Continuous Integration

Gradle Support

Intershop Studio now supports cartridge builds and dependency management using Gradle build files.

Along with the pre-installation of the Eclipse Gradle features (See http://www.gradle.org/tooling) this integration includes cartridge dependent class path handling, additional cartride types and cartridge build launches.

Cartridge Project Setup

In order to use Gradle features with cartridges the source project needs to include the nature org.springsource.ide.eclipse.gradle.core.nature in its natures section.

Example *.project excerpt:

    <natures>

        <nature>com.intershop.enfinity.studio.core.beehiveNature</nature>

        <nature>org.eclipse.jdt.core.javanature</nature>

        <nature>org.springsource.ide.eclipse.gradle.core.nature</nature>

    </natures>

 See migration hints.

Cartridge Gradle Dependencies

Cartridges that use Gradle build support have to use the new classpath container Cartridge Gradle Dependencies which automatically contains the libraries and dependent projects that are declared in the build.gradle file.

 See migration hints.

Gradle Repository Cartridges

Cartridge dependencies that are resolved using Gradle can be shown in the Cartridge Explorer. The cartridges displayed in the folder Gradle Repository Cartridges are computed using all cartridge source project dependencies.

Cartridge Build

New launch configurations can be used to build a cartridge within Intershop Studio. The project Build Cartridge automatically takes care about that.

Alternatively you might use the new Gradle Tasks view.

Migration Hints

In order to perform necessary changes in the *.project and *.classpath files of cartridge projects the action Refresh/Reset Cartridge Classpath can be used.

Select Reset and confirm with OK in the next dialog.

Pipeline Management

Node Comments

Node Comments are now shown near the node.

Comment Tool

The editor palette contains a tool to create a new node comment or to edit an existing one.

Generic Pipeline Nodes

The pipeline concept allows to use pipelets to define business steps. Since its first appearance pipelets were not really enhanced and modernized in terms of technology, development user-friendliness, usage, new Java concepts (e.g., annotations, code injection)

Despite the fact that there really exist many drawbacks and problems with pipelets: E.g., the inconvenient and error prone usage of configuration values, the poor error handling, the unnecessary restriction of the possible output states, the error prone usage of the pipeline dictionary and many others. Along with these problems it is not possible to, e.g., define other node types such as Start or Decision and Interaction nodes using pipelets. Generic pipeline nodes address all these problems. They can be of any node type but also make no usage of the pipeline dictionary and do not use a separate descriptor file.

For more detailed information on the idea of generic pipeline nodes see: Concept - Pipeline Nodes.

Node Definition

Generic pipeline nodes are defined in a simple POJO-like Java class. Pipelet node specific properties are expressed using annotions. The following simple example shows how properties (configuration values), input and output connectors can be defined:

package com.intershop.test.pipelinenode;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNode;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNodeInput;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNodeOutput;
import com.intershop.beehive.pipeline.capi.annotation.PipelineNodeParameter;

/**
 * A pipeline node that creates the input value for further calculations within
 * a pipeline.
 */
@PipelineNode(type = Types.StartNode)
public class CalculationStartNode
{
    public final static String OUTPUT_NAME = "Output";
    public final static String INPUT_NAME = "Input";

    /**
     * The name of this Start Node
     */
    @PipelineNodeParameter
    private String name;

    @PipelineNodeOutput(name = OUTPUT_NAME)
    private Output output;

    @PipelineNodeInput(name = INPUT_NAME)
    public Output start(Input input)
    {
        int cnt = input.getCount();
        List<Long> l = new ArrayList<>(cnt);
        for (int i = 1; i <= cnt; ++i)
        {
            l.add(Long.valueOf(i));
        }
        output.setNumbers(l);
        String calculation = input.getCalculation();
        output.setCalculation(calculation == null ? CalculatorNode.Calculations.SUM.toString() : calculation);
        return output;
    }
    interface Input
    {
        int getCount();
        String getCalculation();
    }
    interface Output
    {
        void setNumbers(Collection<Long> numbers);
        void setCalculation(String calculation);
    }
}

Node the usage of the annotations:

@PipelineNode: Declares this type as definition of a Pipeline Node.
The attribute 'type=Types.StartNode' marks this node as Start Node.

@PipelineNodeParameter: Declare a Pipeline Node property (Configuration value).
The pipeline engine will inject the value according to its value set in the Pipeline

@PipelineNodeInput: An input connector that is defined as method that takes exactly one parameter.
This method gets invoked by the pipeline engine.
The input data type has to be an interface.
The pipeline engine will inject an object of that type.
The getter methods of this object will access matching objects in the current Pipeline Dictionary.
Dependent on the return type the pipeline engine will chose the right output connector.

@PipelineNodeOutput: An output data type.
The pipeline engine considers bean setters and puts their values into the Pipeline Dictionary.

Pipeline Node Annotation Processor

Intershop Studio as well as Intershop Commerce Suite use annotation processors to create descriptors and to extract model information that are part of such annotated pipeline nodes.

In order to use generic pipeline nodes make sure that this annotation processor is available. This processor needs to be enabled using the project properties dialog:

This annotation processor is triggered by the Intershop Studio/Eclipse Java builder and writes the output into a source folder (e.g., .apt_generated). This means that you should either use: Window|Preferences: General|Workspace: [x] Build automatically or invoke Project|Build Project.

View Enhancements

The Pipelet View as well as the Cartridge Explorer now also show pipelets/pipeline nodes that are defined as Generic Pipeline Nodes.

Generic Nodes in the Pipeline Editor

You can add pipelet/pipeline nodes to a pipeline using drag&drop from the Pipelet View or Cartridge Explorer.

Secure Call Mode

Start nodes which are public now provide an option Secure. If this flag is set, the server only accepts secure HTTPS connections (requires Intershop 7.4 or later). Such secure start nodes are decorated with a small key image in all Intershop views as well as in the Visual Pipeline Editor.

Miscellaneous

Cartridge Qualified References

Since Intershop 7.4. pagelet element references need to be cartridge qualified. Therefore, these references cannot be overridden. This means that such references start with the Cartridge name followed by ':'. The editor, properties views, element hyper-linking, content assist as well as other features now support this element reference style.

See the following example of a non resolvable slot inclusion there quick fixes might be used in order to select an existing slot. The presented slot references use the fully qualified syntax:

Pagelet Model Validation

A validation rule has been added that issues errors if a pagelet model does not use cartridge-qualified references.

You can easily fix this kind of errors using the Quick Fix option:

Further Changes

Multiple Paths in IS_SOURCE

Intershop Studio now supports multiple paths in IS_SOURCE. Multiple paths have to be separated using the path separator character defined for the platform (System.getProperty("path.separator")).

The following features make use of the multiple paths:

New Cartride Wizard

Import Cartridge Project

Intershop Classpath Containers

Source attachments of libraries inside Intershop classpath containers (e.g., required cartridge) are computed using these paths. The preference Cartridge Source Code Locations can still be used for additional source code locations.

Comming Soon!

[This is a technical preview!]

Visual Themes in Pipeline Editor

The Visual Pipeline Editor now features an additional visual theme called Node Icons. To switch the themes:

1. Right-click to open the context menu.
2. Select the action Appearance Theme.
   Alternatively use the Visual pieline Editor's toolbar drop-down.

Removed

Removed

Web Service Based Pipelet Creation

In former versions it was possible to create a pipelet based on a Axis2 Web Service stub. This functionality has been removed.

Pipeline WSDD Editor

In former versions it was possible to create and edit pipeline WSDD files and to open the WebService Explorer on such files. This functionality has been removed.