feat(cdevents-notification): Implementing produce CDEvents using Notification

echo-notifications/echo-notifications.gradle

@@ -34,6 +34,9 @@ dependencies {
   implementation "org.jsoup:jsoup:1.8.3"
   implementation "com.atlassian.commonmark:commonmark:0.9.0"
   implementation "org.codehaus.groovy:groovy-json"
+  implementation "io.cloudevents:cloudevents-http-basic:2.5.0"
+  implementation "io.cloudevents:cloudevents-json-jackson:2.5.0"
+  implementation ("dev.cdevents:cdevents-sdk-java:0.1.2")
   testImplementation("com.icegreen:greenmail:1.5.14") {
     exclude group: "com.sun.mail", module: "javax.mail"
   }

echo-notifications/src/main/groovy/com/netflix/spinnaker/echo/cdevents/CDEventsBuilderService.java

@@ -0,0 +1,213 @@
+/*
+    Copyright (C) 2023 Nordix Foundation.
+    For a full list of individual contributors, please see the commit history.
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+          http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+    SPDX-License-Identifier: Apache-2.0
+*/
+
+package com.netflix.spinnaker.echo.cdevents;
+
+import com.netflix.spinnaker.echo.api.events.Event;
+import com.netflix.spinnaker.echo.exceptions.FieldNotFoundException;
+import dev.cdevents.CDEvents;
+import dev.cdevents.constants.CDEventConstants;
+import dev.cdevents.events.PipelineRunFinishedCDEvent;
+import dev.cdevents.events.PipelineRunQueuedCDEvent;
+import dev.cdevents.events.PipelineRunStartedCDEvent;
+import dev.cdevents.events.TaskRunFinishedCDEvent;
+import dev.cdevents.events.TaskRunStartedCDEvent;
+import dev.cdevents.exception.CDEventsException;
+import io.cloudevents.CloudEvent;
+import java.net.URI;
+import java.util.Map;
+import java.util.Optional;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+public class CDEventsBuilderService {
+
+  public CloudEvent createCDEvent(
+      Map<String, Object> preference,
+      String application,
+      Event event,
+      Map<String, String> config,
+      String status,
+      String spinnakerUrl) {
+
+    String configType =
+        Optional.ofNullable(config)
+            .map(c -> (String) c.get("type"))
+            .orElseThrow(FieldNotFoundException::new);
+    String configLink =
+        Optional.ofNullable(config)
+            .map(c -> (String) c.get("link"))
+            .orElseThrow(FieldNotFoundException::new);
+
+    String executionId =
+        Optional.ofNullable(event.content)
+            .map(e -> (Map) e.get("execution"))
+            .map(e -> (String) e.get("id"))
+            .orElse(null);
+
+    String executionUrl =
+        String.format(
+            "%s/#/applications/%s/%s/%s",
+            spinnakerUrl,
+            application,
+            configType == "stage" ? "executions/details" : configLink,
+            executionId);
+
+    String executionName =
+        Optional.ofNullable(event.content)
+            .map(e -> (Map) e.get("execution"))
+            .map(e -> (String) e.get("name"))
+            .orElse(null);
+
+    String cdEventsType =
+        Optional.ofNullable(preference)
+            .map(p -> (String) p.get("cdEventsType"))
+            .orElseThrow(FieldNotFoundException::new);
+
+    CloudEvent ceToSend =
+        buildCloudEventWithCDEventType(
+            cdEventsType, executionId, executionUrl, executionName, spinnakerUrl, status);
+    if (ceToSend == null) {
+      log.error("Failed to created CDEvent with type {} as CloudEvent", cdEventsType);
+      throw new CDEventsException("Failed to created CDEvent as CloudEvent");
+    }
+    return ceToSend;
+  }
+
+  private CloudEvent buildCloudEventWithCDEventType(
+      String cdEventsType,
+      String executionId,
+      String executionUrl,
+      String executionName,
+      String spinnakerUrl,
+      String status) {
+    CloudEvent ceToSend = null;
+    switch (cdEventsType) {
+      case "dev.cdevents.pipelinerun.queued":
+        ceToSend =
+            createPipelineRunQueuedEvent(executionId, executionUrl, executionName, spinnakerUrl);
+        break;
+      case "dev.cdevents.pipelinerun.started":
+        ceToSend =
+            createPipelineRunStartedEvent(executionId, executionUrl, executionName, spinnakerUrl);
+        break;
+      case "dev.cdevents.pipelinerun.finished":
+        ceToSend =
+            createPipelineRunFinishedEvent(
+                executionId, executionUrl, executionName, spinnakerUrl, status);
+        break;
+      case "dev.cdevents.taskrun.started":
+        ceToSend =
+            createTaskRunStartedEvent(executionId, executionUrl, executionName, spinnakerUrl);
+        break;
+      case "dev.cdevents.taskrun.finished":
+        ceToSend =
+            createTaskRunFinishedEvent(
+                executionId, executionUrl, executionName, spinnakerUrl, status);
+        break;
+      default:
+        throw new CDEventsException(
+            "Invalid CDEvents Type " + cdEventsType + " provided to create CDEvent");
+    }
+    return ceToSend;
+  }
+
+  private CloudEvent createTaskRunFinishedEvent(
+      String executionId,
+      String executionUrl,
+      String executionName,
+      String spinnakerUrl,
+      String status) {
+    TaskRunFinishedCDEvent cdEvent = new TaskRunFinishedCDEvent();
+    cdEvent.setSource(URI.create(spinnakerUrl));
+
+    cdEvent.setSubjectId(executionId);
+    cdEvent.setSubjectSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectTaskName(executionName);
+    cdEvent.setSubjectUrl(URI.create(executionUrl));
+    cdEvent.setSubjectErrors(status);
+    cdEvent.setSubjectPipelineRunId(executionId);
+    if (status.equals("complete")) {
+      cdEvent.setSubjectOutcome(CDEventConstants.Outcome.SUCCESS);
+    } else if (status.equals("failed")) {
+      cdEvent.setSubjectOutcome(CDEventConstants.Outcome.FAILURE);
+    }
+    return CDEvents.cdEventAsCloudEvent(cdEvent);
+  }
+
+  private CloudEvent createTaskRunStartedEvent(
+      String executionId, String executionUrl, String executionName, String spinnakerUrl) {
+    TaskRunStartedCDEvent cdEvent = new TaskRunStartedCDEvent();
+    cdEvent.setSource(URI.create(spinnakerUrl));
+
+    cdEvent.setSubjectId(executionId);
+    cdEvent.setSubjectSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectTaskName(executionName);
+    cdEvent.setSubjectUrl(URI.create(executionUrl));
+    cdEvent.setSubjectPipelineRunId(executionId);
+
+    return CDEvents.cdEventAsCloudEvent(cdEvent);
+  }
+
+  private CloudEvent createPipelineRunFinishedEvent(
+      String executionId,
+      String executionUrl,
+      String executionName,
+      String spinnakerUrl,
+      String status) {
+    PipelineRunFinishedCDEvent cdEvent = new PipelineRunFinishedCDEvent();
+    cdEvent.setSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectId(executionId);
+    cdEvent.setSubjectSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectPipelineName(executionName);
+    cdEvent.setSubjectUrl(URI.create(executionUrl));
+    cdEvent.setSubjectErrors(status);
+
+    if (status.equals("complete")) {
+      cdEvent.setSubjectOutcome(CDEventConstants.Outcome.SUCCESS);
+    } else if (status.equals("failed")) {
+      cdEvent.setSubjectOutcome(CDEventConstants.Outcome.FAILURE);
+    }
+
+    return CDEvents.cdEventAsCloudEvent(cdEvent);
+  }
+
+  private CloudEvent createPipelineRunStartedEvent(
+      String executionId, String executionUrl, String executionName, String spinnakerUrl) {
+    PipelineRunStartedCDEvent cdEvent = new PipelineRunStartedCDEvent();
+    cdEvent.setSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectId(executionId);
+    cdEvent.setSubjectSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectPipelineName(executionName);
+    cdEvent.setSubjectUrl(URI.create(executionUrl));
+
+    return CDEvents.cdEventAsCloudEvent(cdEvent);
+  }
+
+  private CloudEvent createPipelineRunQueuedEvent(
+      String executionId, String executionUrl, String executionName, String spinnakerUrl) {
+    PipelineRunQueuedCDEvent cdEvent = new PipelineRunQueuedCDEvent();
+    cdEvent.setSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectId(executionId);
+    cdEvent.setSubjectSource(URI.create(spinnakerUrl));
+    cdEvent.setSubjectPipelineName(executionName);
+    cdEvent.setSubjectUrl(URI.create(executionUrl));
+
+    return CDEvents.cdEventAsCloudEvent(cdEvent);
+  }
+}

echo-notifications/src/main/groovy/com/netflix/spinnaker/echo/cdevents/CDEventsHTTPMessageConverter.java

@@ -0,0 +1,88 @@
+/*
+    Copyright (C) 2023 Nordix Foundation.
+    For a full list of individual contributors, please see the commit history.
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+          http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+    SPDX-License-Identifier: Apache-2.0
+*/
+
+package com.netflix.spinnaker.echo.cdevents;
+
+import static com.fasterxml.jackson.databind.SerializationFeature.FAIL_ON_EMPTY_BEANS;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.netflix.spinnaker.kork.web.exceptions.InvalidRequestException;
+import io.cloudevents.CloudEvent;
+import io.cloudevents.jackson.JsonFormat;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Type;
+import retrofit.converter.ConversionException;
+import retrofit.converter.Converter;
+import retrofit.mime.TypedByteArray;
+import retrofit.mime.TypedInput;
+import retrofit.mime.TypedOutput;
+
+public class CDEventsHTTPMessageConverter implements Converter {
+
+  private final ObjectMapper objectMapper;
+
+  private static final String MIME_TYPE = "application/json";
+
+  public CDEventsHTTPMessageConverter(ObjectMapper objectMapper) {
+    this.objectMapper = objectMapper;
+  }
+
+  public static CDEventsHTTPMessageConverter create() {
+    ObjectMapper objectMapper = new ObjectMapper();
+    objectMapper.registerModule(JsonFormat.getCloudEventJacksonModule());
+    objectMapper.disable(FAIL_ON_EMPTY_BEANS);
+    return new CDEventsHTTPMessageConverter(objectMapper);
+  }
+
+  public String convertCDEventToJson(CloudEvent cdEvent) {
+    try {
+      return objectMapper.writeValueAsString(cdEvent);
+    } catch (JsonProcessingException e) {
+      throw new InvalidRequestException("Unable to convert CDEvent to Json format.", e);
+    }
+  }
+
+  @Override
+  public Object fromBody(TypedInput body, Type type) throws ConversionException {
+    try {
+      JavaType javaType = objectMapper.getTypeFactory().constructType(type);
+      return objectMapper.readValue(body.in(), javaType);
+    } catch (JsonParseException e) {
+      throw new ConversionException(e);
+    } catch (JsonMappingException e) {
+      throw new ConversionException(e);
+    } catch (IOException e) {
+      throw new ConversionException(e);
+    }
+  }
+
+  @Override
+  public TypedOutput toBody(Object object) {
+    try {
+      String json = objectMapper.writeValueAsString(object);
+      return new TypedByteArray(MIME_TYPE, json.getBytes("UTF-8"));
+    } catch (JsonProcessingException e) {
+      throw new AssertionError(e);
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError(e);
+    }
+  }
+}

echo-notifications/src/main/groovy/com/netflix/spinnaker/echo/cdevents/CDEventsSenderClient.java

@@ -0,0 +1,26 @@
+/*
+    Copyright (C) 2023 Nordix Foundation.
+    For a full list of individual contributors, please see the commit history.
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+          http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+    SPDX-License-Identifier: Apache-2.0
+*/
+
+package com.netflix.spinnaker.echo.cdevents;
+
+import retrofit.client.Response;
+import retrofit.http.*;
+
+public interface CDEventsSenderClient {
+  @POST("/{brokerUrl}")
+  Response sendCDEvent(
+      @Body String cdEvent, @Path(value = "brokerUrl", encode = false) String brokerUrl);
+}