9.3. Fuse Online 확장 개발

확장 기능을 개발하기 전에 수행해야 하는 작업에 익숙해집니다.

확장은 다음 중 하나를 정의합니다.

비즈니스 통합자는 확장을 코딩하는 개발자와 요구 사항을 공유합니다. 개발자는 확장자가 포함된 .jar 파일을 제공합니다. 비즈니스 통합자는 Fuse Online에서 .jar 파일을 업로드하여 사용자 지정 커넥터, 사용자 지정 단계 또는 Fuse Online에서 사용할 수 있는 라이브러리 리소스를 만듭니다.

Fuse Online에 업로드하는 확장자 .jar 파일에는 항상 하나의 확장자가 포함되어 있습니다.

연결 간 데이터에서 작동하는 단계를 제공하는 확장을 업로드하고 사용하는 예는 AMQ to REST API 샘플 통합 튜토리얼을 참조하십시오.

확장은 .jar 파일에 패키지로 제공되는 클래스, 종속 항목 및 리소스의 컬렉션입니다.

Fuse Online에서는 Spring Boot를 사용하여 확장을 로드합니다. 따라서 Spring Boot의 실행 가능한 JAR 형식에 따라 확장을 패키징해야 합니다. 예를 들어 ZipEntry.STORED() 메서드를 사용하여 중첩된 JAR 파일을 저장해야 합니다.

확장자를 패키지하는 .jar 파일의 구조는 다음과 같습니다.

extension.jar
|
+- META-INF
|  |
|  +- syndesis
|     |
|     +- syndesis-extension-definition.json 1
|
+- mycompany
|  |
|  +-project
|    |
|    +-YourClasses.class 2
|
+- lib 3
  |
  +-dependency1.jar
  |
  +-dependency2.jar

각 확장에는 이름, 설명, 지원되는 동작 및 종속 항목과 같은 데이터 구조의 값을 지정하여 확장을 정의하는 .json 파일이 있어야 합니다. 다음 표는 각 확장 유형에 대해 Maven이 확장 정의 JSON 파일을 생성할 수 있는지 여부와 필요한 데이터 구조를 나타냅니다.

* 종속 항목의 사양은 엄격하게 요구되지는 않지만 실제로는 거의 항상 지정해야 하는 종속성이 있습니다.

일반적으로 확장 정의 파일에는 다음과 같은 레이아웃이 있습니다.

{
  "schemaVersion": "v1",
  "name": "",
  "description": "",
  "version": "",
  "extensionId": "",
  "extensionType": "",
  "properties": {
  },
  "actions": [
  ],
  "dependencies": [
  ],
}

커넥터 확장 및 단계 확장에서는 확장자 정의 JSON 파일 또는 Java 클래스 파일에서 사용자 인터페이스 속성을 지정합니다. 이러한 속성 설정은 Fuse Online 사용자가 연결을 만들거나, 연결 작업을 구성하거나, 확장 프로그램에서 제공하는 단계를 구성할 때 Fuse Online이 표시되는 HTML 양식 컨트롤을 정의합니다.

Fuse Online 콘솔의 확장 사용자 인터페이스에 표시할 각 양식 컨트롤의 속성을 지정해야 합니다. 각 폼 컨트롤에 대해 임의의 순서로 일부 또는 모든 속성을 지정합니다.For each form control, specify some or all properties in any order.

"properties": {
   "hostname": {
     "description": "IRC Server hostname",
     "displayName": "Hostname",
     "labelHint": "Hostname of the IRC server to connect to",
     "order": "1",
     "required": true,
     "secret": false,
     "type": "string"
   },
   "password": {
     "description": "IRC Server password",
     "displayName": "Password",
     "labelHint": "Required if IRC server requires it to join",
     "order": "3",
     "required": false,
     "secret": true,
     "type": "string"
   },
   "port": {
     "description": "IRC Server port",
     "displayName": "Port",
     "labelHint": "Port of the IRC server to connect to",
     "order": "2",
     "required": true,
     "secret": false,
     "tags": [],
     "type": "int"
   }
 },

이러한 속성 사양을 기반으로 Fuse Online 사용자가 IRC 커넥터를 선택할 때 Fuse Online에 다음과 같은 대화 상자가 표시됩니다. 사용자가 두 개의 필수 필드에 값을 입력하고 Next 를 클릭하면 Fuse Online에서 Fuse Online 사용자가 입력하는 값으로 구성된 IRC 연결을 생성합니다.

단계 확장에서 actions 오브젝트에는 속성 개체가 포함되어 있습니다. properties 오브젝트는 단계 구성을 위한 각 양식 컨트롤의 속성 세트를 정의합니다. JSON 계층 구조는 다음과 같습니다.

"actions": [
   {
      ...

      "propertyDefinitionSteps": [
         {
            ...

            "properties":
               {
                  "control-ONE": {
                     "type": "string",
                     "displayName": "Topic Name",
                     "order": "2",
                     ...,
                     }

                  "control-TWO": {
                     "type": "boolean",
                     "displayName": "Urgent",
                     "order": "3",
                     ...
                     }

                  "control-THREE": {
                     "type": "textarea",
                     "displayName": "Comment",
                     "order": "1",
                     ...,
                     }
 } } ]

다음 코드에서는 하나의 양식 컨트롤에 대한 속성 정의를 보여줍니다. 이 코드는 RouteBuilder 를 사용하여 Camel 경로를 개발하는 예입니다.

public class LogAction extends RouteBuilder {
    @ConfigurationProperty(
        name = "prefix",
        description = "The Log body prefix message",
        displayName = "Log Prefix",
        type = "string")

다음 코드에서는 두 개의 컨트롤에 대한 속성 정의를 보여줍니다. 이 코드는 Syndesis Step API 사용 예의 예입니다.

@Action(id = "split", name = "Split", description = "Split your exchange")
public class SplitAction implements Step {

    @ConfigurationProperty(
        name = "language",
        displayName = "Language",
        description = "The language used for the expression")
    private String language;

    @ConfigurationProperty(
        name = "expression",
        displayName = "Expression",
        description = "The expression used to split the exchange
     private String language;

다음 표에는 Fuse Online 양식 제어에 사용 가능한 입력 유형이 나열되어 있습니다. 컨트롤의 속성 집합에서 알 수 없는 유형 값을 지정하면 Fuse Online에서 한 줄의 텍스트를 허용하는 입력 필드를 표시합니다. 기본값은 "type": "text" 입니다.

extension-maven-plugin 은 확장을 유효한 Spring Boot 모듈로 패키징하여 확장 개발을 지원합니다. Java에서 구현하는 단계 확장의 경우 이 플러그인은 확장 정의 JSON 파일을 생성할 수 있습니다.

Maven 프로젝트의 pom.xml 파일에 다음 플러그인 선언을 추가합니다.

<plugin>
    <groupId>io.syndesis.extension</groupId>
    <artifactId>extension-maven-plugin</artifactId>
    <version>${syndesis.version}</version>
    <executions>
        <execution>
        <goals>
            <goal>generate-metadata</goal>
            <goal>repackage-extension</goal>
        </goals>
        </execution>
    </executions>
</plugin>

extension-maven-plugin 은 다음 목표를 정의합니다.

예를 들어 Maven 프로젝트에 다음 pom.xml 파일이 있다고 가정합니다.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>com.company</groupId>
  <artifactId>my-extension</artifactId>
  <version>1.0.0</version>
  <name>MyExtension</name>
  <description>A Sample Extension</description>
  <packaging>jar</packaging>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.syndesis.extension</groupId>
        <artifactId>extension-bom</artifactId>
        <version>1.3.10</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>io.syndesis.extension</groupId>
      <artifactId>extension-api</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.github.lalyos</groupId>
      <artifactId>jfiglet</artifactId>
      <version>0.0.8</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.7.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>io.syndesis.extension</groupId>
        <artifactId>extension-maven-plugin</artifactId>
        <version>1.3.10</version>
        <executions>
          <execution>
            <goals>
              <goal>generate-metadata</goal>
              <goal>repackage-extension</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

이 pom.xml 파일을 기반으로 생성된 확장 정의 JSON 파일은 다음과 같습니다.

{
  "name": "MyExtension",
  "description": "A Sample Extension",
  "extensionId": "com.company:my-extension",
  "version": "1.0.0",
  "dependencies": [ {
    "type": "MAVEN",
    "id": "io.syndesis.extension:extension-api:jar:1.3.10"
  } ],
  "extensionType": "Libraries",
  "schemaVersion": "v1"
}

생성된 아카이브에는 이 구조와 콘텐츠가 있습니다.

my-extension-1.0.0.jar
|
+- lib
|  |
|  + jfiglet-0.0.8.jar
|
+- META-INF
  |
  +- MANIFEST.MF
     |
     +- syndesis
        |
        +- syndesis-extension-definition.json

데이터 셰이프는 데이터 매퍼에서 사용할 데이터 유형 메타데이터를 보유합니다.A data shape holds data type metadata for use by the data mapper. 데이터 매퍼는 이 메타데이터를 데이터 매퍼 사용자 인터페이스에서 소스 및 대상 데이터 필드를 표시하는 데 사용하는 내부 문서로 변환합니다. 커넥터 또는 사용자 지정 단계에 대한 확장 정의 JSON 파일에서 각 작업 사양은 입력 데이터 도형(inputDataShape) 및 출력 데이터 도형(outputDataShape)을 정의합니다.

확장을 개발할 때는 데이터 매퍼가 소스 및 대상 필드를 올바르게 처리하고 표시할 수 있는 데이터 셰이프 속성을 지정해야 합니다. 다음 데이터 셰이프 속성은 데이터 매퍼 동작에 영향을 미칩니다.

"outputDataShape": {
     "kind": "java",
     "type": "org.apache.camel.component.telegram.model.IncomingMessage"
},

kind 속성이 java 이외의 것으로 설정되면 type 속성에 대한 모든 설정이 무시됩니다.

이 이름은 Fuse Online 흐름 시각화의 데이터 유형 지표에도 나타납니다.

단계 확장은 하나 이상의 사용자 지정 단계를 구현합니다. 각 사용자 지정 단계는 연결 간 통합 데이터를 처리하기 위한 하나의 작업을 구현합니다. 다음 예제에서는 단계 확장을 개발하는 대안을 보여줍니다.

Syndesis는 syndesis-extension-plugin 과 함께 사용할 수 있는 사용자 지정 Java 주석을 제공합니다. Java에서 단계 확장 또는 커넥터 확장을 구현하는 경우 Maven을 활성화하여 확장 정의 JSON 파일에 작업 정의를 추가할 수 있는 주석을 지정할 수 있습니다. 주석 처리를 활성화하려면 Maven 프로젝트에 다음 종속성을 추가합니다.

<dependency>
  <groupId>io.syndesis.extension</groupId>
  <artifactId>extension-annotation-processor</artifactId>
  <optional>true</optional>
</dependency>

Spring Boot는 Camel 컨텍스트에 빈을 삽입하는 통합 런타임이므로 표준 Spring Boot 사례를 따라야 합니다. 예를 들어 자동 구성 클래스를 생성하고 여기에 빈을 생성합니다. 그러나 기본 동작은 확장 코드에 패키지 스캔이 적용되지 않는다는 것입니다. 따라서 단계 확장자에 META-INF/spring.factories 파일을 생성하고 채워야 합니다.

<?xml version="1.0" encoding="UTF-8"?>
<routes xmlns="http://camel.apache.org/schema/spring"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
      http://camel.apache.org/schema/spring
      http://camel.apache.org/schema/spring/camel-spring.xsd">

  <route id="log-body-with-prefix">
    <from uri="direct:log"/>
    <choice>
      <when>
        <simple>${header.prefix} != ''</simple>
        <log message="${header.prefix} ${body}"/>
      </when>
      <otherwise>
        <log message="Output ${body}"/>
      </otherwise>
    </choice>
  </route>

</routes>

{
  "actionType": "step",
  "id": "log-body-with-prefix",
  "name": "Log body with prefix",
  "description": "A simple body log with a prefix",
  "descriptor": {
    "kind": "ENDPOINT", 1
    "entrypoint": "direct:log", 2
    "resource": "classpath:log-body-action.xml", 3
    "inputDataShape": {
      "kind": "none"
    },
    "outputDataShape": {
      "kind": "none"
    },
  "propertyDefinitionSteps": [ {
    "description": "extension-properties",
    "name": "extension-properties",
    "properties": { 4
      "prefix": {
        "componentProperty": false,
        "deprecated": false,
        "description": "The Log body prefix message",
        "displayName": "Log Prefix",
        "javaType": "String",
        "kind": "parameter",
        "required": false,
        "secret": false,
        "type": "string"
      }
    }
  } ]
  }
}

import org.apache.camel.builder.RouteBuilder;

import io.syndesis.extension.api.annotations.Action;
import io.syndesis.extension.api.annotations.ConfigurationProperty;

@Action( 1
    id = "log-body-with-prefix",
    name = "Log body with prefix",
    description = "A simple body log with a prefix",
    entrypoint = "direct:log")
public class LogAction extends RouteBuilder {
    @ConfigurationProperty( 2
        name = "prefix",
        description = "The Log body prefix message",
        displayName = "Log Prefix",
        type = "string")
    private String prefix;

    @Override
    public void configure() throws Exception {
        from("direct::start") 3
            .choice()
                .when(simple("${header.prefix} != ''"))
                    .log("${header.prefix} ${body}")
                .otherwise()
                    .log("Output ${body}")
            .endChoice();
    }
}

{
  "id": "log-body-with-prefix",
  "name": "Log body with prefix",
  "description": "A simple body log with a prefix",
  "descriptor": {
    "kind": "ENDPOINT", 1
    "entrypoint": "direct:log", 2
    "resource": "class:io.syndesis.extension.log.LogAction", 3
    "inputDataShape": {
      "kind": "none"
    },
    "outputDataShape": {
      "kind": "none"
    },
    "propertyDefinitionSteps": [ {
      "description": "extension-properties",
      "name": "extension-properties",
      "properties": { 4
        "prefix": {
          "componentProperty": false,
          "deprecated": false,
          "description": "The Log body prefix message",
          "displayName": "Log Prefix",
          "javaType": "java.lang.String",
          "kind": "parameter",
          "required": false,
          "secret": false,
          "type": "string",
          "raw": false
        }
      }
    } ]
  },
  "actionType": "step"
}

import io.syndesis.extension.api.annotations.Action;
import io.syndesis.extension.api.annotations.ConfigurationProperty;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ActionsConfiguration {

    @Action( 1
        id = "log-body-with-prefix",
        name = "Log body with prefix",
        description = "A simple body log with a prefix",
        entrypoint = "direct:log")
    @ConfigurationProperty( 2
        name = "prefix",
        description = "The Log body prefix message",
        displayName = "Log Prefix",
        type = "string")
    @Bean 3
    public RouteBuilder logBodyWithprefix() {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("direct::start") 4
                    .choice()
                        .when(simple("${header.prefix} != ''"))
                            .log("${header.prefix} ${body}")
                        .otherwise()
                            .log("Output ${body}")
                    .endChoice();
             }
        };
    }
}

{
  "id": "log-body-with-prefix",
  "name": "Log body with prefix",
  "description": "A simple body log with a prefix",
  "descriptor": {
    "kind": "ENDPOINT", 1
    "entrypoint": "direct:log", 2
    "inputDataShape": {
      "kind": "none"
    },
    "outputDataShape": {
      "kind": "none"
    },
    "propertyDefinitionSteps": [ {
      "description": "extension-properties",
      "name": "extension-properties",
      "properties": { 3
        "prefix": {
          "componentProperty": false,
          "deprecated": false,
          "description": "The Log body prefix message",
          "displayName": "Log Prefix",
          "javaType": "java.lang.String",
          "kind": "parameter",
          "required": false,
          "secret": false,
          "type": "string",
          "raw": false
        }
      }
    } ]
  },
  "actionType": "step"
}

import org.apache.camel.Body;
import org.apache.camel.Handler;
import org.apache.camel.Header;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.syndesis.extension.api.annotations.Action;
import io.syndesis.extension.api.annotations.ConfigurationProperty;

@Action(
    id = "log-body-with-prefix",
    name = "Log body with prefix",
    description = "A simple body log with a prefix")
public class LogAction  {
    private static final Logger LOGGER = LoggerFactory.getLogger(LogAction.class);

    @ConfigurationProperty(
        name = "prefix",
        description = "The Log body prefix message",
        displayName = "Log Prefix",
        type = "string")
    private String prefix;

    @Handler 1
    public void process(@Header("prefix") String prefix, @Body Object body) {
        if (prefix == null) {
            LOGGER.info("Output {}", body);
        } else {
            LOGGER.info("{} {}", prefix, body);
        }
    }
}

{
  "id": "log-body-with-prefix",
  "name": "Log body with prefix",
  "description": "A simple body log with a prefix",
  "descriptor": {
    "kind": "BEAN", 1
    "entrypoint": "io.syndesis.extension.log.LogAction::process", 2
    "inputDataShape": {
      "kind": "none"
    },
    "outputDataShape": {
      "kind": "none"
    },
    "propertyDefinitionSteps": [ {
      "description": "extension-properties",
      "name": "extension-properties",
      "properties": {
        "prefix": { 3
          "componentProperty": false,
          "deprecated": false,
          "description": "The Log body prefix message",
          "displayName": "Log Prefix",
          "javaType": "java.lang.String",
          "kind": "parameter",
          "required": false,
          "secret": false,
          "type": "string",
          "raw": false
        }
      }
    } ]
  },
  "actionType": "step"
}

import org.apache.camel.Body;
import org.apache.camel.Handler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.syndesis.extension.api.annotations.Action;
import io.syndesis.extension.api.annotations.ConfigurationProperty;

@Action(
    id = "log-body-with-prefix",
    name = "Log body with prefix",
    description = "A simple body log with a prefix")
public class LogAction  {
    private static final Logger LOGGER = LoggerFactory.getLogger(LogAction.class);

    @ConfigurationProperty(
        name = "prefix",
        description = "The Log body prefix message",
        displayName = "Log Prefix",
        type = "string")
    private String prefix;

    public void setPrefix(String prefix) { 1
        this.prefix = prefix;
    }

    public String getPrefix() { 2
        return prefix;
    }

    @Handler
    public void process(@Body Object body) {
        if (this.prefix == null) {
            LOGGER.info("Output {}", body);
        } else {
            LOGGER.info("{} {}", this.prefix, body);
        }
    }
}

import java.util.Map;
import java.util.Optional;

import io.syndesis.extension.api.Step;
import io.syndesis.extension.api.annotations.Action;
import io.syndesis.extension.api.annotations.ConfigurationProperty;
import org.apache.camel.CamelContext;
import org.apache.camel.model.ProcessorDefinition;
import org.apache.camel.util.ObjectHelper;
import org.apache.camel.Expression;
import org.apache.camel.builder.Builder;
import org.apache.camel.processor.aggregate.AggregationStrategy;
import org.apache.camel.processor.aggregate.UseOriginalAggregationStrategy;
import org.apache.camel.spi.Language;

@Action(id = "split", name = "Split", description = "Split your exchange")
public class SplitAction implements Step {

    @ConfigurationProperty(
        name = "language",
        displayName = "Language",
        description = "The language used for the expression")
    private String language;

    @ConfigurationProperty(
        name = "expression",
        displayName = "Expression",
        description = "The expression used to split the exchange")
    private String expression;

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public String getExpression() {
        return expression;
    }

    public void setExpression(String expression) {
        this.expression = expression;
    }

    @Override
    public Optional<ProcessorDefinition> configure(
            CamelContext context,
            ProcessorDefinition route,
            Map<String, Object> parameters) { 1

        String languageName = language;
        String expressionDefinition = expression;

        if (ObjectHelper.isEmpty(languageName) && ObjectHelper.isEmpty(expressionDefinition)) {
            route = route.split(Builder.body());
        } else if (ObjectHelper.isNotEmpty(expressionDefinition)) {

            if (ObjectHelper.isEmpty(languageName)) {
                languageName = "simple";
            }

            final Language splitLanguage = context.resolveLanguage(languageName);
            final Expression splitExpression = splitLanguage.createExpression(expressionDefinition);
            final AggregationStrategy aggreationStrategy = new UseOriginalAggregationStrategy(null, false);

            route = route.split(splitExpression).aggregationStrategy(aggreationStrategy);
        }

        return Optional.of(route);
    }
}

{
  "id": "split",
  "name": "Split",
  "description": "Split your exchange",
  "descriptor": {
    "kind": "STEP", 1
    "entrypoint": "io.syndesis.extension.split.SplitAction", 2
    "inputDataShape": {
      "kind": "none"
    },
    "outputDataShape": {
      "kind": "none"
    },
    "propertyDefinitionSteps": [ {
      "description": "extension-properties",
      "name": "extension-properties",
      "properties": {
        "language": {
          "componentProperty": false,
          "deprecated": false,
          "description": "The language used for the expression",
          "displayName": "Language",
          "javaType": "java.lang.String",
          "kind": "parameter",
          "required": false,
          "secret": false,
          "type": "string",
          "raw": false
        },
        "expression": {
          "componentProperty": false,
          "deprecated": false,
          "description": "The expression used to split the exchange",
          "displayName": "Expression",
          "javaType": "java.lang.String",
          "kind": "parameter",
          "required": false,
          "secret": false,
          "type": "string",
          "raw": false
        }
      }
    } ]
  },
  "tags": [],
  "actionType": "step"
}

Fuse Online에서 통합에서 연결하려는 애플리케이션 또는 서비스에 대한 커넥터를 제공하지 않는 경우 숙련된 개발자는 Fuse Online에 새 커넥터를 제공하는 확장을 코딩할 수 있습니다. 이 문서에서는 커넥터 확장 개발을 위한 소개를 제공합니다. 커넥터 개발에 대한 자세한 내용은 Syndesis 커뮤니티 사이트에서 통합 커넥터 개발을 참조하십시오.

커넥터는 기본적으로 Camel 구성 요소의 프록시입니다. 커넥터는 기본 구성 요소를 구성하고 확장 정의 및 Fuse Online 웹 인터페이스에서 수집하는 사용자 제공 옵션에 따라 끝점을 생성합니다.

커넥터 확장 정의는 다음과 같은 추가 데이터 구조를 사용하여 단계 확장에 필요한 확장 정의를 확장합니다.

public class DataSourceCustomizer implements ComponentProxyCustomizer, CamelContextAware {
    private final static Logger LOGGER = LoggerFactory.getLogger(DataSourceCustomizer.class);

    private CamelContext camelContext;

    @Override
    public void setCamelContext(CamelContext camelContext) { 1
        this.camelContext = camelContext;
    }

    @Override
    public CamelContext getCamelContext() { 2
        return this.camelContext;
    }

    @Override
    public void customize(ComponentProxyComponent component, Map<String, Object> options) {
        if (!options.containsKey("dataSource")) {
            if (options.containsKey("user") && options.containsKey("password") && options.containsKey("url")) {
                try {
                    BasicDataSource ds = new BasicDataSource();

                    consumeOption(camelContext, options, "user", String.class, ds::setUsername); 3
                    consumeOption(camelContext, options, "password", String.class, ds::setPassword); 4
                    consumeOption(camelContext, options, "url", String.class, ds::setUrl); 5

                    options.put("dataSource", ds);
                } catch (@SuppressWarnings("PMD.AvoidCatchingGenericException") Exception e) {
                    throw new IllegalArgumentException(e);
                }
            } else {
                LOGGER.debug("Not enough information provided to set-up the DataSource");
            }
        }
    }
}

public class DataSourceCustomizer implements ComponentProxyCustomizer, CamelContextAware {
    private final static Logger LOGGER = LoggerFactory.getLogger(DataSourceCustomizer.class);

    private CamelContext camelContext;
    private String userName;
    private String password;
    private String url;

    @Override
    public void setCamelContext(CamelContext camelContext) { 1
        this.camelContext = camelContext;
    }

    @Override
    public CamelContext getCamelContext() { 2
        return this.camelContext;
    }

    public void setUserName(String userName) { 3
      this.userName = userName;
    }

    public String getUserName() { 4
      return this.userName;
    }

    public void setPassword(String password) { 5
      this.password = password;
    }

    public String getPassword() { 6
      return this.password;
    }

    public void setUrl(String url) { 7
      this.url = url;
    }

    public String getUrl() { 8
      return this.url;
    }

    @Override
    public void customize(ComponentProxyComponent component, Map<String, Object> options) {
        if (!options.containsKey("dataSource")) {
            if (userName != null && password != null && url != null) {
                try {
                    BasicDataSource ds = new BasicDataSource();
                    ds.setUserName(userName);
                    ds.setPassword(password);
                    ds.setUrl(url);

                    options.put("dataSource", ds);
                } catch (@SuppressWarnings("PMD.AvoidCatchingGenericException") Exception e) {
                    throw new IllegalArgumentException(e);
                }
            } else {
                LOGGER.debug("Not enough information provided to set-up the DataSource");
            }
        }
    }
}

public class AWSS3DeleteObjectCustomizer implements ComponentProxyCustomizer {
  	private String filenameKey;

    public void setFilenameKey(String filenameKey) {
      this.filenameKey = filenameKey;
    }

    public String getFilenameKey() {
        return this.filenameKey;
    }

    @Override
    public void customize(ComponentProxyComponent component, Map<String, Object> options) {
      	component.setBeforeProducer(this::beforeProducer);
    }

    public void beforeProducer(final Exchange exchange) throws IOException {
      	exchange.getIn().setHeader(S3Constants.S3_OPERATION, S3Operations.deleteObject);

    	  if (filenameKey != null) {
    		    exchange.getIn().setHeader(S3Constants.KEY, filenameKey);
    	  }
    }
}

라이브러리 확장은 런타임 시 통합에 필요한 리소스를 제공합니다. 라이브러리 확장은 Fuse Online에 단계 또는 커넥터를 제공하지 않습니다.

통합을 저장하면 통합과 포함할 하나 이상의 가져온 라이브러리 확장을 선택적으로 선택할 수 있습니다.

라이브러리 확장에서는 작업을 정의하지 않습니다. 라이브러리 확장에 대한 샘플 정의는 다음과 같습니다.

{
  "schemaVersion" : "v1",
  "name" : "Example Library Extension",
  "description" : "Syndesis Extension for adding a runtime library",
  "extensionId" : "io.syndesis.extensions:syndesis-library",
  "version" : "1.0.0",
  "tags" : [ "my-libraries-extension" ],
  "extensionType" : "Libraries"
}

여기에서 샘플 라이브러리 확장도 참조하십시오. https://github.com/syndesisio/syndesis-extensions

작업 부족 외에도 라이브러리 확장의 구조는 단계 또는 커넥터 확장의 구조와 동일합니다.

라이브러리 확장을 생성하는 Maven 프로젝트에서 Maven 리포지토리에서 사용할 수 없는 종속성을 추가하려면 시스템 종속성을 지정합니다. 예를 들면 다음과 같습니다.

<dependency>
    <groupId>com.company</groupId>
    <artifactId>my-library-extension</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/lib/my-library-extension.jar</systemPath>
</dependency>

Apache Derby, MySQL 및 PostgreSQL 이외의 SQL 데이터베이스에 연결하려면 연결하려는 데이터베이스에 대한 JDBC 드라이버를 래핑하는 라이브러리 확장을 생성할 수 있습니다. 이 확장을 Fuse Online에 업로드한 후 Fuse 온라인 제공 데이터베이스 커넥터는 드라이버에 액세스하여 독점 데이터베이스에 대한 연결을 검증하고 생성할 수 있습니다. 특정 데이터베이스에 대한 새 커넥터를 생성하지 않습니다.

Syndesis 오픈 소스 커뮤니티는 JDBC 드라이버를 래핑하는 확장을 생성하기 위한 프로젝트를 제공합니다.

하나의 드라이버를 확장에서만 패키지합니다. 이렇게 하면 특정 데이터베이스를 관리하는 과정의 일부로 확장을 더 쉽게 관리할 수 있습니다. 그러나 두 개 이상의 드라이버를 래핑하는 라이브러리 확장을 생성할 수 있습니다.

생성된 .jar 파일은 syndesis-jdbc-driver/target 폴더에 있습니다. 이 .jar 파일을 Fuse Online의 확장자로 가져옵니다.

라이브러리 확장을 가져온 후 Fuse Online의 통합을 저장하면 선택적으로 가져온 라이브러리 확장을 선택하고 통합과 연결할 수 있습니다.