{"generator":"Jekyll","link":[{"@attributes":{"href":"https:\/\/appulse.io\/feed.xml","rel":"self","type":"application\/atom+xml"}},{"@attributes":{"href":"https:\/\/appulse.io\/","rel":"alternate","type":"text\/html"}}],"updated":"2023-03-14T11:48:47+00:00","id":"https:\/\/appulse.io\/feed.xml","title":"Appulse","subtitle":"Appulse aims to build correct concurrent and scalable applications based on JVM and BEAM.","entry":[{"title":"Encon 1.6.7","link":{"@attributes":{"href":"https:\/\/appulse.io\/2018\/10\/07\/encon-1-6-7.html","rel":"alternate","type":"text\/html","title":"Encon 1.6.7"}},"published":"2018-10-07T00:00:00+00:00","updated":"2018-10-07T00:00:00+00:00","id":"https:\/\/appulse.io\/2018\/10\/07\/encon-1-6-7","content":"<p>Encon 1.6.7 has been released and is is now available from <a href=\"https:\/\/search.maven.org\/search?q=g:io.appulse.encon%20AND%20v:1.6.7\">Maven Central<\/a>.<\/p>\n\n<p>The main changes related to abandoning cached values (or simplify implementation) for Erlang terms. In the future release <a href=\"http:\/\/erlang.org\/doc\/apps\/erts\/erl_ext_dist.html#distribution_header\">distribution header<\/a> will be used for atoms caching.<\/p>\n\n<h3 id=\"changed\">Changed<\/h3>\n\n<ul>\n  <li><code class=\"language-plaintext highlighter-rouge\">ErlangInteger.cached<\/code> now has <code class=\"language-plaintext highlighter-rouge\">java.lang.Integer<\/code>-like cache strategy.<\/li>\n<\/ul>\n\n<h3 id=\"removed\">Removed<\/h3>\n\n<ul>\n  <li><code class=\"language-plaintext highlighter-rouge\">ErlangAtom.cached<\/code> methods;<\/li>\n  <li><code class=\"language-plaintext highlighter-rouge\">ErlangPid.cached<\/code> method.<\/li>\n<\/ul>","author":{"name":{}},"summary":"Encon 1.6.7 has been released and is is now available from Maven Central."},{"title":"Encon 1.6.5","link":{"@attributes":{"href":"https:\/\/appulse.io\/2018\/09\/28\/encon-1.6.5.html","rel":"alternate","type":"text\/html","title":"Encon 1.6.5"}},"published":"2018-09-28T00:00:00+00:00","updated":"2018-09-28T00:00:00+00:00","id":"https:\/\/appulse.io\/2018\/09\/28\/encon-1.6.5","content":"<p>Encon 1.6.5 has been released and is is now available from <a href=\"https:\/\/search.maven.org\/search?q=g:io.appulse.encon%20AND%20v:1.6.5\">Maven Central<\/a>.<\/p>\n\n<p>It is minor quick fix release, nothing fascinating.<\/p>\n\n<h3 id=\"changed\">Changed<\/h3>\n\n<ul>\n  <li>Quick fix for <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/issues\/10\">GitHub issue<\/a>, added <code class=\"language-plaintext highlighter-rouge\">ATOM<\/code> and <code class=\"language-plaintext highlighter-rouge\">SMALL_ATOM<\/code> serialization;<\/li>\n  <li>Remove <code class=\"language-plaintext highlighter-rouge\">LruCache<\/code> from <code class=\"language-plaintext highlighter-rouge\">encon-common<\/code> and use the same class from <code class=\"language-plaintext highlighter-rouge\">io.appulse:utils-java:1.10.0<\/code>.<\/li>\n<\/ul>","author":{"name":{}},"summary":"Encon 1.6.5 has been released and is is now available from Maven Central."},{"title":"Encon library basic concepts overview","link":{"@attributes":{"href":"https:\/\/appulse.io\/2018\/09\/19\/encon-library-basic-concepts-overview.html","rel":"alternate","type":"text\/html","title":"Encon library basic concepts overview"}},"published":"2018-09-19T00:00:00+00:00","updated":"2018-09-19T00:00:00+00:00","id":"https:\/\/appulse.io\/2018\/09\/19\/encon-library-basic-concepts-overview","content":"<p>The <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/tree\/master\/encon\">encon<\/a> library provides a set of tools for communication with Erlang processes. It can also be used for communication with other Java processes using the same library, as well as C processes using the special library.<\/p>\n\n<p>Since this package provides a mechanism for communicating with Erlang, message recipients can be Erlang processes or instances of <code class=\"language-plaintext highlighter-rouge\">io.appulse.encon.mailbox.Mailbox<\/code>, both of which are identified with pids and possibly registered names. When pids or mailboxes are mentioned as message senders or recipients in this section, it should assumed that even Erlang processes are included, unless specified otherwise. The classes in Encon support the following:<\/p>\n\n<ul>\n  <li>manipulation of data represented as Erlang data types;<\/li>\n  <li>conversion of data between Java and Erlang formats;<\/li>\n  <li>encoding and decoding of Erlang data types for transmission or storage;<\/li>\n  <li>communication between Java nodes and Erlang processes;<\/li>\n<\/ul>\n\n<p>In the following sections, these topics are described:<\/p>\n\n<ul>\n  <li><a href=\"#mapping-of-basic-erlang-types-to-java\">Mapping of basic Erlang types to Java<\/a><\/li>\n  <li><a href=\"#special-mapping-issues\">Special mapping issues<\/a><\/li>\n  <li><a href=\"#nodes\">Nodes<\/a><\/li>\n  <li><a href=\"#mailboxes\">Mailboxes<\/a><\/li>\n  <li><a href=\"#connections\">Connections<\/a><\/li>\n  <li><a href=\"#sending-and-receiving-messages\">Sending and receiving messages<\/a><\/li>\n  <li><a href=\"#sending-arbitrary-data\">Sending arbitrary data<\/a><\/li>\n  <li><a href=\"#linking-to-remote-processes\">Linking to remote processes<\/a><\/li>\n  <li><a href=\"#using-epmd\">Using EPMD<\/a><\/li>\n  <li><a href=\"#remote-procedure-calls\">Remote procedure calls<\/a><\/li>\n  <li><a href=\"#tracing\">Tracing<\/a><\/li>\n<\/ul>\n\n<h2 id=\"mapping-of-basic-erlang-types-to-java\">Mapping of basic Erlang types to Java<\/h2>\n\n<p>This section describes the mapping of Erlang basic types to Java.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th style=\"text-align: left\">Erlang type<\/th>\n      <th style=\"text-align: left\">Java type<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td style=\"text-align: left\">atom<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangAtom.java\">ErlangAtom<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">binary<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangBinary.java\">ErlangBinary<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">floating point types<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangFloat.java\">ErlangFloat<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">integral types<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangInteger.java\">ErlangInteger<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">list<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangList.java\">ErlangList<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">pid<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangPid.java\">ErlangPid<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">port<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangPort.java\">ErlangPort<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">ref<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangReference.java\">ErlangReference<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">tuple<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangTuple.java\">ErlangTuple<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">map<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangMap.java\">ErlangMap<\/a><\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\">term<\/td>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/ErlangTerm.java\">ErlangTerm<\/a><\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<p>Also, there are many static function helpers at <code class=\"language-plaintext highlighter-rouge\">io.appulse.encon.terms.Erlang<\/code> utility class, just compare the following examples:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.type.ErlangAtom<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.type.ErlangBitString<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.type.ErlangInteger<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.type.ErlangTuple<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">message<\/span> <span class=\"o\">=<\/span> <span class=\"k\">new<\/span> <span class=\"nc\">ErlangTuple<\/span><span class=\"o\">(<\/span>\n    <span class=\"k\">new<\/span> <span class=\"nf\">ErlangAtom<\/span><span class=\"o\">(<\/span><span class=\"s\">\"ok\"<\/span><span class=\"o\">),<\/span>\n    <span class=\"k\">new<\/span> <span class=\"nf\">ErlangInteger<\/span><span class=\"o\">(<\/span><span class=\"mi\">42<\/span><span class=\"o\">),<\/span>\n    <span class=\"k\">new<\/span> <span class=\"nf\">ErlangBitString<\/span><span class=\"o\">(<\/span><span class=\"s\">\"value\"<\/span><span class=\"o\">)<\/span>\n<span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>The code sample above equals to the code below:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">atom<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">bstring<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">number<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">tuple<\/span><span class=\"o\">;<\/span>\n\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">message<\/span> <span class=\"o\">=<\/span> <span class=\"n\">tuple<\/span><span class=\"o\">(<\/span><span class=\"n\">atom<\/span><span class=\"o\">(<\/span><span class=\"s\">\"ok\"<\/span><span class=\"o\">),<\/span> <span class=\"n\">number<\/span><span class=\"o\">(<\/span><span class=\"mi\">42<\/span><span class=\"o\">),<\/span> <span class=\"n\">bstring<\/span><span class=\"o\">(<\/span><span class=\"s\">\"value\"<\/span><span class=\"o\">));<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<blockquote>\n  <p><strong>IMPORTANT:<\/strong> In some cases, <code class=\"language-plaintext highlighter-rouge\">Erlang.*<\/code> functions could use cached value, instead of creating a new term. It may be useful for repeatable values like atoms and numbers.<\/p>\n<\/blockquote>\n\n<h2 id=\"special-mapping-issues\">Special mapping issues<\/h2>\n\n<p>The atoms <code class=\"language-plaintext highlighter-rouge\">true<\/code> and <code class=\"language-plaintext highlighter-rouge\">false<\/code> are special atoms, used as boolean values. The class <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangAtom.java#L138\">ErlangAtom<\/a> can be used to represent these.<\/p>\n\n<p>Lists in Erlang are also used to describe sequences of printable characters (strings). A convenience class <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangString.java\">ErlangString<\/a> is provided to represent Erlang strings.<\/p>\n\n<h2 id=\"nodes\">Nodes<\/h2>\n\n<p>A node as defined by Erlang\/OTP is an instance of the Erlang Runtime System, a virtual machine roughly equivalent to a JVM. Each node has a unique name in the form of an identifier composed partly of the hostname on which the node is running, e.g \u201cpopa@appulse.io\u201d. Several such nodes can run on the same host as long as their names are unique. The class <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon\/src\/main\/java\/io\/appulse\/encon\/Node.java\">Node<\/a> represents an Erlang node. It is created with a name and optionally a port number on which it listens for incoming connections. Before creating an instance of <code class=\"language-plaintext highlighter-rouge\">Node<\/code>, ensure that <code class=\"language-plaintext highlighter-rouge\">Epmd<\/code> is running on the host machine. You can you Appulse\u2019s Java implementation of <a href=\"https:\/\/github.com\/appulse-projects\/epmd-java\/blob\/master\/server\/README.md\">Epmd<\/a> server. See the Erlang documentation for more information about <code class=\"language-plaintext highlighter-rouge\">Epmd<\/code>.<\/p>\n\n<p>In this example, the host name is appended automatically to the identifier, and the port number is chosen by the underlying system:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.Node<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.Nodes<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">Node<\/span> <span class=\"n\">node<\/span> <span class=\"o\">=<\/span> <span class=\"nc\">Nodes<\/span><span class=\"o\">.<\/span><span class=\"na\">singleNode<\/span><span class=\"o\">(<\/span><span class=\"s\">\"popa\"<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<h2 id=\"mailboxes\">Mailboxes<\/h2>\n\n<p>Erlang processes running on an Erlang node are identified by process identifiers (pids) and, optionally, by registered names unique within the node. Each Erlang process has an implicit mailbox that is used to receive messages; the mailbox is identified with the pid of the process.<\/p>\n\n<p>Encon provides a similar mechanism with the class <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon\/src\/main\/java\/io\/appulse\/encon\/mailbox\/Mailbox.java\">Mailbox<\/a>, a mailbox that can be used to send and receive messages asynchronously. Each <code class=\"language-plaintext highlighter-rouge\">Mailbox<\/code> is identified with a unique pid and , optionally, a registered name unique within the <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon\/src\/main\/java\/io\/appulse\/encon\/Node.java\">Node<\/a>.<\/p>\n\n<p>Applications are free to create mailboxes as necessary. This is done as follows:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.mailbox.Mailbox<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">Mailbox<\/span> <span class=\"n\">mailbox<\/span> <span class=\"o\">=<\/span> <span class=\"n\">node<\/span><span class=\"o\">.<\/span><span class=\"na\">mailbox<\/span><span class=\"o\">()<\/span>\n    <span class=\"o\">.<\/span><span class=\"na\">build<\/span><span class=\"o\">();<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>The mailbox created in the above example has no registered name, although it does have a pid. The pid can be obtained from the mailbox and included in messages sent from the mailbox, so that remote processes are able to respond.<\/p>\n\n<p>An application can register a name for a mailbox, either when the mailbox is initially created:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.mailbox.Mailbox<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">Mailbox<\/span> <span class=\"n\">mailbox<\/span> <span class=\"o\">=<\/span> <span class=\"n\">node<\/span><span class=\"o\">.<\/span><span class=\"na\">mailbox<\/span><span class=\"o\">()<\/span>\n    <span class=\"o\">.<\/span><span class=\"na\">name<\/span><span class=\"o\">(<\/span><span class=\"s\">\"my_process_name\"<\/span><span class=\"o\">)<\/span> <span class=\"c1\">\/\/ this is an optional<\/span>\n    <span class=\"o\">.<\/span><span class=\"na\">build<\/span><span class=\"o\">();<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>or later on, as necessary:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.mailbox.Mailbox<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">Mailbox<\/span> <span class=\"n\">mailbox<\/span> <span class=\"o\">=<\/span> <span class=\"n\">node<\/span><span class=\"o\">.<\/span><span class=\"na\">mailbox<\/span><span class=\"o\">().<\/span><span class=\"na\">build<\/span><span class=\"o\">();<\/span>\n<span class=\"n\">node<\/span><span class=\"o\">.<\/span><span class=\"na\">register<\/span><span class=\"o\">(<\/span><span class=\"n\">mailbox<\/span><span class=\"o\">,<\/span> <span class=\"s\">\"my_process_name\"<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>Registered names are usually necessary in order to start communication, since it is impossible to know in advance the pid of a remote process. If a well-known name for one of the processes is chosen in advance and known by all communicating parties within an application, each mailbox can send an initial message to the named mailbox, which then can identify the sender pid.<\/p>\n\n<h2 id=\"connections\">Connections<\/h2>\n\n<p>It is not necessary to explicitly set up communication with a remote node. Simply sending a message to a mailbox on that node will cause the <code class=\"language-plaintext highlighter-rouge\">Node<\/code> to create a connection if one does not already exist. Once the connection is established, subsequent messages to the same node will reuse the same connection.<\/p>\n\n<p>It is possible to check for the existence of a remote node before attempting to communicate with it. Here we send a ping message to the remote node to see if it is alive and accepting connections:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"k\">if<\/span> <span class=\"o\">(<\/span><span class=\"n\">node<\/span><span class=\"o\">.<\/span><span class=\"na\">ping<\/span><span class=\"o\">(<\/span><span class=\"s\">\"remote\"<\/span><span class=\"o\">))<\/span> <span class=\"o\">{<\/span>\n  <span class=\"nc\">System<\/span><span class=\"o\">.<\/span><span class=\"na\">out<\/span><span class=\"o\">.<\/span><span class=\"na\">println<\/span><span class=\"o\">(<\/span><span class=\"s\">\"remote is up\"<\/span><span class=\"o\">);<\/span>\n<span class=\"o\">}<\/span> <span class=\"k\">else<\/span> <span class=\"o\">{<\/span>\n  <span class=\"nc\">System<\/span><span class=\"o\">.<\/span><span class=\"na\">out<\/span><span class=\"o\">.<\/span><span class=\"na\">println<\/span><span class=\"o\">(<\/span><span class=\"s\">\"remote is not up\"<\/span><span class=\"o\">);<\/span>\n<span class=\"o\">}<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>If the call to <code class=\"language-plaintext highlighter-rouge\">ping()<\/code> succeeds, a connection to the remote node has been established. Note that it is not necessary to ping remote nodes before communicating with them, but by using ping you can determine if the remote exists before attempting to communicate with it.<\/p>\n\n<p>Connections are only permitted by nodes using the same security cookie. The cookie is a short string provided either as an argument when creating <code class=\"language-plaintext highlighter-rouge\">Node<\/code> objects, or found in the user\u2019s home directory in the file <code class=\"language-plaintext highlighter-rouge\">.erlang.cookie<\/code>. When a connection attempt is made, the string is used as part of the authentication process. If you are having trouble getting communication to work, use the trace facility (described later in this document) to show the connection establishment. A likely problem is that the cookies are different.<\/p>\n\n<p>Connections are never broken explicitly. If a node fails or is closed, a connection may be broken however.<\/p>\n\n<h2 id=\"sending-and-receiving-messages\">Sending and receiving messages<\/h2>\n\n<p>Messages sent with this package must be instances of <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/ErlangTerm.java\">ErlangTerm<\/a> or one of its subclasses. Message can be sent to processes or pids, either by specifying the pid of the remote, or its registered name and node.<\/p>\n\n<p>In this example, we create a message containing our own pid so the echo process can reply:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">atom<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">tuple<\/span><span class=\"o\">;<\/span>\n\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">message<\/span> <span class=\"o\">=<\/span> <span class=\"n\">atom<\/span><span class=\"o\">(<\/span><span class=\"s\">\"hello, world\"<\/span><span class=\"o\">);<\/span>\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">tuple<\/span> <span class=\"o\">=<\/span> <span class=\"n\">tuple<\/span><span class=\"o\">(<\/span><span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">getPid<\/span><span class=\"o\">(),<\/span> <span class=\"n\">message<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>When we send the message, a connection will be created:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">send<\/span><span class=\"o\">(<\/span><span class=\"s\">\"popa@appulse.io\"<\/span><span class=\"o\">,<\/span> <span class=\"s\">\"echo\"<\/span><span class=\"o\">,<\/span> <span class=\"n\">tuple<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>And here we receive the reply:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.connection.regular.Message<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">Message<\/span> <span class=\"n\">message<\/span> <span class=\"o\">=<\/span> <span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">receive<\/span><span class=\"o\">();<\/span>\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">body<\/span> <span class=\"o\">=<\/span> <span class=\"n\">message<\/span><span class=\"o\">.<\/span><span class=\"na\">getBody<\/span><span class=\"o\">();<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>Messages are sent asynchronously, so the call to <code class=\"language-plaintext highlighter-rouge\">send()<\/code> returns as soon as the message has been dispatched to the underlying communication layer. This means that you receive no indication whether the operation completed successfully or the remote even existed. If you need this kind of confirmation, you should wait for a response from the remote process.<\/p>\n\n<p>The echo server itself might look like this:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">NIL<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">tuple<\/span><span class=\"o\">;<\/span>\n\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.mailbox.Mailbox<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.Node<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.Nodes<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.type.ErlangPid<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">Node<\/span> <span class=\"n\">node<\/span> <span class=\"o\">=<\/span> <span class=\"nc\">Nodes<\/span><span class=\"o\">.<\/span><span class=\"na\">singleNode<\/span><span class=\"o\">(<\/span><span class=\"s\">\"popa\"<\/span><span class=\"o\">);<\/span>\n<span class=\"nc\">Mailbox<\/span> <span class=\"n\">mailbox<\/span> <span class=\"o\">=<\/span> <span class=\"n\">node<\/span><span class=\"o\">.<\/span><span class=\"na\">mailbox<\/span><span class=\"o\">()<\/span>\n    <span class=\"o\">.<\/span><span class=\"na\">name<\/span><span class=\"o\">(<\/span><span class=\"s\">\"echo\"<\/span><span class=\"o\">)<\/span>\n    <span class=\"o\">.<\/span><span class=\"na\">build<\/span><span class=\"o\">();<\/span>\n\n<span class=\"k\">while<\/span> <span class=\"o\">(<\/span><span class=\"kc\">true<\/span><span class=\"o\">)<\/span> <span class=\"o\">{<\/span>\n  <span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">message<\/span> <span class=\"o\">=<\/span> <span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">receive<\/span><span class=\"o\">().<\/span><span class=\"na\">getBody<\/span><span class=\"o\">();<\/span>\n\n  <span class=\"nc\">ErlangPid<\/span> <span class=\"n\">from<\/span> <span class=\"o\">=<\/span> <span class=\"n\">message<\/span><span class=\"o\">.<\/span><span class=\"na\">get<\/span><span class=\"o\">(<\/span><span class=\"mi\">0<\/span><span class=\"o\">)<\/span>\n        <span class=\"o\">.<\/span><span class=\"na\">filter<\/span><span class=\"o\">(<\/span><span class=\"nl\">ErlangTerm:<\/span><span class=\"o\">:<\/span><span class=\"n\">isPid<\/span><span class=\"o\">)<\/span>\n        <span class=\"o\">.<\/span><span class=\"na\">map<\/span><span class=\"o\">(<\/span><span class=\"nl\">ErlangTerm:<\/span><span class=\"o\">:<\/span><span class=\"n\">asPid<\/span><span class=\"o\">)<\/span>\n        <span class=\"o\">.<\/span><span class=\"na\">orElseThrow<\/span><span class=\"o\">(()<\/span> <span class=\"o\">-&gt;<\/span> <span class=\"k\">new<\/span> <span class=\"nc\">RuntimeException<\/span><span class=\"o\">(<\/span><span class=\"s\">\"0 element must be a PID\"<\/span><span class=\"o\">));<\/span>\n\n  <span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">response<\/span> <span class=\"o\">=<\/span> <span class=\"n\">tuple<\/span><span class=\"o\">(<\/span><span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">getPid<\/span><span class=\"o\">(),<\/span> <span class=\"n\">message<\/span><span class=\"o\">.<\/span><span class=\"na\">get<\/span><span class=\"o\">(<\/span><span class=\"mi\">1<\/span><span class=\"o\">).<\/span><span class=\"na\">orElse<\/span><span class=\"o\">(<\/span><span class=\"no\">NIL<\/span><span class=\"o\">));<\/span>\n\n  <span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">send<\/span><span class=\"o\">(<\/span><span class=\"n\">from<\/span><span class=\"o\">,<\/span> <span class=\"n\">response<\/span><span class=\"o\">);<\/span>\n<span class=\"o\">}<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>In the examples above, only one mailbox was created on each node. however you are free to create as many mailboxes on each node as you like. You are also free to create as many nodes as you like on each JVM, however because each node uses some limited system resources such as file descriptors, it is recommended that you create only a small number of nodes (such as one) on each JVM.<\/p>\n\n<h2 id=\"sending-arbitrary-data\">Sending arbitrary data<\/h2>\n\n<p>This library was originally intended to be used for communicating between Java and Erlang, and for that reason the send and receive methods all use Java representations of Erlang data types.<\/p>\n\n<p>However it is possible to use the library to communicate with remote processes written in Java as well, and in these cases it may be desirable to send other data types.<\/p>\n\n<p>The simplest way to do this is to encapsulate arbitrary data in messages of type <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/encon-terms\/src\/main\/java\/io\/appulse\/encon\/terms\/type\/ErlangBinary.java\">ErlangBinary<\/a>. The <code class=\"language-plaintext highlighter-rouge\">ErlangBinary<\/code> instance can be created from arbitrary Java objects that implement the <code class=\"language-plaintext highlighter-rouge\">Serializable<\/code> or <code class=\"language-plaintext highlighter-rouge\">Externalizable<\/code> interface:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">encon<\/span><span class=\"o\">.<\/span><span class=\"na\">terms<\/span><span class=\"o\">.<\/span><span class=\"na\">Erlang<\/span><span class=\"o\">.<\/span><span class=\"na\">binary<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">MyClass<\/span> <span class=\"n\">object<\/span> <span class=\"o\">=<\/span> <span class=\"k\">new<\/span> <span class=\"nc\">MyClass<\/span><span class=\"o\">();<\/span>\n<span class=\"nc\">ErlangBinary<\/span> <span class=\"n\">term<\/span> <span class=\"o\">=<\/span> <span class=\"n\">binary<\/span><span class=\"o\">(<\/span><span class=\"n\">object<\/span><span class=\"o\">);<\/span>\n<span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">send<\/span><span class=\"o\">(<\/span><span class=\"n\">remote<\/span><span class=\"o\">,<\/span> <span class=\"n\">term<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>The example above will cause the object to be serialized and encapsulated in an <code class=\"language-plaintext highlighter-rouge\">ErlangBinary<\/code> before being sent. The recipient will receive an <code class=\"language-plaintext highlighter-rouge\">ErlangBinary<\/code> but can extract the original object from it:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">static<\/span> <span class=\"n\">io<\/span><span class=\"o\">.<\/span><span class=\"na\">appulse<\/span><span class=\"o\">.<\/span><span class=\"na\">utils<\/span><span class=\"o\">.<\/span><span class=\"na\">SerializationUtils<\/span><span class=\"o\">.<\/span><span class=\"na\">deserialize<\/span><span class=\"o\">;<\/span>\n\n<span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">term<\/span> <span class=\"o\">=<\/span> <span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">receive<\/span><span class=\"o\">().<\/span><span class=\"na\">getBody<\/span><span class=\"o\">();<\/span>\n<span class=\"k\">if<\/span> <span class=\"o\">(<\/span><span class=\"n\">term<\/span><span class=\"o\">.<\/span><span class=\"na\">isBinary<\/span><span class=\"o\">())<\/span> <span class=\"o\">{<\/span>\n  <span class=\"kt\">byte<\/span><span class=\"o\">[]<\/span> <span class=\"n\">bytes<\/span> <span class=\"o\">=<\/span> <span class=\"n\">term<\/span><span class=\"o\">.<\/span><span class=\"na\">asBinary<\/span><span class=\"o\">();<\/span>\n  <span class=\"nc\">MyClass<\/span> <span class=\"n\">object<\/span> <span class=\"o\">=<\/span> <span class=\"o\">(<\/span><span class=\"nc\">MyClass<\/span><span class=\"o\">)<\/span> <span class=\"n\">deserialize<\/span><span class=\"o\">(<\/span><span class=\"kt\">byte<\/span><span class=\"o\">);<\/span>\n<span class=\"o\">}<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>If you want to serialize\/deserialize your <code class=\"language-plaintext highlighter-rouge\">POJO<\/code>s not only between Java processes, you should to use <a href=\"https:\/\/appulse.io\/pinned\/advanced-usage.html#databinding\">encon-databind<\/a> extension.<\/p>\n\n<h2 id=\"linking-to-remote-processes\">Linking to remote processes<\/h2>\n\n<p>Erlang defines a concept known as linked processes. A link is an implicit connection between two processes that causes an exception to be raised in one of the processes if the other process terminates for any reason. Links are bidirectional: it does not matter which of the two processes created the link or which of the linked processes eventually terminates; an exception will be raised in the remaining process. Links are also idempotent: at most one link can exist between two given processes, only one operation is necessary to remove the link.<\/p>\n\n<p>Encon provides a similar mechanism. Also here, no distinction is made between mailboxes and Erlang processes. A link can be created to a remote mailbox or process when its pid is known:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">link<\/span><span class=\"o\">(<\/span><span class=\"n\">remotePid<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>The link can be removed by either of the processes in a similar manner:<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">unlink<\/span><span class=\"o\">(<\/span><span class=\"n\">remotePid<\/span><span class=\"o\">);<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>If the remote process terminates while the link is still in place, an exception will be raised on a subsequent call to receive():<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.mailbox.exception.ReceivedExitException<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"k\">try<\/span> <span class=\"o\">{<\/span>\n  <span class=\"n\">message<\/span> <span class=\"o\">=<\/span> <span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">receive<\/span><span class=\"o\">();<\/span>\n<span class=\"o\">}<\/span> <span class=\"k\">catch<\/span> <span class=\"o\">(<\/span><span class=\"nc\">ReceivedExitException<\/span> <span class=\"n\">ex<\/span><span class=\"o\">)<\/span> <span class=\"o\">{<\/span>\n  <span class=\"n\">log<\/span><span class=\"o\">.<\/span><span class=\"na\">error<\/span><span class=\"o\">(<\/span><span class=\"s\">\"Remote pid {} has terminated with reason '{}'\"<\/span><span class=\"o\">,<\/span> <span class=\"n\">ex<\/span><span class=\"o\">.<\/span><span class=\"na\">getFrom<\/span><span class=\"o\">(),<\/span> <span class=\"n\">ex<\/span><span class=\"o\">.<\/span><span class=\"na\">getReason<\/span><span class=\"o\">());<\/span>\n<span class=\"o\">}<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p>When a mailbox is explicitly closed, exit messages will be sent in order to break any outstanding links.<\/p>\n\n<h2 id=\"using-epmd\">Using EPMD<\/h2>\n\n<p>Epmd is the Erlang Port Mapper Daemon. Distributed Erlang nodes register with epmd on the localhost to indicate to other nodes that they exist and can accept connections. Epmd maintains a register of node and port number information, and when a node wishes to connect to another node, it first contacts epmd in order to find out the correct port number to connect to.<\/p>\n\n<p>The basic interaction with EPMD is done through instances of <a href=\"https:\/\/github.com\/appulse-projects\/epmd-java\/blob\/master\/client\/src\/main\/java\/io\/appulse\/epmd\/java\/client\/EpmdClient.java\">EpmdClient<\/a> class. Nodes wishing to contact other nodes must first request information from Epmd before a connection can be set up, however this is done automatically by <code class=\"language-plaintext highlighter-rouge\">Node.connect*<\/code> methods family when necessary.<\/p>\n\n<p>When you use <code class=\"language-plaintext highlighter-rouge\">Node.connect*<\/code> to connect to an Erlang node, a connection is first made to epmd and, if the node is known, a connection is then made to the Erlang node.<\/p>\n\n<p>Java nodes can also register themselves with epmd if they want other nodes in the system to be able to find and connect to them. This is done by call to method <code class=\"language-plaintext highlighter-rouge\">EpmdClient.register<\/code>.<\/p>\n\n<p>Be aware that on some systems (such as VxWorks), a failed node will not be detected by this mechanism since the operating system does not automatically close descriptors that were left open when the node failed. If a node has failed in this way, epmd will prevent you from registering a new node with the old name, since it thinks that the old name is still in use. In this case, you must unregister the name explicitly, by using <code class=\"language-plaintext highlighter-rouge\">EpmdClient.stop()<\/code>.<\/p>\n\n<p>This will cause epmd to close the connection from the far end. Note that if the name was in fact still in use by a node, the results of this operation are unpredictable. Also, doing this does not cause the local end of the connection to close, so resources may be consumed.<\/p>\n\n<h2 id=\"remote-procedure-calls\">Remote procedure calls<\/h2>\n\n<p>An Erlang node acting as a client to another Erlang node typically sends a request and waits for a reply. Such a request is included in a function call at a remote node and is called a remote procedure call.<\/p>\n\n<div class=\"language-java highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"kn\">import<\/span> <span class=\"nn\">io.appulse.encon.terms.ErlangTerm<\/span><span class=\"o\">;<\/span>\n\n\n<span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">call<\/span><span class=\"o\">(<\/span><span class=\"s\">\"remote@appulse.io\"<\/span><span class=\"o\">,<\/span> <span class=\"s\">\"erlang\"<\/span><span class=\"o\">,<\/span> <span class=\"s\">\"date\"<\/span><span class=\"o\">);<\/span>\n<span class=\"nc\">ErlangTerm<\/span> <span class=\"n\">response<\/span> <span class=\"o\">=<\/span> <span class=\"n\">mailbox<\/span><span class=\"o\">.<\/span><span class=\"na\">receiveRemoteProcedureResult<\/span><span class=\"o\">();<\/span>\n<\/code><\/pre><\/div><\/div>\n\n<p><code class=\"language-plaintext highlighter-rouge\">erlang:date\/0<\/code> is just called to get the date tuple from a remote host.<\/p>\n\n<blockquote>\n  <p><strong>IMPORTANT:<\/strong> Note that this method has unpredicatble results if the remote node is not an <code class=\"language-plaintext highlighter-rouge\">Erlang<\/code>\/<code class=\"language-plaintext highlighter-rouge\">Elixir<\/code> node. If you want to call remote procedures of another <code class=\"language-plaintext highlighter-rouge\">Java<\/code> node, you need to create <strong>rex<\/strong> mailbox by yourself.<\/p>\n<\/blockquote>\n\n<h2 id=\"tracing\">Tracing<\/h2>\n\n<p>Communication between nodes can be traced by setting an <code class=\"language-plaintext highlighter-rouge\">Encon<\/code> and <code class=\"language-plaintext highlighter-rouge\">Netty<\/code> log levels, like this:<\/p>\n\n<p><strong>src\/main\/resources\/logback.xml<\/strong><\/p>\n\n<div class=\"language-xml highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"cp\">&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;<\/span>\n<span class=\"nt\">&lt;configuration&gt;<\/span>\n  <span class=\"nt\">&lt;include<\/span> <span class=\"na\">resource=<\/span><span class=\"s\">\"io\/appulse\/logging\/logback\/base.xml\"<\/span><span class=\"nt\">\/&gt;<\/span>\n\n  <span class=\"nt\">&lt;logger<\/span> <span class=\"na\">name=<\/span><span class=\"s\">\"io.appulse.encon.connection\"<\/span> <span class=\"na\">level=<\/span><span class=\"s\">\"DEBUG\"<\/span><span class=\"nt\">\/&gt;<\/span>\n  <span class=\"nt\">&lt;logger<\/span> <span class=\"na\">name=<\/span><span class=\"s\">\"io.netty.handler.logging\"<\/span> <span class=\"na\">level=<\/span><span class=\"s\">\"DEBUG\"<\/span><span class=\"nt\">\/&gt;<\/span>\n<span class=\"nt\">&lt;\/configuration&gt;<\/span>\n<\/code><\/pre><\/div><\/div>","author":{"name":{}},"summary":"The encon library provides a set of tools for communication with Erlang processes. It can also be used for communication with other Java processes using the same library, as well as C processes using the special library."},{"title":"Encon 1.6.4","link":{"@attributes":{"href":"https:\/\/appulse.io\/2018\/09\/17\/encon-1-6-4.html","rel":"alternate","type":"text\/html","title":"Encon 1.6.4"}},"published":"2018-09-17T00:00:00+00:00","updated":"2018-09-17T00:00:00+00:00","id":"https:\/\/appulse.io\/2018\/09\/17\/encon-1-6-4","content":"<p>Encon 1.6.4 has been released and is is now available from <a href=\"https:\/\/search.maven.org\/search?q=g:io.appulse.encon%20AND%20v:1.6.4\">Maven Central<\/a>.<\/p>\n\n<h3 id=\"added\">Added<\/h3>\n\n<ul>\n  <li><code class=\"language-plaintext highlighter-rouge\">Mailbox.call()<\/code> and <code class=\"language-plaintext highlighter-rouge\">Mailbox.receiveRemoteProcedureResult()<\/code>, a remote procedure call functionality;<\/li>\n  <li><code class=\"language-plaintext highlighter-rouge\">Mailbox.exit()<\/code> without arguments, for normal mailbox exiting;<\/li>\n  <li>Benchmark\u2019s <code class=\"language-plaintext highlighter-rouge\">README.md<\/code> section about how to run single\/group of becnhmark(s).<\/li>\n<\/ul>\n\n<h3 id=\"changed\">Changed<\/h3>\n\n<ul>\n  <li>Tuned server and client <code class=\"language-plaintext highlighter-rouge\">Netty<\/code>\u2019s settings, especially its <code class=\"language-plaintext highlighter-rouge\">WRITE_BUFFER_WATER_MARK<\/code> option;<\/li>\n  <li>Now, use <code class=\"language-plaintext highlighter-rouge\">channel.eventLoop().execute(Runnable)<\/code> for server\u2019s responses, instead of creating composite buffer and single <code class=\"language-plaintext highlighter-rouge\">writeAndFlush<\/code> call;<\/li>\n  <li>Fix samples <code class=\"language-plaintext highlighter-rouge\">pom.xml<\/code> files.<\/li>\n<\/ul>","author":{"name":{}},"summary":"Encon 1.6.4 has been released and is is now available from Maven Central."},{"title":"Encon vs Jinterface benchmarks","link":{"@attributes":{"href":"https:\/\/appulse.io\/2018\/09\/13\/encon-vs-jinterface-benchmarks.html","rel":"alternate","type":"text\/html","title":"Encon vs Jinterface benchmarks"}},"published":"2018-09-13T00:00:00+00:00","updated":"2018-09-13T00:00:00+00:00","id":"https:\/\/appulse.io\/2018\/09\/13\/encon-vs-jinterface-benchmarks","content":"<p>The main purpose of the <a href=\"http:\/\/openjdk.java.net\/projects\/code-tools\/jmh\/\">JMH<\/a> tests below is to compare the <code class=\"language-plaintext highlighter-rouge\">Ericsson<\/code>\u2019s <a href=\"http:\/\/erlang.org\/doc\/apps\/jinterface\/jinterface_users_guide.html\">jinterface<\/a> package and <code class=\"language-plaintext highlighter-rouge\">Appulse<\/code> <a href=\"https:\/\/github.com\/appulse-projects\/encon-java\">encon<\/a> library.<\/p>\n\n<ul>\n  <li><a href=\"#benchmark-host-machine\">Benchmark host machine<\/a><\/li>\n  <li><a href=\"#the-results\">The results<\/a>\n    <ul>\n      <li><a href=\"#multi-client-tests\">Multi client tests<\/a><\/li>\n      <li><a href=\"#mailbox-to-mailbox\">Mailbox to mailbox<\/a><\/li>\n    <\/ul>\n  <\/li>\n<\/ul>\n\n<h2 id=\"benchmark-host-machine\">Benchmark host machine<\/h2>\n\n<p>For benchmarking we are using <code class=\"language-plaintext highlighter-rouge\">DigitalOcean<\/code>\u2019s CPU Optimized Droplets:<\/p>\n\n<div class=\"language-bash highlighter-rouge\"><div class=\"highlight\"><pre class=\"highlight\"><code><span class=\"nv\">$&gt;<\/span> <span class=\"nb\">sudo <\/span>lshw <span class=\"nt\">-short<\/span>\nH\/W path      Device      Class      Description\n<span class=\"o\">================================================<\/span>\n                          system     Droplet\n\/0                        bus        Motherboard\n\/0\/0                      memory     96KiB BIOS\n\/0\/401                    processor  Intel<span class=\"o\">(<\/span>R<span class=\"o\">)<\/span> Xeon<span class=\"o\">(<\/span>R<span class=\"o\">)<\/span> CPU E5-2697A v4 @ 2.60GHz\n\/0\/402                    processor  Intel<span class=\"o\">(<\/span>R<span class=\"o\">)<\/span> Xeon<span class=\"o\">(<\/span>R<span class=\"o\">)<\/span> CPU E5-2697A v4 @ 2.60GHz\n\/0\/1000                   memory     4GiB System Memory\n\/0\/1000\/0                 memory     4GiB DIMM RAM\n\/0\/100                    bridge     440FX - 82441FX PMC <span class=\"o\">[<\/span>Natoma]\n\/0\/100\/1                  bridge     82371SB PIIX3 ISA <span class=\"o\">[<\/span>Natoma\/Triton II]\n\/0\/100\/1.1                storage    82371SB PIIX3 IDE <span class=\"o\">[<\/span>Natoma\/Triton II]\n\/0\/100\/1.2                bus        82371SB PIIX3 USB <span class=\"o\">[<\/span>Natoma\/Triton II]\n\/0\/100\/1.2\/1  usb1        bus        UHCI Host Controller\n\/0\/100\/1.3                bridge     82371AB\/EB\/MB PIIX4 ACPI\n\/0\/100\/2                  display    QXL paravirtual graphic card\n\/0\/100\/3                  network    Virtio network device\n\/0\/100\/3\/0    eth0        network    Ethernet interface\n\/0\/100\/4                  storage    Virtio SCSI\n\/0\/100\/4\/0                generic    Virtual I\/O device\n\/0\/100\/5                  storage    Virtio block device\n\/0\/100\/5\/0    \/dev\/vda    disk       26GB Virtual I\/O device\n\/0\/100\/5\/0\/1  \/dev\/vda1   volume     24GiB EXT4 volume\n\/0\/100\/5\/0\/e  \/dev\/vda14  volume     4095KiB BIOS Boot partition\n\/0\/100\/5\/0\/f  \/dev\/vda15  volume     105MiB Windows FAT volume\n\/0\/100\/6                  generic    Virtio memory balloon\n\/0\/100\/6\/0                generic    Virtual I\/O device\n<\/code><\/pre><\/div><\/div>\n\n<ul>\n  <li>\n    <p><strong>JMH version:<\/strong> 1.21<\/p>\n  <\/li>\n  <li>\n    <p><strong>VM version:<\/strong> JDK 1.8.0_181, Java HotSpot(TM) 64-Bit Server VM, 25.181-b13<\/p>\n  <\/li>\n  <li>\n    <p><strong>VM options:<\/strong> -Xms1G -Xmx2G<\/p>\n  <\/li>\n  <li>\n    <p><strong>Warmup:<\/strong> 10 iterations, 10 s each<\/p>\n  <\/li>\n  <li>\n    <p><strong>Measurement:<\/strong> 20 iterations, 10 s each<\/p>\n  <\/li>\n  <li>\n    <p><strong>Timeout:<\/strong> 10 min per iteration<\/p>\n  <\/li>\n  <li>\n    <p><strong>Threads:<\/strong> 1 thread, will synchronize iterations<\/p>\n  <\/li>\n  <li>\n    <p><strong>Benchmark mode:<\/strong> Throughput, ops\/time<\/p>\n  <\/li>\n<\/ul>\n\n<h2 id=\"the-results\">The results<\/h2>\n\n<h3 id=\"multi-client-tests\">Multi client tests<\/h3>\n\n<p>The installation consist of a server node at separate thread, which echoes the messages and <strong>N<\/strong>-threads-clients, which pitch the messages and receive it back.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th style=\"text-align: left\">implementation<\/th>\n      <th style=\"text-align: center\">clients<\/th>\n      <th style=\"text-align: right\">score<\/th>\n      <th style=\"text-align: right\">error<\/th>\n      <th style=\"text-align: left\">units<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/Encon_Node2NodeBenchmarks.java#L130\">encon<\/a><\/td>\n      <td style=\"text-align: center\">1<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">11679.266<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">414.090<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/JInterface_Node2NodeBenchmarks.java#L109\">jinterface<\/a><\/td>\n      <td style=\"text-align: center\">1<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">11862.914<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">385.573<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/Encon_Node2NodeBenchmarks.java#L138\">encon<\/a><\/td>\n      <td style=\"text-align: center\">2<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">22337.500<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">918.292<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/JInterface_Node2NodeBenchmarks.java#L117\">jinterface<\/a><\/td>\n      <td style=\"text-align: center\">2<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">18217.878<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">861.270<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/Encon_Node2NodeBenchmarks.java#L146\">encon<\/a><\/td>\n      <td style=\"text-align: center\">4<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">36001.870<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">2033.472<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/JInterface_Node2NodeBenchmarks.java#L125\">jinterface<\/a><\/td>\n      <td style=\"text-align: center\">4<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">23202.485<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">1295.186<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/Encon_Node2NodeBenchmarks.java#L154\">encon<\/a><\/td>\n      <td style=\"text-align: center\">8<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">44742.858<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">1865.853<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/JInterface_Node2NodeBenchmarks.java#L133\">jinterface<\/a><\/td>\n      <td style=\"text-align: center\">8<\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">23495.184<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">671.766<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<h3 id=\"mailbox-to-mailbox\">Mailbox to mailbox<\/h3>\n\n<p>In this test we have only one node and two mailboxes which send the message to each other.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th style=\"text-align: left\">implementation<\/th>\n      <th style=\"text-align: right\">score<\/th>\n      <th style=\"text-align: right\">error<\/th>\n      <th style=\"text-align: left\">units<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/Encon_SimpleBenchmarks.java#L57\">encon<\/a><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">4080746.356<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">79809.419<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n    <tr>\n      <td style=\"text-align: left\"><a href=\"https:\/\/github.com\/appulse-projects\/encon-java\/blob\/master\/benchmark\/src\/main\/java\/io\/appulse\/encon\/benchmark\/JInterface_SimpleBenchmarks.java#L51\">jinterface<\/a><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">4885380.490<\/code><\/td>\n      <td style=\"text-align: right\"><code class=\"language-plaintext highlighter-rouge\">61920.971<\/code><\/td>\n      <td style=\"text-align: left\">ops\/s<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>","author":{"name":{}},"summary":"The main purpose of the JMH tests below is to compare the Ericsson\u2019s jinterface package and Appulse encon library."}]}