Initial Commit

Author: orleonbatista

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Orleon Batista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,58 @@
-# migration-gitlab
+# GitLab Migration Tool
+
+## Overview
+The GitLab Migration Tool is a versatile Python program designed to facilitate seamless migration and management of projects between GitLab instances. Whether you're transferring projects from one GitLab environment to another or managing project variables, this tool streamlines the process with efficiency and reliability.
+
+## Key Features
+
+1. **Rate Limit Manager**: The Rate Limit Manager ensures optimal performance by controlling the number of API requests made within specified intervals, preventing the program from exceeding GitLab API rate limits.
+
+2. **GitLab Integration**: Seamlessly integrate with GitLab APIs to export and import projects between GitLab instances. Enjoy smooth project migration while preserving data integrity.
+
+3. **Project Export/Import**: Effortlessly export projects from a source GitLab instance and import them into a destination instance. Transfer code, issues, milestones, and more between GitLab environments with ease.
+
+4. **Project Variable Management**: Manage project variables effectively by transferring variables between GitLab projects. Customize project configurations and settings during migration or replication.
+
+5. **Shared Runners Management**: Enable shared runners for projects.
+
+6. **Configurable Settings**: Easily configure the program's behavior using the `config.json` file. Specify GitLab URLs, access tokens, group IDs, and project mappings to adapt to different GitLab environments.
+
+7. **Testing Framework**: Ensure code quality and reliability with the included testing framework. Verify functionality and prevent regressions during development with comprehensive testing capabilities.
+
+8. **Cross-Platform Compatibility**: Enjoy the versatility of running the program on multiple platforms, including Linux, macOS, and Windows. Experience broad compatibility for diverse computing environments.
+
+## Installation
+1. Clone the repository: `git clone https://github.com/username/repository.git`
+2. Navigate to the project directory: `cd project_name`
+3. Install dependencies: `pip install -r requirements.txt`
+
+## Usage
+1. Create a new `config.json` file in the root directory of the project.
+2. Add the necessary configuration parameters to `config.json`.
+3. Run the main script: `python src/main.py`
+
+## Configuration File (`config.json`)
+Example `config.json` structure:
+```json
+{
+  "token_info": {
+    "src_gitlab_url": "https://source.gitlab.com",
+    "src_gitlab_access_token": "your-source-access-token",
+    "dest_gitlab_url": "https://destination.gitlab.com",
+    "dest_gitlab_access_token": "your-destination-access-token",
+    "group_id": 123
+  },
+  "projects": [
+    {
+      "src_project_id": 456
+    },
+    {
+      "src_project_id": 789
+    }
+  ]
+}
+```
+
+## License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

__init__.py

@@ -0,0 +1,3 @@
+requests==2.26.0
+pytest==6.2.4
+json

requirements.txt

@@ -0,0 +1,44 @@
+import os
+from RateLimitManager import RateLimitManager
+
+class GitLab:
+    """
+    Class for interacting with GitLab.
+    """
+
+    def __init__(self, gitlab_url, gitlab_access_token):
+        """
+        Initializes the GitLab class with GitLab URL and access token.
+
+        Args:
+            gitlab_url (str): The GitLab URL.
+            gitlab_access_token (str): The GitLab access token.
+        """
+        self.gitlab_url = gitlab_url
+        self.gitlab_access_token = gitlab_access_token
+
+    def import_project(self, file_path, group_id):
+        """
+        Imports a project to GitLab.
+
+        Args:
+            file_path (str): The path of the exported file.
+            group_id (int): The ID of the group to import the project.
+
+        Returns:
+            dict: The imported project data.
+        """
+        base_url = f"{self.gitlab_url}/api/v4"
+        import_url = f"{base_url}/projects/import"
+        params = {"path": os.path.basename(file_path).split(".")[0], "namespace": group_id}
+        headers = {"PRIVATE-TOKEN": self.gitlab_access_token}
+        files = {"file": open(file_path, "rb")}
+
+        response = RateLimitManager().make_request(import_url, "POST", headers=headers, data=params, files=files)
+
+        if response.status_code == 201:
+            print(f"Project imported successfully. It will be available in a few seconds. Status code: {response.status_code}")
+            return response.json()
+        else:
+            print(f"Failed to import project. Status code: {response.status_code}")
+            return None

src/GitLab.py

@@ -0,0 +1,78 @@
+import os
+import time
+from RateLimitManager import RateLimitManager
+
+class GitLabProject:
+    """
+    Class to manage GitLab projects.
+    """
+    
+    def __init__(self, project_id, gitlab_url, gitlab_access_token):
+        """
+        Initializes the GitLabProject class with project ID, GitLab URL, and access token.
+
+        Args:
+            project_id (int): The project ID.
+            gitlab_url (str): The GitLab URL.
+            gitlab_access_token (str): The GitLab access token.
+        """
+        self.project_id = project_id
+        self.gitlab_url = gitlab_url
+        self.gitlab_access_token = gitlab_access_token
+
+    def export_project(self):
+        """
+        Exports a project from GitLab.
+
+        Returns:
+            str: The path of the exported file.
+        """
+        base_url = f"{self.gitlab_url}/api/v4"
+        export_url = f"{base_url}/projects/{self.project_id}/export"
+        payload = {"upload[http_method]": "PUT"}
+        headers = {"PRIVATE-TOKEN": self.gitlab_access_token}
+
+        response = RateLimitManager().make_request(export_url, "POST", headers=headers, data=payload)
+
+        if response.status_code == 202:
+            print("Project export initiated successfully.")
+        else:
+            print(f"Failed to initiate project export. Status code: {response.status_code}")
+            return None
+
+        export_status_url = f"{base_url}/projects/{self.project_id}/export"
+        export_status = None
+
+        while export_status != "finished":
+            time.sleep(5)
+            status_response = RateLimitManager().make_request(export_status_url, "GET", headers=headers)
+
+            if status_response.status_code == 200:
+                export_status = status_response.json().get("export_status")
+                if export_status == "finished":
+                    download_url = status_response.json().get("_links").get("api_url")
+                    project_name = status_response.json().get("name")
+                    break
+                else:
+                    print("Project export still in progress. Status:", export_status)
+            else:
+                print(f"Failed to get export status. Status code: {status_response.status_code}")
+                return None
+
+        export_dir = "./exports"
+        if not os.path.exists(export_dir):
+            os.makedirs(export_dir)
+
+        print("Project export completed. Downloading the exported file...")
+
+        export_response = RateLimitManager().make_request(download_url, "GET", headers=headers)
+        if export_response.status_code == 200:
+            file_path = os.path.join(export_dir, f"{project_name}.tar.gz")
+            with open(file_path, "wb") as file:
+                file.write(export_response.content)
+
+            print(f"Exported file downloaded as '{file_path}'.")
+            return file_path
+        else:
+            print(f"Failed to download the exported file. Status code: {export_response.status_code}")
+            return None

src/GitLabProject.py

@@ -0,0 +1,56 @@
+from RateLimitManager import RateLimitManager
+
+class ProjectVariableManager:
+    """
+    Class to manage project variables in GitLab.
+    """
+
+    def __init__(self, src_gitlab_url, src_gitlab_access_token, dest_gitlab_url, dest_gitlab_access_token):
+        """
+        Initializes the ProjectVariableManager class with source and destination GitLab URLs and access tokens.
+
+        Args:
+            src_gitlab_url (str): The source GitLab URL.
+            src_gitlab_access_token (str): The source GitLab access token.
+            dest_gitlab_url (str): The destination GitLab URL.
+            dest_gitlab_access_token (str): The destination GitLab access token.
+        """
+        self.src_gitlab_url = src_gitlab_url
+        self.src_gitlab_access_token = src_gitlab_access_token
+        self.dest_gitlab_url = dest_gitlab_url
+        self.dest_gitlab_access_token = dest_gitlab_access_token
+
+    def get_project_variables(self, project_id):
+        """
+        Gets variables of a project.
+
+        Args:
+            project_id (int): The project ID.
+
+        Returns:
+            list: A list of project variables.
+        """
+        url = f"{self.src_gitlab_url}/api/v4/projects/{project_id}/variables"
+        headers = {"PRIVATE-TOKEN": self.src_gitlab_access_token}
+        response = RateLimitManager().make_request(url, "GET", headers=headers)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print("Failed to fetch project variables.")
+            return None
+
+    def create_project_variable(self, project_id, variable):
+        """
+        Creates a variable in a project.
+
+        Args:
+            project_id (int): The project ID.
+            variable (dict): The data of the variable to be created.
+        """
+        url = f"{self.dest_gitlab_url}/api/v4/projects/{project_id}/variables"
+        headers = {"PRIVATE-TOKEN": self.dest_gitlab_access_token}
+        response = RateLimitManager().make_request(url, "POST", headers=headers, data=variable)
+        if response.status_code == 201:
+            print(f"Variable {variable['key']} created successfully.")
+        else:
+            print(f"Failed to create variable {variable['key']}.")

src/ProjectVariableManager.py

@@ -0,0 +1,32 @@
+import time
+import requests
+
+class RateLimitManager:
+    """
+    Class to manage rate limits for API requests.
+    """
+
+    interval = 60  # 1-minute interval
+    max_requests = 5  # Maximum number of requests per interval
+    requests = 0
+    last_check = time.time()
+
+    @classmethod
+    def check_rate_limit(cls):
+        current_time = time.time()
+        if current_time - cls.last_check > cls.interval:
+            cls.requests = 0
+            cls.last_check = current_time
+
+    @classmethod
+    def make_request(cls, url, method, headers=None, data=None, files=None):
+        cls.check_rate_limit()
+        if cls.requests >= cls.max_requests:
+            wait_time = cls.interval - (time.time() - cls.last_check)
+            print(f"Waiting {wait_time:.1f} seconds to avoid rate limit exceedance...")
+            time.sleep(wait_time)
+            cls.check_rate_limit()
+
+        response = requests.request(method, url, headers=headers, data=data, files=files)
+        cls.requests += 1
+        return response

src/RateLimitManager.py

@@ -0,0 +1,46 @@
+import json
+from RateLimitManager import RateLimitManager
+
+class RunnerManager:
+    """
+    Class to manage shared runners for GitLab projects.
+    """
+
+    def __init__(self, gitlab_url, access_token):
+        """
+        Initializes the RunnerManager class with the GitLab URL and access token.
+
+        Args:
+            gitlab_url (str): The GitLab URL.
+            access_token (str): The GitLab access token.
+        """
+        self.gitlab_url = gitlab_url
+        self.access_token = access_token
+
+    def enable_shared_runners(self, project_id):
+        """
+        Enable shared runners for a specified project.
+
+        Args:
+            project_id (int): The project ID.
+
+        Returns:
+            dict: The response from the GitLab API.
+        """
+        url = f"{self.gitlab_url}/api/v4/projects/{project_id}"
+        headers = {
+            "PRIVATE-TOKEN": self.access_token,
+            "Content-Type": "application/json"
+        }
+        data = {
+            "shared_runners_enabled": True
+        }
+
+        response = RateLimitManager().make_request(url, "PUT", headers=headers, data=json.dumps(data))
+
+        if response.status_code == 200:
+            print("Shared runners enabled successfully.")
+            return response
+        else:
+            print(f"Failed to enable shared runners: {response.status_code} - {response.reason}")
+            return None