Maven integration

It is highly recommended that you use Maven. This tutorial helps you create a PipeT module from scratch, using Maven.

If you are in a hurry, you may directly download the resulting source tree and start from there, modifying it according to your needs.

Creating an empty project

To create a module from scratch, start by creating a skeleton project as usual, like so:

mvn archetype:create -DgroupId=com.example -DartifactId=example-module

Declaring dependencies

Then, add pipet-module-api as a dependency to your project by editing pom.xml, and make sure the PipeT repository is added too so that Maven knows where to get the files.

<project>

  ...

  <dependencies>

    ...

    <dependency>
      <groupId>net.sf.pipet</groupId>
      <artifactId>pipet-module-api</artifactId>
      <version>1.2.15</version>
      <scope>compile</scope>
    </dependency>

  </dependencies>

  <repositories>
    <repository>
      <id>pipet.sourceforge.net</id>
      <name>pipet</name>
      <url>http://downloads.sourceforge.net/project/pipet/m2repo</url>
    </repository>
  </repositories>
</project>

Create a module class

Create a module class which implements the PipeT interface; see: Creating a Java module.

Extending the POM

The JAR built by invoking mvn package cannot yet be used by PipeT as a module, because PipeT does not know which class is the "module class". The Maven assembly plugin will do this for you if you add the following to pom.xml. You probably need the compiler plugin as well; otherwise the compiler enforces Java 1.3 compatibility. Both plugins are added by adding the sample below.

<project>

  ...

  <build>
    <plugins>

      ...

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.0</version>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
          <debug>false</debug>
        </configuration>
      </plugin>

      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <archive>
            <manifestEntries>
              <!-- replace the Module-Interface value by your module class -->
              <Module-Interface>com.example.ExampleModule</Module-Interface>
            </manifestEntries>
          </archive>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id><!-- this is used for inheritance merges -->
            <phase>package</phase><!-- append to the packaging phase -->
            <goals>
              <goal>attached</goal><!-- goals == mojos -->
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

  ...

</project>

Don't forget to replace the Module-Interface class name by the appropriate value. Apart from setting the right values in the manifest file, you now get two JAR files instead of one by invoking mvn package. The second JAR contains not only your compiled code, but also any packages your code may depend on. Most likely, you need this to get your module to work if your module has any third party dependencies.

Finally

That's it! The module is ready for use in a pipeline setup, using the pipeline editor to select the generated JAR.

Next steps

Unit tests

Performing unit tests on your module is always a good idea. See the unit test manual for more information.

Eclipse integration

The Maven Eclipse Plugin helps working with Maven projects in Eclipse.

Given an existing Maven project, generate an Eclipse project by doing:

mvn eclipse:eclipse

Next, import the project in Eclipse by selecting "existing project into workspace".