【第41回】AWS CloudFormationを用いた基盤自動化(21)継続的インテグレーション環境の構築(2)¶

package org.debugroom.mynavi.sample.sonarqube.initdb.app.handler;

import com.amazonaws.services.lambda.runtime.Context;
import lombok.extern.slf4j.Slf4j;
import org.debugroom.mynavi.sample.sonarqube.initdb.app.CloudFormationResponseSender;
import org.debugroom.mynavi.sample.sonarqube.initdb.app.model.Status;
import org.springframework.cloud.function.adapter.aws.SpringBootRequestHandler;
import reactor.core.publisher.Flux;

import java.util.Map;
import java.util.Objects;

@Slf4j
public class LambdaTriggerHandler extends
     SpringBootRequestHandler<Map<String, Object>, String> {                                       // (A)

    @Override
    public Object handleRequest(Map<String, Object> event, Context context) {                      // (B)
        for(String key : event.keySet()){
            log.info("[Key]" + key + " [Value]" + event.get(key).toString());                      // (C)
        }
        Object requestType = event.get("RequestType");                                             // (D)
        if(requestType != null && Objects.equals(requestType.toString(), "Delete")){               // (E)
            CloudFormationResponseSender.send(event, context, Status.SUCCESS,
              event.get("ResourceProperties"), event.get("PhysicalResourceId").toString(), false); // (F)
            return Flux.just("Complete!");                                                         // (G)
        }
        Object result = super.handleRequest(event, context);                                       // (H)
        if(requestType != null && result instanceof Flux){
            CloudFormationResponseSender.send(event, context, Status.SUCCESS,
              event.get("ResourceProperties"), null, false);                                       // (I)
        }
        return result;
     }

 }

package org.debugroom.mynavi.sample.sonarqube.initdb.app;

import com.amazonaws.services.lambda.runtime.Context;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import lombok.extern.slf4j.Slf4j;
import org.debugroom.mynavi.sample.sonarqube.initdb.app.model.CfnResponse;
import org.debugroom.mynavi.sample.sonarqube.initdb.app.model.Status;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestOperations;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;

@Slf4j
public class CloudFormationResponseSender {

    public static <T> void send(Map<String, Object> event, Context context,
                          Status status, T responseData, String physicalResourceId,
                          boolean noEcho){
        Object responseURL = event.get("ResponseURL");                              // (A)

        ObjectMapper mapper = new ObjectMapper()
          .setPropertyNamingStrategy(PropertyNamingStrategy.UPPER_CAMEL_CASE);      // (B)
        MappingJackson2HttpMessageConverter converter =
          new MappingJackson2HttpMessageConverter();
        converter.setObjectMapper(mapper);
        RestOperations restOperations = new RestTemplateBuilder()
          .messageConverters(Arrays.asList(converter))
          .build();                                                                 // (C)

        if(responseURL != null){
            log.info("ResponseURL : " + responseURL.toString());
            CfnResponse<T> cfnResponse = CfnResponse.<T>builder()
              .Status(status)
              .Reason("See the details in CloudWatch Log Stream: " + context.getLogStreamName())
              .PhysicalResourceId(physicalResourceId == null ?
                      context.getLogStreamName(): physicalResourceId)
              .StackId(event.get("StackId").toString())
              .RequestId(event.get("RequestId").toString())
              .LogicalResourceId(event.get("LogicalResourceId").toString())
              .NoEcho(noEcho)
              .Data(responseData)
              .build();                                                              // (D)

            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<CfnResponse> requestEntity = new HttpEntity<>(cfnResponse, headers);
            restOperations.exchange(getUri(responseURL.toString()),
              HttpMethod.PUT, requestEntity, Void.class);                            // (E)
       }else {
           throw new IllegalStateException("No ResponseURL to send.");
       }
    }

    protected static URI getUri(String responseURL){                                 // (F)

        String url = responseURL.split("\\?")[0];
        MultiValueMap<String, String> params = new LinkedMultiValueMap<>();

        try {
            String[] urlParams = responseURL.split("\\?")[1].split("&");
            for(String param : urlParams){
                String key = param.split("=")[0];
                String value = URLDecoder.decode(param.split("=")[1], StandardCharsets.UTF_8.toString());
                params.put(key, Collections.singletonList(URLEncoder.encode(value, "UTF-8")));
            }
        }catch (UnsupportedEncodingException e){
            e.printStackTrace();
        }

        return UriComponentsBuilder.fromHttpUrl(url)
          .queryParams(params)
          .build(true)
          .toUri();
    }
}

package org.debugroom.mynavi.sample.sonarqube.initdb.app.function;

import com.amazonaws.services.simplesystemsmanagement.AWSSimpleSystemsManagement;
import com.amazonaws.services.simplesystemsmanagement.model.GetParameterRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import reactor.core.publisher.Flux;

import java.util.Map;
import java.util.function.Function;

@Slf4j
public class InitDBFunction implements Function<Map<String, Object>, Flux<String>> {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    AWSSimpleSystemsManagement awsSimpleSystemsManagement;

    @Override
    public Flux<String> apply(Map<String, Object> stringObjectMap) {
        GetParameterRequest request = new GetParameterRequest();
        request.setName("mynavi-sonarqube-rds-sonar-password");
        request.setWithDecryption(true);
        jdbcTemplate.execute("CREATE ROLE sonar WITH LOGIN PASSWORD '"
          + awsSimpleSystemsManagement.getParameter(request).getParameter().getValue()
          + "';");
        return Flux.just("Complete!");
    }
}