python脚本（三）

add_suff.py
批量添加文件后缀

import os

def rename_files_with_suffix(directory, suffix="_V1.00"):
    for filename in os.listdir(directory):
            if filename.count('.')==2:
                continue
            new_filename = filename.split('.')[0]+suffix+'.'+filename.split('.')[1]
            source = os.path.join(directory, filename)
            destination = os.path.join(directory, new_filename)
            os.rename(source, destination)

rename_files_with_suffix("C:\\Users\\Desktop\\test")  # 替换为你的文件夹路径

get_gitlab_project_member.py
查询gitlab信息

import requests

# 设置 GitLab 的 API 地址和访问令牌
URL = 'https://gitlab'
ACCESS_TOKEN = ''
user_id=4694


# 获取用户的访问令牌
# def get_user_access_token(user_login):
#     url = f"{GITLAB_URL}/oauth/token?grant_type=password&client_id=client_id&client_secret=client_secret&username={user_login}&password=password"
#     response = requests.post(url)
#     return response.json()['access_token']


#添加仓库管理员权限
def add_repository_admin(id,level):
    url = f"{URL}/api/v4/projects/{id}/members"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'user_id': user_id, 'access_level': level}
    response = requests.post(url, headers=headers, data=data)
    print(response.json())

def update_repository_admin(id):
    url = f"{URL}/api/v4/projects/{id}/members/{user_id}"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'access_level': 20}
    response = requests.put(url, headers=headers, data=data)
    print(response.json())

def convert(access_level):
    if access_level==10:
        return "Guest"
    if access_level==20:
        return "Reporter"
    if access_level==30:
        return "Developer"
    if access_level==40:
        return "Maintainer"
    return "other"

def query_project_members(id):
    #url = f"{URL}/api/v4/user"
    #url = f"{URL}/api/v4/projects/9615/repository/branches"
    #url = f"{URL}/api/v4/projects/9615"
    url = f"{URL}/api/v4/projects/{id}/members"
    headers = {'Private-Token': ACCESS_TOKEN}
    response = requests.get(url, headers=headers)
    # print(response.json())
    for user_info in response.json():
        # print(user_info)
        print(user_info['username']+" "+convert(user_info['access_level']))

def query_project_by_name(name):
    url = f"{URL}/api/v4/projects/"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'search': name}
    response = requests.get(url, headers=headers,data=data)
    for project_info in response.json():
        print(str(project_info['id'])+" "+project_info['name'])

def query_group_by_name(name):
    url = f"{URL}/api/v4/group/"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'search': name}
    response = requests.get(url, headers=headers,data=data)
    print(response.json())
    # for project_info in response.json():
    #     print(str(project_info['id'])+" "+project_info['name'])

def get_mr_id(id,source_branch,target_branch):
    url = f"{URL}/api/v4/projects/{id}/merge_requests"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'state': 'opened',
            'source_branch':source_branch,
            'target_branch':target_branch}
    response = requests.get(url, headers=headers, data=data)
    print(response.json())
    return response.json()[0]['iid']

def query_project_info(id):
    url = f"{URL}/api/v4/projects/{id}"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'id': id}
    response = requests.get(url, headers=headers,data=data)
    print(response.json())

def query_project_webhook_info(id):
    url = f"{URL}/api/v4/projects/{id}/hooks"
    headers = {'Private-Token': ACCESS_TOKEN}
    response = requests.get(url, headers=headers)
    print(response.json())

def query_system_webhook():
    url = f"{URL}/api/v4/hooks"
    headers = {'Private-Token': ACCESS_TOKEN}
    response = requests.get(url, headers=headers)
    print(response.json())

def query_group_projects(id):
    url = f"{URL}/api/v4/groups/{id}/projects"
    headers = {'Private-Token': ACCESS_TOKEN}
    data = {'per_page': 50}
    response = requests.get(url, headers=headers)
    # print(response.json())
    for proj in response.json():
        print(proj)

def query_user(username):
    url = f"{URL}/api/v4/users"
    headers = {'Private-Token': ACCESS_TOKEN}
    #,'blocked':True
    data = {'username': username}
    response = requests.get(url, headers=headers, data=data)
    print(response.json())

#query_project_info(10300)
#query_project_webhook_info(9586)
# query_system_webhook()
#add_repository_admin(8734,30)
#update_repository_admin(9911)
#query_project_by_name('aidisdk')
#query_project_members(7624)
# query_group_projects(2661)
#query_user('')
# print(get_mr_id(9615,"feat-test1","master"))
# query_group_by_name("gallery")

get_all_project_id_from_group.py
从组的id递归获取所有project id

import gitlab

def group_search_repo(group_id):
    group = gl.groups.get(group_id)
    project_ids = []

    # 获取当前组的所有项目ID
    for project in group.projects.list(all=True):
        project_ids.append(project.id)
    #print(project_ids)

        # 遍历当前组的所有子组
    for subgroup in group.subgroups.list(all=True):
        # 递归调用以获取子组中的所有项目ID
        project_ids.extend(group_search_repo(subgroup.id))

    return project_ids
def get_all_project_ids(group, gl):
    project_ids = []

    # 获取当前组的所有项目ID
    for project in group.projects.list(all=True):
        project_ids.append(project.id)
    #print(project_ids)

        # 遍历当前组的所有子组
    for subgroup in group.subgroups.list(all=True):
        # 使用子组的ID获取完整的子组对象
        full_subgroup = gl.groups.get(subgroup.id)
        # 递归调用以获取子组中的所有项目ID
        project_ids.extend(get_all_project_ids(full_subgroup, gl))

    return project_ids

def group_search_repo_url(group_id):
    group = gl.groups.get(group_id)
    project_urls = []  # 改变变量名以反映现在存储的是URLs

    # 获取当前组的所有项目URL
    for project in group.projects.list(all=True):
        # print(project.web_url)
        project_urls.append(project.web_url)

    # 遍历当前组的所有子组
    for subgroup in group.subgroups.list(all=True):
        # 递归调用以获取子组中所有项目的URL
        project_urls.extend(group_search_repo_url(subgroup.id))

    # print(project_urls)
    return project_urls


# 从配置文件中加载 GitLab 实例
gl = gitlab.Gitlab.from_config('trigger', ['python-gitlab.cfg'])

gl.auth()
# 假设你知道组ID
group_id = '12900'

# 获取组对象
try:
    group = gl.groups.get(group_id)
except gitlab.exceptions.GitlabGetError as e:
    print(f"Error retrieving group with ID {group_id}: {e}")
    exit()

# 调用函数获取所有项目ID
# all_project_ids = get_all_project_ids(group, gl)
# print(len(all_project_ids))

# all_project_ids1=group_search_repo(group_id)
# print(len(all_project_ids1))
# 打印所有项目ID
# for project_id in all_project_ids:
#     print(project_id)

all_project_urls=group_search_repo_url(group_id)
print(len(all_project_urls))
for project_id in all_project_urls:
    print(project_id)

get_project_id_from_url.py
从gitlab url得到id

import re

import gitlab

# GitLab的URL和授权令牌
gitlab_url = 'https://gitlab.hobot.cc'
gitlab_token = ''
gitlab_prefix = "git@gitlab.hobot.cc"

# 初始化GitLab连接
gl = gitlab.Gitlab(url=gitlab_url, private_token=gitlab_token)
gl.auth()  # 进行安全认证

def convert_http_to_git(url):
    url=url.strip()
    if ".git" not in url:
        url+='.git'

    pattern = gitlab_url + '/(.*)/(.*).git'
    match = re.search(pattern, url)
    if match:
        return gitlab_prefix + f':{match.group(1)}/{match.group(2)}.git'
    else:
        return url


ssh_address = ""

# 使用split方法分隔字符串，以冒号为分隔符
line =convert_http_to_git(ssh_address)
repository_path=line.split(':')[-1].split('.git')[0]
print(repository_path)


# # 通过完整路径获取项目
try:
    project = gl.projects.get(repository_path)
    print(f"仓库ID: {project.id}")
except gitlab.exceptions.GitlabGetError as e:
    print(f"无法获取仓库信息: {e}")

branch_sync.py
同步gitlab仓库分支
分别复制clonewith ssh,粘贴至A、B位置,并填写对应分支至至
src_branch、dst_branch,按需编写sync_conf.yml文件中的其它各项参数。

• sync:
  proposer: xxx
  project: xxx
  src_repo: A [注:源仓库]
  src_branch:
  dst_repo: B [注:目标仓库]
  dst_branch:
  【注】branch与对应的repo一致且真实存在,不可为空,sro_branch与
  dst_branch不要求内容一致。

import yaml
import threading
import os
import subprocess
import shutil
import sys
import logging

logging.basicConfig(level=logging.INFO, format=' %(asctime)s - %(levelname)s - %(message)s')

try:
    from yaml import CLoader as Loader, CDumper as Dumper
except ImportError:
    from yaml import Loader, Dumper

class SyncBranch():
    def __init__(self):
        self.sync_conf = 'sync_conf.yml'
        self.sync_list = self.read_yaml()
        self.sync_thread_num = 1
        self.tmp_repo = 'tmp_repo'
        self.exec_result = True

    def read_yaml(self):
        f_obj = open(self.sync_conf, 'r')
        f_obj_data = f_obj.read()
        yaml_data = yaml.load(f_obj_data, Loader=Loader)
        f_obj.close()
        return yaml_data

    def remove_folder(self, folder):
        if os.path.exists(folder):
            shutil.rmtree(folder)

    def run_thread(self, name):
        repo_folder = self.tmp_repo + '/' + name
        print(self.sync_list)
        while True:
            try:
                one_sync = self.sync_list.pop()
            except Exception as e:
                print(e)
                if len(self.sync_list) == 0:
                    break
                continue
            print(one_sync)
            self.remove_folder(repo_folder)
            try:
                proposer = one_sync['sync']['proposer']
                project = one_sync['sync']['project']
                src_repo = one_sync['sync']['src_repo']
                src_branch = one_sync['sync']['src_branch']
                dst_repo = one_sync['sync']['dst_repo']
                dst_branch = one_sync['sync']['dst_branch']
            except Exception as e:
                print(e)
                self.exec_result = False
                continue
            # temp rule
            #if dst_repo.find('gitlab.hobot.cc:ptd/') > 0:
            #   continue
            command_git_clone = 'git clone -b %s %s %s' % (src_branch, src_repo, repo_folder)
            logging.info("git clone -b {} {} {}".format(src_branch, src_repo, repo_folder))
            if not self.runcmd(command_git_clone, dst_repo, dst_branch):
                continue
            command_add_remote = 'cd %s;git remote add upstream %s' % (repo_folder, dst_repo)
            logging.info('cd {};git remote add upstream {}'.format(repo_folder, dst_repo))
            if not self.runcmd(command_add_remote, dst_repo, dst_branch):
                continue
            command_fetch_upstream = 'cd %s;git fetch upstream' % (repo_folder)
            logging.info('cd {};git fetch upstream'.format(repo_folder))
            if not self.runcmd(command_fetch_upstream, dst_repo, dst_branch):
                continue
            command_set_upstream = 'cd %s;git branch %s --set-upstream-to=upstream/%s' % (repo_folder, src_branch, dst_branch)
            logging.info('cd {};git branch {} --set-upstream-to=upstream/{}'.format(repo_folder, src_branch, dst_branch))
            if not self.runcmd(command_set_upstream, dst_repo, dst_branch):
                continue
            command_set_upstream = 'cd %s;git branch -m %s' % (repo_folder, dst_branch)
            logging.info('cd {};git branch -m {}'.format(repo_folder, dst_branch))
            if not self.runcmd(command_set_upstream, dst_repo, dst_branch):
                continue
            command_push_force = 'cd %s;git push -f upstream %s' % (repo_folder, dst_branch)
            logging.info('cd {};git push -f upstream {}'.format(repo_folder, dst_branch))
            if not self.runcmd(command_push_force, dst_repo, dst_branch):
                continue 

    def runcmd(self, command, dst_repo, dst_branch):
        #print('run cmd---- ', command)
        try:
            ret = subprocess.run(command,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
        except Exception as e:
            print(e)
            self.exec_result = False
            return False
        if ret.returncode != 0:
            #print('error', command, ret.stdout)
            logging.error("error:",command, ret.returncode)
            logging.error("error: dst repo: {}, dst branch: {}, sync failed".format(dst_repo, dst_branch))
            #sys.exit(1)
            self.exec_result = False
            return False
        return True

    def parse_yaml_thread(self):
        self.remove_folder(self.tmp_repo)
        os.mkdir(self.tmp_repo)
        threadLock = threading.Lock()
        threads = list()
        for i in range(self.sync_thread_num):
            tr = threading.Thread(target=self.run_thread, args=(str(i)))
            threads.append(tr)
        for i in threads:
            i.start()
        for i in threads:
            i.join()

def main():
    sync_branch = SyncBranch()
    sync_branch.parse_yaml_thread()
    if not sync_branch.exec_result:
        print('exec fail')
        sys.exit(1)

if __name__ == "__main__":
    main()

sync_conf.yml

 - sync:
    proposer: xxx
    project: xxx
    src_repo: git@gitlab.test.cc:ptd/xxx.git
    src_branch: x
    dst_repo: git@gitlab.test.cc:ptd/xxx.git
    dst_branch: x