Home
Design Server
The documentation provided here describes how to use the Design Server.
Flows
A flow node invokes a sub flow within a flow. Sub-flows need not be wired to other nodes; it is valid to have a flow that is comprised of multiple sub-flows that each have listeners.
Flows
This documentation describes how Flows can be run from REST API, listeners, or they can be scheduled.
Nodes
Cache Read and Write
This documentation describes the function and use of the Cache Read and Cache Write nodes.
Cache Write
The Cache Write node writes key/value pairs to the global cache, or to the flow variables based on the scope property

Design Server
The documentation provided here describes how to use the Design Server.
- Projects
  This documentation describes Design Server projects.
- Schemas
- Maps
- Flows
  A flow node invokes a sub flow within a flow. Sub-flows need not be wired to other nodes; it is valid to have a flow that is comprised of multiple sub-flows that each have listeners.
  - Flows
    This documentation describes how Flows can be run from REST API, listeners, or they can be scheduled.
    - Nodes
      - Maps
        A map node invokes a LNK map within a flow.
      - Flow
        A flow node invokes a sub flow within a flow. Sub-flows need not be wired to other nodes; it is valid to have a flow that is comprised of multiple sub-flows that each have listeners.
      - Source and Target
        Source and Target nodes provide Link with an outside-in approach to developing integrations. The inside-out approach means that you begin with a map, add inputs and outputs, and then configure these to access resources. Connections might be created in the process. The outside-in approach implements the integration from the opposite direction. You begin with the outside interfaces, then connects them to provide maps and other artifacts.
      - Cache Read and Write
        This documentation describes the function and use of the Cache Read and Cache Write nodes.
        Cache Read and Cache Write nodes configuration
        This documentation describes how to configure the Cache Read node and the Cache Write node.
        Cache Read
        The Cache Read node reads key/value pairs from the global cache, or from the flow variables. Optionally, it can delete keys and read from the cache.
        Cache Write
        The Cache Write node writes key/value pairs to the global cache, or to the flow variables based on the scope property
        Settings
        This documentation describes the settings that are available in the Cache Write node.
        Node Logging
        When executed, the node reports the keys that are set in the cache.
      - Clone
        The Clone node has one input and two output terminals. This node clones, or copies the input data from the single input terminal to both output terminals.
      - Decision
      - Fail
        Fails the flow execution.
      - Format Converter
        The Format Converter Node can be used to quickly convert data from one format to another.
      - JAVA
        Invokes a java class, performing user defined functionality based on the properties specified for the java class to act on the input.
      - Join
        The Join node gathers the individual results and appends to a single output file or terminal.
      - Log
        This node logs the raw data from the node input into the file and propagates the data from the input to the output terminal.
      - REST Client
        The REST Client flow node provides a simple and powerful way to access REST services. It can be used to directly invoke REST APIs or can use prebuilt configurations that define the APIs of the service. The node supports:
      - Route
        The Route node provides a way to route data conditionally to one or more outputs of the node. The node bases decisions by evaluating a condition for a flow variable and determining whether to send the data to output 1 or 2 or both, based on the result of the condition.
      - Sleep
        This node suspends the execution of the flow for the specified number of milliseconds
      - Split
        A Split node should be used when there is a need to split csv data processing. This might occur when csv data processing becomes excessively time consuming. Such time-consuming behavior might occur when you send big csv data to the flow input terminal or it might become memory intense when complex data validation is being performed. The Split node can be used with these, and with other data processing tasks that can be done in parallel.
    - Terminals
    - Flow terminals
    - Scheduled flows
    - Listener
      A Flow that has a Map node as its first node, and uses a File adapter for an input, can enable that node's input to be a Watch.
    - Flow audits
      Flow audits are a way to retrieve more verbose information about a flow instance.
    - Flow variables
      Flow Variables are process data variables that go along with the flow execution, accessible to all nodes in the flow while it is being executed under flow executor/engine context.
- Using Design Server
  How to use the HCL Link Design Server.
- Flows
  This documentation describes how Flows can be run from REST API, listeners, or they can be scheduled.
- Schema designer
  Use the schema designer to define, modify, and view schemas. A schema describes the syntax, structure, and semantics of your data.

Cache Write

The Cache Write node writes key/value pairs to the global cache, or to the flow variables based on the scope property

The Cache Write node consists of one input terminal, where the key values are pssed, aon one output terminal. The node propogates data from inptut terminal to the output terminal.

Data is sent to the Input terminal as a set of keys and values. If the Key Prefix property is set, it is perpended to each key value to provide name-spacing.

Example 1: If the Data Format is delimited, and the delimiters are set to defaults, and the data format is expressed as follows:

Key1,Value1\n
Key2,Value2

The record delimiter is an option on the last record.

Example 2: If the Data Format is a JSON array

[
  {
    "key": "Key1",
    "value": "Value1"
  },
  {
    "key": "Key2",
    "value": "Value2"
  }
]

Key1 is set to Value2 and so forth.

Example 3: If the Data Format is a JSON Object.

{ “Key1”:”Value1”, Key2:123 }

Key1 value is set to string "Value1" and Key2 integer value 123 is set to string “123”.

All cache values are stored as strings, but the value provided could be in any format supported by JSON.