Integrate gitbeaker API into client codebase

.gitignore

@@ -164,4 +164,4 @@ runner.yml
 .workspace
 
 # command scripts for runner
-servers/execution/runner/lifecycle*
+servers/execution/runner/lifecycle*

client/config/local.js

@@ -16,4 +16,4 @@ if (typeof window !== 'undefined') {
     REACT_APP_LOGOUT_REDIRECT_URI: 'http://localhost/',
     REACT_APP_GITLAB_SCOPES: 'openid profile read_user read_repository api',
   };
-};
+};

client/package.json

@@ -44,6 +44,7 @@
     "@emotion/react": "^11.11.1",
     "@emotion/styled": "^11.11.0",
     "@fontsource/roboto": "^5.0.8",
+    "@gitbeaker/rest": "^40.1.2",
     "@mui/icons-material": "^5.14.8",
     "@mui/material": "^5.14.8",
     "@reduxjs/toolkit": "^1.9.7",
@@ -106,4 +107,4 @@
       "last 1 safari version"
     ]
   }
-}
+}

client/src/util/gitlab.ts

@@ -0,0 +1,83 @@
+    import { Gitlab } from '@gitbeaker/rest';
+
+    interface LogEntry {
+        status: string;
+        DTName: string;
+        runnerTag: string;
+        error?: Error;
+    }
+
+    interface FolderEntry {
+        name: string;
+        path: string;
+    }
+
+    class GitlabInstance {
+        public username: string;
+        public api: InstanceType<typeof Gitlab>;
+        public logs: LogEntry[];
+        public subfolders: FolderEntry[] = [];
+
+        constructor() {
+            this.username = 'user1';
+            this.api = new Gitlab({
+                host: 'https://gitlab.com',
+                token: 'glpat-CJknCUBMj8hSC3oibyxS'
+            });
+            this.logs = [];
+        }
+
+        async getProjectId(): Promise<number | null> {
+            const groupPath = 'DTaaS';
+            try {
+                const group = await this.api.Groups.show(groupPath);
+                const projects = await this.api.Groups.allProjects(group.id);
+                const project = projects.find(proj => proj.name === this.username);
+                if (project) {
+                    return project.id;
+                }
+                return null;
+            } catch (error) {
+                return null;
+            }
+        }  
+
+        async getTriggerToken(projectId: number): Promise<string | null> {
+            try {
+                const triggers = await this.api.PipelineTriggerTokens.all(projectId);
+                if (triggers) {
+                    return triggers[0].token;
+                } 
+                return null;
+            } catch (error) {
+                return null;
+            }
+        }
+
+        async getDTSubfolders(projectId: number): Promise<FolderEntry[]> {
+            const folderPath = 'digital_twins';
+            try {
+                const files = await this.api.Repositories.allRepositoryTrees(projectId, {
+                    path: folderPath,
+                    recursive: false,
+                });
+
+                this.subfolders = files
+                    .filter(file => file.type === 'tree' && file.path !== folderPath)
+                    .map(file => ({
+                        name: file.name,
+                        path: file.path
+                    }));
+
+                return this.subfolders;
+            } catch (error) {
+                return [];
+            }
+        }
+
+        executionLogs(): LogEntry[] {
+            return this.logs;
+        }
+    }
+
+    export default GitlabInstance;

client/src/util/gitlabDigitalTwin.ts

@@ -0,0 +1,53 @@
+import GitlabInstance from './gitlab';
+
+class DigitalTwin {
+    public DTName: string;
+    public gitlabInstance: GitlabInstance;
+    private lastExecutionStatus: string | null = null;
+
+    constructor(DTName: string, gitlabInstance: GitlabInstance) {
+        this.DTName = DTName;
+        this.gitlabInstance = gitlabInstance;
+    }
+
+    async execute(runnerTag: string): Promise<boolean> {
+        const projectId = await this.gitlabInstance.getProjectId();
+        if (projectId === null) {
+            this.lastExecutionStatus = 'error';
+            return false;
+        }
+
+        const triggerToken = await this.gitlabInstance.getTriggerToken(projectId);
+        if (triggerToken === null) {
+            this.lastExecutionStatus = 'error'; 
+            return false;
+        }
+
+        const variables = {
+            DTName: this.DTName,
+            RunnerTag: runnerTag,
+        }
+
+        try {
+            await this.gitlabInstance.api.PipelineTriggerTokens.trigger(
+                projectId,
+                'main', 
+                triggerToken,
+                { variables }
+            );
+            this.gitlabInstance.logs.push({ status: 'success', DTName: this.DTName, runnerTag: runnerTag });
+            this.lastExecutionStatus = 'success';
+            return true;
+        } catch (error) {
+            this.gitlabInstance.logs.push({ status: 'error', error: error instanceof Error ? error : new Error(String(error)), DTName: this.DTName, runnerTag: runnerTag });
+            this.lastExecutionStatus = 'error'; 
+            return false;
+        }
+    }
+
+    executionStatus(): string | null {
+        return this.lastExecutionStatus;
+    }
+}
+
+export default DigitalTwin;

client/src/util/gitlabDriver.ts

@@ -0,0 +1,40 @@
+import GitlabInstance from './gitlab';
+import DigitalTwin from './gitlabDigitalTwin';
+
+class GitlabDriver {
+    public static async run(): Promise<void> {
+        const gitlabInstance = new GitlabInstance();
+        console.log('GitLab username:', gitlabInstance.username);
+        console.log('GitLab logs:', gitlabInstance.logs);
+        console.log('GitLab subfolders:', gitlabInstance.subfolders);
+
+        const projectId = await gitlabInstance.getProjectId() || 0;
+        console.log('Project id:', projectId);
+
+        const subfolders = await gitlabInstance.getDTSubfolders(projectId);
+        console.log('Subfolders:', subfolders);
+
+        const dtName = subfolders[0].name;
+        const runnerTag = 'dtaas';
+
+        const triggerToken = await gitlabInstance.getTriggerToken(projectId);
+        console.log('Trigger token:', triggerToken);
+
+        const digitalTwin = new DigitalTwin(dtName, gitlabInstance);
+        const result = await digitalTwin.execute(runnerTag);
+
+        console.log('Execution Result:', result);
+
+        const lastExecutionStatus = digitalTwin.executionStatus();
+        console.log('Execution Status:', lastExecutionStatus);
+
+        const logs = gitlabInstance.executionLogs();
+        console.log('Execution Logs:', logs);
+    }
+}
+
+GitlabDriver.run().catch(error => {
+    console.error('Error executing GitlabDriver:', error);
+});
+
+export default GitlabDriver;

client/test/unitTests/Util/gitlab.test.ts

@@ -0,0 +1,135 @@
+import { Gitlab } from '@gitbeaker/rest';
+import { ProjectSchema, PipelineTriggerTokenSchema, GroupSchema, RepositoryTreeSchema } from '@gitbeaker/rest';
+import GitlabInstance from '../../../src/util/gitlab';
+
+const mockApi = {
+    Groups: {
+        show: jest.fn(),
+        allProjects: jest.fn()
+    },
+    PipelineTriggerTokens: {
+        all: jest.fn(),
+        trigger: jest.fn()
+    },
+    Repositories: {
+        allRepositoryTrees: jest.fn()
+    }
+};
+
+describe('GitlabInstance', () => {
+    let gitlab: GitlabInstance;
+
+    beforeEach(() => {
+        gitlab = new GitlabInstance();
+        gitlab.api = mockApi as unknown as InstanceType<typeof Gitlab>;
+    });
+
+    it('should fetch project ID successfully', async () => {
+        mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' } as GroupSchema);
+        mockApi.Groups.allProjects.mockResolvedValue([{ id: 1, name: 'user1' } as ProjectSchema]);
+
+        const projectId = await gitlab.getProjectId();
+
+        expect(projectId).toBe(1);
+        expect(mockApi.Groups.show).toHaveBeenCalledWith('DTaaS');
+        expect(mockApi.Groups.allProjects).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle project ID not found', async () => {
+        mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' } as GroupSchema);
+        mockApi.Groups.allProjects.mockResolvedValue([]);
+
+        const projectId = await gitlab.getProjectId();
+
+        expect(projectId).toBeNull();
+    });
+
+    it('should handle errors fetching project ID', async () => {
+        mockApi.Groups.show.mockRejectedValue(new Error('API error'));
+
+        const projectId = await gitlab.getProjectId();
+
+        expect(projectId).toBeNull();
+    });
+
+    it('should fetch trigger token successfully', async () => {
+        mockApi.PipelineTriggerTokens.all.mockResolvedValue([{ token: 'test-token' } as PipelineTriggerTokenSchema]);
+
+        const token = await gitlab.getTriggerToken(1);
+
+        expect(token).toBe('test-token');
+        expect(mockApi.PipelineTriggerTokens.all).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle no trigger tokens found', async () => {
+        mockApi.PipelineTriggerTokens.all.mockResolvedValue([]);
+
+        const token = await gitlab.getTriggerToken(1);
+
+        expect(token).toBeNull();
+        expect(mockApi.PipelineTriggerTokens.all).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle undefined trigger tokens', async () => {
+        mockApi.PipelineTriggerTokens.all.mockResolvedValue(undefined);
+
+        const token = await gitlab.getTriggerToken(1);
+
+        expect(token).toBeNull();
+    });    
+
+    it('should handle errors fetching trigger token', async () => {
+        mockApi.PipelineTriggerTokens.all.mockRejectedValue(new Error('API error'));
+
+        const token = await gitlab.getTriggerToken(1);
+
+        expect(token).toBeNull();
+        expect(mockApi.PipelineTriggerTokens.all).toHaveBeenCalledWith(1);
+    });
+
+    it('should fetch DT subfolders successfully', async () => {
+        mockApi.Repositories.allRepositoryTrees.mockResolvedValue([
+            { name: 'subfolder1', path: 'digital_twins/subfolder1', type: 'tree' } as RepositoryTreeSchema,
+            { name: 'subfolder2', path: 'digital_twins/subfolder2', type: 'tree' } as RepositoryTreeSchema,
+            { name: 'file1', path: 'digital_twins/file1', type: 'blob' } as RepositoryTreeSchema
+        ]);
+
+        const subfolders = await gitlab.getDTSubfolders(1);
+
+        expect(subfolders).toHaveLength(2);
+        expect(subfolders).toEqual([
+            { name: 'subfolder1', path: 'digital_twins/subfolder1' },
+            { name: 'subfolder2', path: 'digital_twins/subfolder2' }
+        ]);
+        expect(mockApi.Repositories.allRepositoryTrees).toHaveBeenCalledWith(1, {
+            path: 'digital_twins',
+            recursive: false
+        });
+    });
+
+    it('should handle errors fetching DT subfolders', async () => {
+        mockApi.Repositories.allRepositoryTrees.mockRejectedValue(new Error('API error'));
+
+        const subfolders = await gitlab.getDTSubfolders(1);
+
+        expect(subfolders).toEqual([]);
+    });
+
+    it('should return execution logs', () => {
+        const mockLog = {
+            status: 'success',
+            DTName: 'test-DTName',
+            runnerTag: 'test-runnerTag',
+            error: undefined
+        };
+
+        gitlab.logs.push(mockLog);
+
+        const logs = gitlab.executionLogs();
+
+        expect(logs).toHaveLength(1);
+        expect(logs[0].status).toBe('success');
+        expect(logs[0].DTName).toBe('test-DTName');
+        expect(logs[0].runnerTag).toBe('test-runnerTag');
+    });
+});