feat: github repo listing apis & customer's app deploy request

.github/workflows/Build-Deploy-dev.yaml

@@ -23,7 +23,7 @@ jobs:
         with:
           java-version: 17
           distribution: 'oracle'
-      
+
       - name: Setup Gradle 7.6
         uses: gradle/gradle-build-action@v2
         with:
@@ -45,15 +45,15 @@ jobs:
         shell: bash
 
       - name: Build Project
-        run: gradle build
-    
+        run: ./gradlew clean build
+
       ############################################
       ### Start Pushing container image on ECR ###
       ############################################
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v1
         with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} 
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           aws-region: ${{ env.AWS_REGION }}
 
@@ -76,7 +76,7 @@ jobs:
 
           docker push $ECR_REGISTRY/$ECR_REPOSITORY:dev-$DATE
           docker push $ECR_REGISTRY/$ECR_REPOSITORY:dev-latest
-          
+
       #########################################################
       # MAIN # MAIN # MAIN # MAIN # MAIN # MAIN # MAIN # MAIN #
       #########################################################
@@ -92,7 +92,7 @@ jobs:
 
           docker push $ECR_REGISTRY/$ECR_REPOSITORY:main-$DATE
           docker push $ECR_REGISTRY/$ECR_REPOSITORY:main-latest
-      
+
 
   deploy:
     needs: build
@@ -114,7 +114,6 @@ jobs:
             password=$(aws ecr get-login-password --region ${{ env.AWS_REGION }})
             docker login --username AWS --password $password ${{ env.ECR_REGISTRY }}
             docker pull ${{ env.ECR_REGISTRY }}/${{ env.ECR_REPOSITORY }}:dev-latest
-            docker stop ${{ env.ECR_REPOSITORY }}-dev
             docker run --rm -d -p 8081:8080 --name kumo-server-dev ${{ env.ECR_REGISTRY }}/${{ env.ECR_REPOSITORY }}:dev-latest
 
       #########################################################

.github/workflows/Staging.yml

@@ -0,0 +1,62 @@
+name: Build and Push to ECR
+on:
+  push:
+    branches:
+      - staging # Change this to your desired branch
+env:
+  REGION: ap-northeast-2 # Seoul
+
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        name: Set up JDK 17
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          check-latest: true
+
+      - name: make application.yml
+        run: |
+          mkdir ./src/main/resources
+          cd ./src/main/resources
+          touch ./application.yml
+          echo "${{ secrets.YML }}" > ./application.yml
+        shell: bash
+
+      - name: make application-dev.yml
+        run: |
+          cd ./src/main/resources
+          touch ./application-dev.yml
+          echo "${{ secrets.YML_STAGING }}" > ./application-dev.yml
+          cat ./application-dev.yml
+        shell: bash
+
+      - name: Build Spring Boot application
+        run: ./gradlew clean build
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v1
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.REGION }}
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v1
+
+      - name: Build and tag Docker image
+        run: |
+          docker build -t ${{ secrets.ECR_REGISTRY }}/dev:latest .
+
+      - name: Push Docker image to ECR
+        run: |
+          docker push ${{ secrets.ECR_REGISTRY }}/dev:latest

build.gradle

@@ -19,10 +19,12 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.springframework:spring-test:5.3.10'
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     implementation 'org.springframework.boot:spring-boot-starter-web'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
+    testImplementation 'org.springframework.amqp:spring-rabbit-test'
     implementation 'mysql:mysql-connector-java:8.0.33'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
     compileOnly 'org.projectlombok:lombok:1.18.24'
@@ -33,6 +35,13 @@ dependencies {
     implementation group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.2'
     implementation group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.2'
     implementation group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.2'
+
+    implementation "io.hypersistence:hypersistence-utils-hibernate-55:3.5.0"
+    implementation 'org.springdoc:springdoc-openapi-ui:1.6.9'
+    implementation 'software.amazon.awssdk:s3:2.17.112'
+
+    // dependency of rabbitmq
+    implementation 'org.springframework.boot:spring-boot-starter-amqp'
 }
 
 tasks.named('test') {

src/main/java/com/kumofactory/cloud/AppController.java

@@ -1,12 +1,25 @@
 package com.kumofactory.cloud;
 
+import com.kumofactory.cloud.auth.jwt.dto.TokenDto;
+import com.kumofactory.cloud.auth.jwt.provider.JwtTokenProvider;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Required;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
+@RequiredArgsConstructor
 public class AppController {
-  @GetMapping("/")
-  public String checkHealth() {
-    return "success";
-  }
+		private final JwtTokenProvider provider;
+
+		@GetMapping("/")
+		public String checkHealth() {
+				return "success";
+		}
+
+		@GetMapping("/token")
+		public String createMockTest() {
+				TokenDto tokenDto = provider.create("11");
+				return tokenDto.getAccessToken();
+		}
 }

src/main/java/com/kumofactory/cloud/CloudApplication.java

@@ -1,15 +1,21 @@
 package com.kumofactory.cloud;
 
+import com.rabbitmq.client.Channel;
+import com.rabbitmq.client.Connection;
+import com.rabbitmq.client.ConnectionFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.domain.EntityScan;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 
+import java.nio.charset.StandardCharsets;
+
 @SpringBootApplication
 public class CloudApplication {
+		private final static String QUEUE_NAME = "hello";
 
-    public static void main(String[] args) {
-        SpringApplication.run(CloudApplication.class, args);
-    }
+		public static void main(String[] args) {
+				SpringApplication.run(CloudApplication.class, args);
+		}
 
 }

src/main/java/com/kumofactory/cloud/appDeploy/AppDeployController.java

@@ -0,0 +1,56 @@
+package com.kumofactory.cloud.appDeploy;
+
+import com.kumofactory.cloud.appDeploy.dto.BuildRequestDto;
+import com.kumofactory.cloud.appDeploy.dto.GitHubRepoDto;
+import com.kumofactory.cloud.appDeploy.service.BuildRequestService;
+import com.kumofactory.cloud.appDeploy.service.UserRepoService;
+import com.kumofactory.cloud.global.annotation.auth.AuthorizationFromToken;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/build")
+@RequiredArgsConstructor
+@Slf4j
+public class AppDeployController {
+    private final Logger logger = org.slf4j.LoggerFactory.getLogger(AppDeployController.class);
+
+    private final UserRepoService userRepoService;
+    private final BuildRequestService buildRequestService;
+
+    @GetMapping("/list/{org}/repo")
+    @AuthorizationFromToken
+    public List<GitHubRepoDto.RepoInfoDto> listOrgRepo(@PathVariable String org, String userId) {
+        return userRepoService.RequestOrgRepoInfo(org, userId);
+    }
+
+    @GetMapping("/list")
+    @AuthorizationFromToken
+    public GitHubRepoDto.UserDto listUserRepoAndOrgs(String userId) {
+        return userRepoService.RequestUserRepoInfoAndOrgList(userId);
+    }
+
+    @GetMapping("/list/{org}/{repo}/branch")
+    @AuthorizationFromToken
+    public List<String> listRepoBranches(@PathVariable String org, @PathVariable String repo, String userId) {
+        return userRepoService.RequestRepoBranches(org, repo, userId);
+    }
+
+    @GetMapping("/list/{repo}/branch")
+    @AuthorizationFromToken
+    public List<String> listRepoBranches(@PathVariable String repo, String userId) {
+        return userRepoService.RequestRepoBranches(repo, userId);
+    }
+
+    @PostMapping("/deploy")
+    @AuthorizationFromToken
+    public ResponseEntity<String> deployRequest(@RequestBody BuildRequestDto request, String userId) {
+        buildRequestService.RequestBuild(request, userId);
+        return ResponseEntity.ok("success");
+    }
+}

src/main/java/com/kumofactory/cloud/appDeploy/dto/BuildRequestDto.java

@@ -0,0 +1,29 @@
+package com.kumofactory.cloud.appDeploy.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.List;
+
+public record BuildRequestDto(
+        @JsonProperty("targetInstance") String instanceId, // required
+        @JsonProperty("githubToken") String gitHubToken,
+        @JsonProperty("user") String user, // required
+        @JsonProperty("repo") String repo, // required
+        @JsonProperty("branch") String branch, // required
+        @JsonProperty("Dockerfile") Boolean Dockerfile,
+        @JsonProperty("language") String language, // required
+        @JsonProperty("env") List<EnvInfoDTO> env) // required
+ {
+    public record EnvInfoDTO(
+            @JsonProperty("key") String key,
+            @JsonProperty("value") String value
+    ) { }
+
+     public BuildRequestDto setDockerfile(Boolean Dockerfile) {
+         return new BuildRequestDto(instanceId, gitHubToken, user, repo, branch, Dockerfile, language, env);
+     }
+
+     public BuildRequestDto setgithubToken(String gitHubToken) {
+         return new BuildRequestDto(instanceId, gitHubToken, user, repo, branch, Dockerfile, language, env);
+     }
+}

src/main/java/com/kumofactory/cloud/appDeploy/dto/GitHubRepoDto.java

@@ -0,0 +1,25 @@
+package com.kumofactory.cloud.appDeploy.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.List;
+
+public class GitHubRepoDto {
+    public record RepoInfoDto(
+            @JsonProperty("name") String name,
+            @JsonProperty("fullName") String fullName,
+            @JsonProperty("private") Boolean isPrivate,
+            @JsonProperty("fork") Boolean isFork
+    ) { }
+
+    public record UserDto(
+//            @JsonProperty("personal_repo_count") Integer personalRepoCount,
+//            @JsonProperty("personal_repo") List<RepoInfoDto> personalRepo,
+//            @JsonProperty("organization_count") Integer organizationCount,
+//            @JsonProperty("organization") List<String> organizationList
+            @JsonProperty("repoCount") Integer personalRepoCount,
+            @JsonProperty("repoInfo") List<RepoInfoDto> personalRepo,
+            @JsonProperty("orgCount") Integer organizationCount,
+            @JsonProperty("orgList") List<String> organizationList
+    ) { }
+}

src/main/java/com/kumofactory/cloud/appDeploy/service/BuildRequestService.java

@@ -0,0 +1,7 @@
+package com.kumofactory.cloud.appDeploy.service;
+
+import com.kumofactory.cloud.appDeploy.dto.BuildRequestDto;
+
+public interface BuildRequestService {
+    public void RequestBuild(BuildRequestDto request, String oauthId);
+}

src/main/java/com/kumofactory/cloud/appDeploy/service/BuildRequestServiceImpl.java

@@ -0,0 +1,76 @@
+package com.kumofactory.cloud.appDeploy.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.kumofactory.cloud.appDeploy.dto.BuildRequestDto;
+import com.kumofactory.cloud.member.MemberRepository;
+import com.kumofactory.cloud.member.domain.Member;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.RestTemplate;
+
+@Service
+@Slf4j
+@Repository
+@RequiredArgsConstructor
+public class BuildRequestServiceImpl implements BuildRequestService {
+
+    private final MemberRepository memberRepository;
+    private final Logger logger = LoggerFactory.getLogger(BuildRequestServiceImpl.class);
+    private String token;
+    private String baseUri = "https://api.github.com";
+    @Value("${build.server}")
+    private String buildServerUri;
+
+    @Override
+    public void RequestBuild(BuildRequestDto request, String oauthId) {
+        Member member = memberRepository.findMemberByOauthId(oauthId);
+        this.token = member.getGithubAccessToken();
+        String url = buildServerUri + "/api/v1/deploy";
+        request.setDockerfile(isDockerfileExist(request.user(), request.repo()));
+        request.setgithubToken(token);
+
+        logger.info(request.toString());
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.set("Accept", "application/json");
+        HttpEntity<BuildRequestDto> httpEntity = new HttpEntity<>(request, headers);
+        ResponseEntity<String> response = new RestTemplate().exchange(url, HttpMethod.POST, httpEntity, String.class);
+
+        if (response.getStatusCode().is2xxSuccessful()) {
+            logger.info("response : {}", response.getBody());
+        } else {
+            logger.error("response : {}", response.getBody());
+            logger.error("response : {}", response.getStatusCode());
+        }
+    }
+
+    private Boolean isDockerfileExist(String userName ,String repoName) {
+        String url = baseUri + "/repos/" + userName + "/" + repoName + "/contents/Dockerfile";
+        try {
+            ResponseEntity<JsonNode> response = RequestGitHubAPIs(url);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    private ResponseEntity<JsonNode> RequestGitHubAPIs(String uri) {
+        HttpHeaders headers = new HttpHeaders();
+        headers.set("Accept", "application/json");
+        if( StringUtils.hasText(token) ) {
+            headers.setBearerAuth(token);
+        }
+        HttpEntity<String> httpEntity = new HttpEntity<>(headers);
+        return new RestTemplate().exchange(uri, HttpMethod.GET, httpEntity, JsonNode.class);
+    }
+}