Index Maven Plugin

This plugin generates an index for trap-utils' PackageScannerFile to be able to detect classpath packages on certain platforms, e.g. Android.

License

License

Categories

Categories

Maven Build Tools Search Business Logic Libraries Dex General Purpose Libraries Utility
GroupId

GroupId

com.ericsson.research.trap
ArtifactId

ArtifactId

trap-index-maven-plugin
Last Version

Last Version

1.4.2
Release Date

Release Date

Type

Type

maven-plugin
Description

Description

Index Maven Plugin
This plugin generates an index for trap-utils' PackageScannerFile to be able to detect classpath packages on certain platforms, e.g. Android.
Project URL

Project URL

http://ericssonresearch.github.io/trap/trap-index-maven-plugin/
Project Organization

Project Organization

Ericsson AB

Download trap-index-maven-plugin

How to add to project

<plugin>
    <groupId>com.ericsson.research.trap</groupId>
    <artifactId>trap-index-maven-plugin</artifactId>
    <version>1.4.2</version>
</plugin>

Dependencies

compile (1)

Group / Artifact Type Version
com.ericsson.research.trap : trap-utils-15 jar 1.4.2

provided (9)

Group / Artifact Type Version
org.apache.maven : maven-plugin-api jar 3.2.1
org.apache.maven.plugin-tools : maven-plugin-annotations jar 3.2
commons-io : commons-io jar 2.4
commons-lang : commons-lang jar 2.4
org.apache.maven : maven-core jar 3.2.1
com.google.inject : guice jar 3.0
org.apache.maven : maven-compat jar 3.2.1
org.eclipse.aether : aether-api jar 0.9.0.M2
org.eclipse.aether : aether-util jar 0.9.0.M2

test (1)

Group / Artifact Type Version
org.apache.maven.plugin-testing : maven-plugin-testing-harness jar 3.2.0

Project Modules

There are no modules declared in this project.

Transport Abstraction Package (trap)

Maven Central

This library provides a socket-based interface that abstracts a set of underlying transports (socket, websocket, http, functioncall), while allowing reconnects, network connection changes, compression and multiplexing. Trap can utilise one or more underlying connections to improve performance, is a fully binary protocol, and is designed to handle failures.

Features

Trap provides

  • Transport independent data transfer using a message paradigm.
  • Optional, reliable, in-order hop-to-hop transfer, regardless of underlying medium.
  • Connection re-establishment, when applicable. This recovers from a network connection change (e.g. wifi to cellular data)
  • Multiplexing of up to 255 application streams, at configurable priority levels that allow pre-emption of bulk data.
  • Support for Java and JavaScript clients and servers (node.js required for servers).

As an abstraction, Trap applies the following overheads (measured in Java, as of 2014)

  • 16 bytes of protocol data per message (excluding transport overhead such as TCP/HTTP)
  • Approximately 50 kilobytes of RAM per connection (configurable usage for active connections)
  • A minimum of 200 kilobytes of RAM to load class files.
  • Two threads for network & timing. Additional threads as required by the application.
  • About 500 kilobytes .jar file (if packaging all features, including slf4j which Trap depends on)

Installation

The easiest way to add Trap for Java is to include the full archive in one step. The following code will include Trap as well as the four default, built-in transports. These transports are not suitable in all contexts, but can serve as an entry point.

	<dependency>
		<groupId>com.ericsson.research.trap.packaging</groupId>
		<artifactId>trap-full</artifactId>
		<version>1.3</version>
	</dependency>

The recommended way is to include the specific transports as needed. The full list of transports is available in the main repo. Some transports, such as HTTP, have multiple providers. It is recommended to use the best provider available (e.g. Servlet) when applicable.

Getting Started

For more detailed information, see the dedicated getting started guide for Java or JavaScript, or check out the Java examples.

Listening for incoming connections

Java

After you have included the Trap dependency, you can create a listener, which is the equivalent to a server socket.

listener = TrapFactory.createListener("http://0.0.0.0:8888");

This will create and configure a listener with a fixed transport (http) to listen on any IP and port 8888. When the port is unspecified, Trap will automatically allocate available ports. The full list of ports can be accessed via listener.getClientConfiguration().

The listener, while allocated, is not listening to the sockets yet. In order to start listening, you need to call

listener.listen(delegate);

where delegate is an object that implements at least the OnAccept interface from the Trap Delegate Interfaces. This delegate will be called by the listener whenever a new Trap connection is established.

Whenever an incoming connection is received, the onAccept method will be called with a TrapEndpoint object. The following code exemplifies how this is handled:

void incomingTrapConnection(TrapEndpoint endpoint, TrapListener listener, Object context) {
	endpoint.setDelegate(myConnectionDelegate);
	myEndpointCollection.put(endpointKey, endpoint);
}

JavaScript (node.js)

Instantiate the endpoint directly. You can optionally pass a configuration as the first parameter, specifying ports, transports, etc.

Trap = require("../trap-node.js");

listener = new Trap.ListenerEndpoint();

To activate the listener, call the listen method. It accepts one argument, an object containing event handlers.

listener.listen({
	incomingTrapConnection: function(endpoint)
	{
		console.log("New connection");
		endpoint.onmessage = function(m)
		{
			endpoint.send(m.data);
		};
	}
});

To verify that initialisation succeeded properly, in both JS and Java you can call

listener.getClientConfiguration();

which will print a complete list of the transports and the host/port combinations they have bound to.

Connecting to a server

Java

Connect to a listener by using the factory to create a new client. After the client is configured and a delegate is set, call open() to begin connecting. The connection process is asynchronous.

client = TrapFactory.createClient("http://127.0.0.1:8888");
client.setDelegate(myDelegate);
client.open();

This will create a client to connect using http to localhost, port 8888. The delegate should implement at least the OnOpen interface to be notified when the connection is open. The trapOpen() function will be called when the connection is established.

JavaScript

Connect to a listener by instantiating an endpoint directly. Note that, unlike Java, the open() method is optional. It exists, but does not need to be called. The client will open automatically after the current run loop.

client = new Trap.ClientEndpoint("http://127.0.0.1:8888");
client.onopen = ...
client.onmessage = ...
// open() is implicit in JS and does not need to be called

Sending data

Send data by as calling TrapEndpoint.send(), from either a client or server. Continuing the client example above, the relevant entry would be (JS and Java)

client.send(data);

Receiving data

Java

To receive data in Java, use the OnData or OnObject delegates. The implemented method will be called when data is received, on the object registered as a delegate using setDelegate().

// OnData callback
public void trapData(byte[] data, int channel, TrapEndpoint endpoint, Object context)
{
    System.out.println("Received message: [" + StringUtil.toUtfString(data) + "] of length " + data.length);
}

JavaScript

In JavaScript, the message event will be dispatched when a message is received.

client.onmessage = function(evt) {
	console.log("Received from server: " + evt.string);
}

Further Guides

There are more detailed guides and examples in the Trap Site.

Links

com.ericsson.research.trap

Ericsson Research

Early research results and innovative ideas from Ericsson Research

Versions

Version
1.4.2
1.4.1
1.4
1.3