Features

There are many interesting features to bring to your attention. This is a growing list of features you may find useful:

Expandable

You can write your own components and call them from the configuration file. Just implement the appropriate interfaces and references them just like any other named component in the configuration. More Readers, Writers, Tasks and other components are being added regularly.

Modular

It is possible to write modules which contain sets of components and allows the deployment of just the code you need. For example, the base module contains basic text and JDBC components. Other modules have been written to connect to specific cloud application (CoyoteSN), FTP file transfer tasks (CoyoteFT), other modules are being considered.

One package in the works is CoyoteDF, a data factory package which will allow you to create test data by allowing you to configure "Readers" which generate test data for writing to any number of formats with any Coyote DX writer.

Encryption

It is possible to use exportable encryption to secure the usernames and passwords in your configuration files. This make sharing configurations with teammates less risky.

The Encryption can be use in transformations to secure data written to local targets. This allows you to work with sensitive data with less risk.

Language Support

All the log messages use resource bundles and can be internationalized.

Embeddable

You can create a Transform engine in your own Java (or Groovy, Scala, etc.) project and have the full capabilities of the Coyote DX toolkit embedded in your application. You can use the transform factory to read in configuration files, or you can create an instance of the DefaultTransformEngine and add the components you want programmatically in your code.

Small Footprint

Much of this code was taken from other projects which were intended to be deployed on very small devices with a limited resource set. These projects involved SCADA and IoT concepts where the code needed to run in "Micro Edition" runtimes on small devices with limited storage and memory. This code base formed the foundation of Coyote DX and in the spirit of the "Internet of Things" will continue to strive to run in smaller footprint environments. There is a TinyDX project which packages Coyote DX in an installer designed for BeagleBone, Raspberry Pi, Parallella, NanoPC-T3, PixelPro and others. It installs only what is necessary, but is capable of running anything which runs under Coyote DX.

Reduced Dependencies

The tool kit does not need to run in servers or containers such as Tomcat or Jetty. This is basic JRE code which can be run from the command line if necessary. This does not use IoC (Inversion of Control) frameworks nor require their libraries. The FatJar build is around 500k - that's everything.

Other modules may require other libraries, but one of the reasons for the modularization of the tools was to keep dependencies to a minimum. You have the ability to install only the components you need. You do not have to install a large application just to read a CSV file into a Fixed Field Length file.

There is no GUI, no IDE. It is a tool kit for developers and those end users with the ability to edit a configuration file and run the utility from the command line. Again, the goal was not to be the be-all, end-all tool for all your integration or ETL needs, it was meant for simplicity and utility.

Simplicity

One of the design goals is to keep things easy to use. Another is to keep things easy to maintain. Both of these are more easily achieved through design simplicity. Our goals did not include the most elegant or clever design. The tool kit just uses a single thread of execution to read and write data while passing records (data frames) through a pipeline of components using basic, trusted and familiar design patterns. This simplicity allows these tools to be embedded in a variety of applications and enable a wide variety of developers to more easily utilize this tool kit.