Download JAR files tagged by provide with all dependencies

A platform for discovery and communication between various parts of a distributed service or application. At its minimum, the platform is a library which can be used to serialize and deserialize application constructs into payloads which it can then send to and receive from remote endpoints. For now it supports TCP and HTTP communication protocols with WebSockets coming soon. It supports raw byte streams via TCP, as well as application/json via JAX-RS as serialization protocols. It offers plain or SSL/TLS communication for security of your data in transit. For now it is only available in Java, with bindings for other languages coming soon. The communication pattern is request-reply, with fail fast semantics, and with service consumers (clients) knowing beforehand the coordinates of the service providers (servers). The TCP communication protocol offers blocking/unblocking/asynchronous flavors whereas the rest are only blocking for now. Coming soon, the platform will provide a Discovery Service to facilitate the registration of the service providers (servers) and service consumers (clients). In this case, the callers don't need to resolve or even balance their calls towards various endpoints, since the Platform handles this tasks. In this case, the pub/sub communication pattern will also be available (coming soon) with at-most-once delivery guarantees. We intend to provide a Security Service for managing the keys/and certificates of various services as well as Metrics and Logging services (coming soon).

Rouplex-Niossl is a java SPI (service provider interface) for secure (SSL/TLS), selectable, socket channels. Some of the classes in the java.nio.channels package have been extended by secure counterparts that can be used side by side, or replace existing instances of the plain implementations. This package contains just the entry point calls for instantiating such instances, as well as a non-functional, default implementation. For a concrete implementation of these classes you can take a look at Rouplex-Niossl-Spi, which would be included as a separate dependency to your applications. More specifically this library defines SSLSocketChannel class to inherit from SocketChannel, SSLServerSocketChannel to inherit from ServerSocketChannel and SSLSelector to inherit from SSLSelector. One or more instances of SSLSocketChannel can be registered with an (or more) instance of SSLSelector to be selected upon, with the same exact semantics a SocketChannel would expect from registering with a Selector. Further, a mixture of SocketChannels and SSLSocketChannels can be registered simultaneously with an SSLSelector. The secure counterparts abide to the same API and semantics defined for plain channels at https://docs.oracle.com/javase/8/docs/api/java/nio/channels/package-summary.html. This way, the existing products can be easily updated to provide secure communication and new products can achieve security of data in transit by using the already proven and excellent patterns for communication such as nio.

A library extending the Jdk1.8 java.nio.channels package with SSL implementations for SocketChannel, ServerSocketChannel, Selector and SelectorProvider.

This project aims to offer an easy-to-extend Java DAS server framework. It offers several advantages: * Implementing data sources is very easy but also flexible and powerful. * Data caching is built into the system, with access to the caching mechanism made available to the data sources. * All aspects of the server are highly configurable, including selecting options where the DAS 1.53 specification offers choices to the implementor. * The latest Java technologies have been used throughout the system to optimise performance and simplify data source development. * Wherever possible the same terminology is used in the API as in the DAS specification and XML - again, making data source development more easy. * The server allows XSLT transforms of the DAS XML to be configured to provide a simple DAS client view (limited to the single DAS source). More details of the DAS protocol, DAS servers and DAS clients can be found at http://www.biodas.org/wiki/Main_Page. The first version of this server is a complete implementation of Distributed Sequence Annotation System (DAS) Version 1.53. If you are interested in learning more about DAS 1.53, the specification is highly recommended as a concise and complete description of the DAS protocol that can be obtained from: http://biodas.org/documents/spec.html

This module contains a more general approach to construct AlignmentAlgorithms by relying on the theoretical concept of Algebraic Dynamic Programming (ADP) as developed by Giegerich et al. ADP defines four ingredients for an alignment algorithm: 1.) A signature that defines the permitted alignment operations. Operations are just function templates with an associated arity, meaning the number of arguments it takes from the left sequence and from the right sequence. In the TCSAlignmentToolbox we have a fixed signature with the following operations: REPLACEMENT(1, 1), DELETION(1, 0), INSERTION(0, 1), SKIPDELETION(1, 0) and SKIPINSERTION(0, 1) 2.) A regular tree grammar that produces alignments, that is: sequences of operations, in a restricted fashion. 3.) An algebra that can translate such trees to a cost. In the TCSAlignmentToolbox this is a Comparator. 4.) A choice function, in case of the TCSAlignmentToolbox: the strict minimum or the soft minimum. An alignment algorithm in the TCSAlignmentToolbox sense of the word then is the combination of choice function and grammar. While we provide hardcoded versions of these combinations in the main package, the adp package allows you to create your own grammars. You can combine them with a choice function by instantiating one of the Algorithm classes provided in this package with a grammar of your choice. For example: AlignmentAlgorithm algo = new SoftADPScoreAlgorithm(my_grammar, comparator); creates an alignment algorithm that implicitly produces all possible alignments your grammar can construct with the given input, translates them to a cost using the algebra/comparator you provided and applies the soft minimum to return the score. This all gets efficient by dynamic programming. Note that there is runtime overhead when using this method in comparison with the hardcoded algorithms. But for complicated grammars this is a much easier way to go. For more information on the theory, please refer to my master's thesis: "Adaptive Affine Sequence Alignment using Algebraic Dynamic Programming"

Axis2 is an effort to re-design and totally re-implement both Axis/Java and (eventually) Axis/C++ on a new architecture. Evolving from the now standard "handler chain" model which Axis1 pioneered, Axis2 is developing a more flexible pipeline architecture which can yet be managed and packaged in a more organized manner. This new design acknowledges the maturing of the Web services space in terms of new protocols such as WS-ReliableMessaging, WS-Security and WS-Addressing that are built on top of the base SOAP system. At the time Axis1 was designed, while it was fully expected that other protocols such as WS-ReliableMessaging would be built on top of it, there was not a proper extension architecture defined to enable clean composition of such layers. Thus, one of the key motivations for Axis2 is to provide a clean and simple environment for like Apache Sandesha and Apache WSS4J to layer on top of the base SOAP system. Another driving force for Axis2 as well as the move away from RPC oriented Web services towards more document-oriented, message style asynchronous service interactions. The Axis2 project is centered on a new representation for SOAP messages called AXIOM (AXIs Object Model). AXIOM consists of two parts: a complete XML Infoset representation and a SOAP Infoset representation on top of that. The XML Infoset representation provides a JDOM-like simple API but is built on a deferred model via a StAX-based (Streaming API for XML) pull parsing API. A key feature of AXIOM is that it allows one to stop building the XML tree and just access the pull stream directly; thus enabling both maximum flexibility and maximum performance. This approach allows us to support multiple levels of abstraction for consuming and offering Web services: using plain AXIOM, using generated code and statically data-bound data types and so on. At the time of Axis1's design, RPC-style, synchronous, request-response interactions were the order of the day for Web services. Today service interactions are much more message -oriented and exploit many different message exchange patterns. The Axis2 engine architecture is careful to not build in any assumptions of request-response patterns to ensure that it can be used easily to support arbitrary message exchange patterns.