/**
* Creates a new client end of a NetBarrier connected to the barrier with the given index on the given Node
*
* @param addr
* NodeAddres of the Node that the barrier is located
* @param vbn
* Index of the barrier to connect to
* @param enrolled
* The number of locally enrolled processes
* @return A new client end of a NetBarrier
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @//throws ArgumentException
* Thrown if the number of enrolled processes is outside the defined range.
*/
public static NetBarrier netBarrier(NodeAddress addr, int vbn, int enrolled)
{
// Get the Link with the given address
Link link = LinkFactory.getLink(addr);
NetBarrier barrierToReturn = null;
try
{
barrierToReturn = NetBarrier.create(new NetBarrierLocation(link.remoteID, vbn), enrolled);
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
catch (JCSPNetworkException e)
{
Console.WriteLine(e);
}
return(barrierToReturn);
// Create a new NetBarrier
//return NetBarrier.create(new NetBarrierLocation(link.remoteID, vbn), enrolled);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which uses the
* given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter)
//throws JCSPNetworkException
{
NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID;
NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn);
return(Any2NetChannel.create(loc, Int32.MaxValue, filter));
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetChannelOutput
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn)
//throws JCSPNetworkException
{
NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID;
NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn);
return(One2NetChannel.create(loc, Int32.MaxValue, new ObjectNetworkMessageFilter.FilterTX()));
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which has the
* given poison immunity
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel)
//throws JCSPNetworkException
{
NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID;
NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn);
return(Any2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()));
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which has the given
* poison immunity and uses the given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
//throws JCSPNetworkException
{
NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID;
NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn);
return(One2NetChannel.create(loc, immunityLevel, filter));
}
/**
* Creates a new One2NetChannel by connecting to an already created NetChannelInput
*
* @param loc
* The location of the NetChannelInput
* @param immunity
* The immunity level of the channel
* @param filter
* The filter used to encode outgoing messages
* @return A new One2NetChannel
* @//throws JCSPNetworkException
* Thrown if the connection to the remote Node fails
*/
internal static One2NetChannel create(NetChannelLocation loc, int immunity,
NetworkMessageFilter.FilterTx filter)
////throws JCSPNetworkException
{
// Create the channel data structure
ChannelData data = new ChannelData();
// Create the channel linking this to the Link level. This channel is the one used to receive acknowledgement
// messages
One2OneChannel chan = Channel.one2one(new InfiniteBuffer());
data.toChannel = chan.Out();
// Set state of channel
data.state = ChannelDataState.OK_OUTPUT;
// Register channel
ChannelManager.getInstance().create(data);
// We now need to create the connection to the input end of the channel
ChannelOutput toLink;
// Check if this is a local link, and if so connect directly to the input channel
if (loc.getNodeID().equals(Node.getInstance().getNodeID()))
{
toLink = ChannelManager.getInstance().getChannel(loc.getVCN()).toChannel;
return(new One2NetChannel(chan.In(), toLink, null, data, loc, immunity, filter));
}
// Connect to remote node if necessary
Link link = LinkManager.getInstance().requestLink(loc.getNodeID());
// Check if an existing connection exists
if (link == null)
{
// We are not connected. Connect to remote Node.
link = LinkFactory.getLink(loc.getNodeID());
}
// Get the connection to the Link.
toLink = link.getTxChannel();
// Return new channel
return(new One2NetChannel(chan.In(), toLink, link, data, loc, immunity, filter));
}
/**
* @param factory
* @return NodeKey for this Node
* @//throws JCSPNetworkException
*/
public NodeKey init(NodeFactory factory)
////throws JCSPNetworkException
{
Node.log.log(this.GetType(), "Node initialisation begun");
if (this.initialized)
{
throw new JCSPNetworkException("Node already initialised");
}
NodeAddress localAddr = factory.initNode(this);
this.nodeID = new NodeID("", localAddr);
this.initialized = true;
this.nk = new NodeKey();
Link toServer = LinkFactory.getLink(factory.cnsAddress);
CNS.CNS.initialise(toServer.remoteID);
BNS.BNS.initialise(toServer.remoteID);
return(this.nk);
}
/**
* Initialises the connection to the BNS
*
* @param bnsNode
* The NodeAddress of the BNS Node
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static void initialise(NodeAddress bnsNode)
////throws JCSPNetworkException
{
// First check that we are not already initialised
if (BNS.initialised)
{
throw new JCSPNetworkException("The BNS is already initialised");
}
// We are initialised. Attempt to do so.
// First, we need to connect to the BNS Node
Link link = LinkFactory.getLink(bnsNode);
// Now create the BNSService
BNS.service = new BNSService(link.getRemoteNodeID());
// Now set initialised to true
BNS.initialised = true;
// We are now connected
}
static NetAltingConnectionClient create(NetConnectionLocation loc, NetworkMessageFilter.FilterTx filterTX, NetworkMessageFilter.FilterRx filterRX)
////throws JCSPNetworkException
{
// Create the connection data structure
ConnectionData data = new ConnectionData();
// Create channel linking this to the Link level. This channel is used to receive response and
// acknowledgement messages
Any2OneChannel chan = Channel.any2one(new InfiniteBuffer());
data.toConnection = chan.Out();
// Set state of connection
data.state = ConnectionDataState.CLIENT_STATE_CLOSED;
ConnectionManager.getInstance().create(data);
ChannelOutput toLink;
if (loc.getNodeID().equals(Node.getInstance().getNodeID()))
{
toLink = ConnectionManager.getInstance().getConnection(loc.getVConnN()).toConnection;
return(new NetAltingConnectionClient(chan.In(), toLink, null, data, loc, filterTX, filterRX));
}
Link link = LinkManager.getInstance().requestLink(loc.getNodeID());
if (link == null)
{
link = LinkFactory.getLink(loc.getNodeID());
}
toLink = link.getTxChannel();
return(new NetAltingConnectionClient(chan.In(), toLink, link, data, loc, filterTX, filterRX));
}
/**
* Static factory method for creating a client end of a NetBarrier
*
* @param loc
* The location of the server end of the connection
* @param localEnroll
* The number of locally enrolled processes
* @return A new NetBarrier client end
* @//throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @//throws ArgumentException
* Thrown if local enrolled is less than 1
*/
internal static NetBarrier create(NetBarrierLocation loc, int localEnroll)
////throws JCSPNetworkException, ArgumentException
{
// First, the sanity check.
if (localEnroll < 1)
{
throw new ArgumentException(
"Tried to create a NetBarrier with fewer than one locally enrolled process");
}
// Next, create the BarrierData structure
BarrierData data = new BarrierData();
// Set the state to OK_CLIENT
data.state = BarrierDataState.OK_CLIENT;
// Create the connecting channel between this object and the Links
Any2OneChannel chan = Channel.any2one(new InfiniteBuffer());
// Attach the output end to the structure
data.toBarrier = chan.Out();
// Initialise the barrier with the BarrierManager
BarrierManager.getInstance().create(data);
// Now check if this is a locally connected barrier
if (loc.getNodeID().equals(Node.getInstance().getNodeID()))
{
// We are locally connected, so create a new NetBarrier. The constructor will connect to the Barrier server
// end for us.
return(new NetBarrier(data, localEnroll, 0, loc, chan.In(), null));
}
// We are not locally connected. Continue.
// This is the channel we will pass to the NetBarrier
ChannelOutput toLink;
// First, check if the LinkManager has a connection for us.
Link link = LinkManager.getInstance().requestLink(loc.getNodeID());
// The previous operation returns null if no connection exists.
if (link == null)
{
// No connection to the Link exists. Use the factory to get one.
link = LinkFactory.getLink(loc.getNodeID());
// The LinkFactory will have created and started the Link for us, if it could connect. We can continue
}
// Retrieve the channel connecting to the TX process
toLink = link.getTxChannel();
// We now need to enroll with the server end. Send the enroll message
NetworkMessage msg = new NetworkMessage();
msg.type = NetworkProtocol.ENROLL;
// Destination is the VBN of the location
msg.attr1 = loc.getVBN();
// Attribute 2 is not used
msg.attr2 = -1;
// Write the message to the Link
toLink.write(msg);
// Register with the Link
link.registerBarrier(data);
// Return a new NetBarrier
return(new NetBarrier(data, localEnroll, 0, loc, chan.In(), toLink));
}
