Git+GitLab+Repo

1. Installation of Required Components

sudo apt-get update
sudo apt-get install -y curl openssh-server ca-certificates
sudo apt-get install -y postfix
Copy the code

When installing Postfix, use the left and right keys and Enter keys, and select an Internet Site from the drop-down list.

2. Trust GitLab’s GPG public key

curl https://packages.gitlab.com/gpg.key 2> /dev/null | sudo apt-key add - &>/dev/null  
Copy the code

3. Configuring a Mirror Path

If vim is not installed, install it first

vim /etc/apt/sources.list.d/gitlab-ce.list
Copy the code

Gitlab-ce. List:

deb https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/ubuntu xenial main
Copy the code

If the gitlab-ce. List file does not exist, create it and grant permission to the root file.

touch /etc/apt/sources.list.d/gitlab-ce.list
chmod 777 /etc/apt/sources.list.d/gitlab-ce.list
Copy the code

4. Install gitlab – ce

sudo apt-get update
sudo apt-get install gitlab-ce
Copy the code

5. Perform the configuration

sudo gitlab-ctl reconfigure
Copy the code

6. Start the GitLab

sudo gitlab-ctl start
Copy the code

7. Modify external_url

sudo gedit /etc/gitlab/gitlab.rb 
Copy the code

Change the following path:

external_url 'http://gitlab.example.com'
Copy the code

The specific IP address should be changed to your server, for example, I use 192.168.50.10

External_url 'http://192.168.50.10'Copy the code

Be sure to reconfigure and run the configuration command again

sudo gitlab-ctl reconfigure 
Copy the code

8. Visit your GitLab service

Open the browser on any computer in the same network segment only when the computers can communicate with each other. If VMS are used, set the network type to Bridge and configure VMS in the same network segment to communicate with each other.

Enter http://192.168.50.10 in the browser address bar (use your own URL instead).

You can then create user root, enter the password and confirm. Register other users and so on.

There are too many repositories in the source code to create one by one in the browser, so you need to automate this with the python-Gitlab library. Place default.xml in the same directory as the script and run it. Waiting for the completion of the warehouse, a bit time-consuming, maybe half an hour. If python-Gitlab is not installed, it can be installed with PIP.

The script contains the name of the parent group (Android6NewC), which needs to be created in the GitLab web page. To generate Tokens, go to GitLab Settings -> Access Tokens -> Add a Personal Access token.

AndroidSourceCodeGitlabManager.py

#! /usr/bin/python3

import gitlab
import os
import re
import time

MANIFEST_XML = "default.xml"
ROOT = os.getcwd()
ROOT_GROUP = "Android6NewC"
MANIFEST_XML_PATH_NAME_RE = re.compile(r"
      
       [^\"]+)\"\s+name=\"(? P
       
        [^\"]+)\"\s+/>"
       
      \s+path=\"(?>,
                                       re.DOTALL)

gl = gitlab.Gitlab('http://192.168.50.10/', private_token='xxxxxxx')

manifest_xml_project_paths = []


def parse_repo_manifest() :
    with open(os.path.join(ROOT, MANIFEST_XML), "rb") as strReader:
        for line in strReader:
            if line is not None and len(line) ! =0:
                this_temp_line = line.decode()
                if line.find("path".encode(encoding="utf-8")):

                    s = MANIFEST_XML_PATH_NAME_RE.search(this_temp_line)

                    if s is not None:
                        manifest_xml_project_paths.append(s.group("path"))

    print("manifest_xml_project_paths=" + str(manifest_xml_project_paths))
    print("manifest_xml_project_paths len=" + str(len(manifest_xml_project_paths)))


def create_group_and_project() :
    all_groups = gl.groups.list(all=True)
    print("all_groups=" + str(all_groups))
    group_parent = None

    for g in all_groups:
        if g.name == ROOT_GROUP:
            group_parent = g
            break
    print("group parent=" + str(group_parent))

    for path in manifest_xml_project_paths:
        print("path=" + path)
        paths = path.split("/")
        print("paths=" + str(paths))

        last_path_index = len(paths) - 1

        group = group_parent
        for index in range(0, last_path_index):
            p = paths[index]
            print("p=" + p)
            # is the group exist
            print("parent group=" + group.name)
            try:
                all_groups = group.subgroups.list(all=True)
            except AttributeError:
                all_groups = []
                print("AttributeError: clear all subgroups")

            is_group_exist = False
            for g in all_groups:
                if g.name == p:
                    is_group_exist = True
                    group = g
                    print("group exist=" + g.name)
                    break
            if is_group_exist:
                continue
            # create subgroup
            data = {
                "name": p,
                "path": p,
                "parent_id": group.id
            }

            try:
                group = gl.groups.create(data)
                print("group create success name=" + p)
                time.sleep(1)
            except gitlab.exceptions.GitlabCreateError as e:
                if e.response_code == 400:
                    print("group:" + p + " has already been created")

                    query_groups = gl.groups.list(all=True)
                    print("query_groups:" + str(query_groups))
                    for query_group in query_groups:
                        if query_group.name == p and query_group.parent_id == group.id:
                            group = query_group
                            print("update exit group:" + group.name)
                            break

        project = paths[last_path_index]
        print("group project list group=" + group.name)
        real_group = gl.groups.get(group.id, lazy=True)
        all_projects = real_group.projects.list(all=True)
        print("group all projects=" + str(all_projects))
        is_project_exist = False
        for p in all_projects:
            if p.name == project:
                is_project_exist = True
                print("project exist=" + p.name)
                break
        if not is_project_exist:
            print("create project=" + project)
            gl.projects.create({'name': project, 'path': project, 'namespace_id': group.id})
            print("project create success name=" + project)
            time.sleep(1)


def test_create_project_with_dot_name() :
    # need use path field, if don't use path, GitLab url will replace "." to "_"
    gl.projects.create({'name': "xxx.yy.xy".'path': "xxx.yy.xy"})


if __name__ == '__main__':
    parse_repo_manifest()
    create_group_and_project()
Copy the code

The basic working principle of the script is relatively simple. It parses the project tag in default. XML to get path through regular expression, creates groups (including subgroups) according to path, and finally creates project.

When the script runs correctly, output looks like the following:

. path=external/mtd-utils paths=['external', 'mtd-utils'] p=external parent group=Android6NewC group exist=external group project list group=external group all projects=[...]  create project=mtd-utils project create success name=mtd-utils ...... Process finished with exit code 0Copy the code

After the script runs, take a look at the GitLab group page and generate the directory structure we need.

Use the following command to install Git on Ubuntu 14.04 LTS

apt-get install git
Copy the code

If Git version 2.7.4 is displayed, the installation is successful.

git --version
Copy the code

Git globally configures the user name and mailbox

git config --global user.name "xxx"
git config --global user.email "xxx email address"
Copy the code

Generate the SSH key

ssh-keygen -t ed25519 -C "xxx email address"
Copy the code

The generated message is as follows. Sensitive information has been removed from the generated message. Your generated message will change.

Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/captain/.ssh/id_ed25519):         
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/captain/.ssh/id_ed25519.
Your public key has been saved in /home/captain/.ssh/id_ed25519.pub.
The key fingerprint is:
xxxxxx xxx email address
The key's randomart image is:
+--[ED25519  256--+
|      =          |
|     x *         |
|    . x x        |
|   xo            |
|  * o = S o      |
| o = x o x       |
|  x o.4 .        |
|      x+         |
|     xx          |
+-----------------+
Copy the code

See the SSH key

cat /home/captain/.ssh/id_ed25519.pub
Copy the code

The following information is displayed

ssh-ed25519 AAAAC3NzaC1lZXXXXXXXXXXXXXXsULA48NC2f+oOLf5EoFSpn4 xxx email address
Copy the code

Add SSH key in GitLab. Paste the above key into Settings -> SSH Keys -> Add an SSH key.

Push is stored in the source folder project to the repository. Here is an example where the script actually wraps these commands.

This requires the development of a script to execute, again in Python implementation, must be careful to switch to the working path, otherwise the pit, of course, the script has fixed the bug.

PushAndroidSourceCode2GitLab.py

Clone a copy of the REPo to a computer with Internet access.

git clone https://github.com/GerritCodeReview/git-repo.git
Copy the code

Then wrap it up

tar cvf git-repo.tar git-repo/
Copy the code

Copy git-repo.tar to the Intranet PC and decompress it.

tar xvf git-repo.tar
Copy the code

Delete.git from git-repo/.

Create a Git-repo project under the Android-tools group. And push git-repo there.

Create a local branch for all repositories with an arbitrary branch name dev.

repo start dev --all
Copy the code

Submit code to remote.

git add .
git commit -m "xxx"
git push aosp dev
Copy the code

Git push < remote host name > < local branch name > will create a dev branch at the remote creation and request merge.

Git branch -a is the name of the remote repository.

Repo upload. (note the dot at the end) is not available because we have not configured the Gerrit server.

Alternatively, the code can be synchronized using the pull command.

git pull --rebase
Copy the code

Advanced usage

Repo forall -c XXX executes the commands specified by -c on all warehouses

repo forall -c git add .
repo forall -c git commit -m "xxx"
repo forall -c git pull --rebase
repo forall -c git push aosp dev
Copy the code

The following figure is the result of a default.xml FETCH configuration error.

git commit

Git: ‘Interpret – Trailers’ is not a Git command. See’ git –help ‘.

cannot insert change-id line in .git/COMMIT_EDITMSG

Update with the following command

sudo add-apt-repository ppa:git-core/ppa
sudo apt-get update
sudo apt-get install git
Copy the code