/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 2000-2009. All Rights Reserved.
*
* The contents of this file are subject to the Erlang Public License,
* Version 1.1, (the "License"); you may not use this file except in
* compliance with the License. You should have received a copy of the
* Erlang Public License along with this software. If not, it can be
* retrieved online at http://www.erlang.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* %CopyrightEnd%
*/
package com.ericsson.otp.erlang;
import java.io.IOException;
import java.net.Socket;
/**
* <p>
* Maintains a connection between a Java process and a remote Erlang, Java or C
* node. The object maintains connection state and allows data to be sent to and
* received from the peer.
* </p>
*
* <p>
* Once a connection is established between the local node and a remote node,
* the connection object can be used to send and receive messages between the
* nodes.
* </p>
*
* <p>
* The various receive methods are all blocking and will return only when a
* valid message has been received or an exception is raised.
* </p>
*
* <p>
* If an exception occurs in any of the methods in this class, the connection
* will be closed and must be reopened in order to resume communication with the
* peer.
* </p>
*
* <p>
* The message delivery methods in this class deliver directly to
* {@link OtpMbox mailboxes} in the {@link OtpNode OtpNode} class.
* </p>
*
* <p>
* It is not possible to create an instance of this class directly.
* OtpCookedConnection objects are created as needed by the underlying mailbox
* mechanism.
* </p>
*/
public class OtpCookedConnection extends AbstractConnection {
protected OtpNode self;
/*
* The connection needs to know which local pids have links that pass
* through here, so that they can be notified in case of connection failure
*/
protected Links links = null;
/*
* Accept an incoming connection from a remote node. Used by {@link
* OtpSelf#accept() OtpSelf.accept()} to create a connection based on data
* received when handshaking with the peer node, when the remote node is the
* connection intitiator.
*
* @exception java.io.IOException if it was not possible to connect to the
* peer.
*
* @exception OtpAuthException if handshake resulted in an authentication
* error
*/
// package scope
OtpCookedConnection(final OtpNode self, final Socket s) throws IOException,
OtpAuthException {
super(self, s);
this.self = self;
links = new Links(25);
start();
}
/*
* Intiate and open a connection to a remote node.
*
* @exception java.io.IOException if it was not possible to connect to the
* peer.
*
* @exception OtpAuthException if handshake resulted in an authentication
* error.
*/
// package scope
OtpCookedConnection(final OtpNode self, final OtpPeer other)
throws IOException, OtpAuthException {
super(self, other);
this.self = self;
links = new Links(25);
start();
}
// pass the error to the node
@Override
public void deliver(final Exception e) {
self.deliverError(this, e);
return;
}
/*
* pass the message to the node for final delivery. Note that the connection
* itself needs to know about links (in case of connection failure), so we
* snoop for link/unlink too here.
*/
@Override
public void deliver(final OtpMsg msg) {
final boolean delivered = self.deliver(msg);
switch (msg.type()) {
case OtpMsg.linkTag:
if (delivered) {
links.addLink(msg.getRecipientPid(), msg.getSenderPid());
} else {
try {
// no such pid - send exit to sender
super.sendExit(msg.getRecipientPid(), msg.getSenderPid(),
new OtpErlangAtom("noproc"));
} catch (final IOException e) {
}
}
break;
case OtpMsg.unlinkTag:
case OtpMsg.exitTag:
links.removeLink(msg.getRecipientPid(), msg.getSenderPid());
break;
case OtpMsg.exit2Tag:
break;
}
return;
}
/*
* send to pid
*/
void send(final OtpErlangPid from, final OtpErlangPid dest,
final OtpErlangObject msg) throws IOException {
// encode and send the message
sendBuf(from, dest, new OtpOutputStream(msg));
}
/*
* send to remote name dest is recipient's registered name, the nodename is
* implied by the choice of connection.
*/
void send(final OtpErlangPid from, final String dest,
final OtpErlangObject msg) throws IOException {
// encode and send the message
sendBuf(from, dest, new OtpOutputStream(msg));
}
@Override
public void close() {
super.close();
breakLinks();
}
@Override
protected void finalize() {
close();
}
/*
* this one called by dying/killed process
*/
void exit(final OtpErlangPid from, final OtpErlangPid to,
final OtpErlangObject reason) {
try {
super.sendExit(from, to, reason);
} catch (final Exception e) {
}
}
/*
* this one called explicitely by user code => use exit2
*/
void exit2(final OtpErlangPid from, final OtpErlangPid to,
final OtpErlangObject reason) {
try {
super.sendExit2(from, to, reason);
} catch (final Exception e) {
}
}
/*
* snoop for outgoing links and update own table
*/
synchronized void link(final OtpErlangPid from, final OtpErlangPid to)
throws OtpErlangExit {
try {
super.sendLink(from, to);
links.addLink(from, to);
} catch (final IOException e) {
throw new OtpErlangExit("noproc", to);
}
}
/*
* snoop for outgoing unlinks and update own table
*/
synchronized void unlink(final OtpErlangPid from, final OtpErlangPid to) {
links.removeLink(from, to);
try {
super.sendUnlink(from, to);
} catch (final IOException e) {
}
}
/*
* When the connection fails - send exit to all local pids with links
* through this connection
*/
synchronized void breakLinks() {
if (links != null) {
final Link[] l = links.clearLinks();
if (l != null) {
final int len = l.length;
for (int i = 0; i < len; i++) {
// send exit "from" remote pids to local ones
self.deliver(new OtpMsg(OtpMsg.exitTag, l[i].remote(), l[i]
.local(), new OtpErlangAtom("noconnection")));
}
}
}
}
}