public void Init()
{
_tupleSpace = new TupleSpace();
_tuple1Schema = new TupleSchema(Tuple1);
_tuple2Schema = new TupleSchema(Tuple2);
_tuple3Schema = new TupleSchema(Tuple3);
}
private List <Tuple> Read(TupleSchema tupleSchema)
{
var listTuple = TupleSpace.Read(tupleSchema);
if (listTuple.Count > 0)
{
Log("Read (first tuple): " + listTuple.First());
}
return(listTuple);
}
private List <Tuple> Take(TupleSchema tupleSchema)
{
List <Tuple> tuples = TupleSpace.Take(tupleSchema);
if (tuples.Count > 0)
{
List <Tuple> tuplesWriteBack = new List <Tuple>(tuples);
tuplesWriteBack.Remove(tuplesWriteBack.First());
Write(tuplesWriteBack);
Log("Took (first tuple): " + tuples.First());
}
return(tuples);
}
/**
* Remove locked tuples from LockedTuples List, and add them back to the tuple space
* acts as a release for the "lock" of a take request
*/
private void ReleaseLockedTuples(int takeRequestSeqNum)
{
// remove from LockedTuples
bool isRemoved = LockedTuples.TryRemove(takeRequestSeqNum, out List <Tuple> tuples);
// add back to TupleSpace
if (isRemoved)
{
foreach (Tuple tuple in tuples)
{
TupleSpace.Write(tuple);
}
}
}
/**
* Remove the selected tuple and add the remaining locked tuples back to the tuplespace
*/
private Message ProcessTakeRemove(Message message)
{
TakeRemove takeRemove = (TakeRemove)message;
LockedTuples.TryRemove(takeRemove.TakeRequestSeqNumber, out List <Tuple> lockedTuples);
// remove the selected tuple specified in the request
if (lockedTuples != null && takeRemove.SelectedTuple != null)
{
lockedTuples.Remove(takeRemove.SelectedTuple);
// add back the remaining tuples to the tuple space
foreach (Tuple tuple in lockedTuples)
{
TupleSpace.Write(tuple);
}
}
// Send back an Ack of the remove
Ack ack = new Ack(EndpointURL, takeRemove);
SendMessageToRemoteURL(takeRemove.SrcRemoteURL, ack);
return(ack);
}
private void Write(Tuple tuple)
{
TupleSpace.Write(tuple);
Log("Wrote : " + tuple);
}
private void Receiver(object state)
{
var pipeline = new Pipeline();
pipeline.Push(new NboFrameLengthSink(2)
{
IncludeHeaderLength = false, MaxFrameLength = 1024
});
pipeline.Push(
new MessageFormatterSink(new Iso8583MessageFormatter((@"..\Formatters\Iso8583Bin1987.xml"))));
var ts = new TupleSpace <ReceiveDescriptor>();
var server = new TcpServerChannel(new Pipeline(), new ClonePipelineFactory(pipeline), ts,
new FieldsMessagesIdentifier(new[] { 11, 41 }))
{
Port = 8583,
LocalInterface = (string)state,
Name = "ISO8583Server"
};
server.StartListening();
while (!_stop)
{
ReceiveDescriptor rcvDesc = ts.Take(null, 100);
if (rcvDesc == null)
{
continue;
}
_requestsCnt++;
var message = rcvDesc.ReceivedMessage as Iso8583Message;
if (message == null)
{
continue;
}
Iso8583Message response;
if (message.IsAuthorization())
{
Console.WriteLine("go to handle sale msg");
Sale auth = new Sale(message);
response = auth.GetMessage();
}
else if (message.IsNetworkManagement())
{
Console.WriteLine("go to handle logon msg");
Logon logon = new Logon(message);
logon.BuildResponse();
response = logon.GetMessage();
Console.WriteLine(response.ToString());
}
else
{
response = null;
}
//message.SetResponseMessageTypeIdentifier();
//message.Fields.Add(Field39ResponseCode, "00");
var addr = rcvDesc.ChannelAddress as ReferenceChannelAddress;
if (addr == null)
{
continue;
}
var child = addr.Channel as ISenderChannel;
if (child != null)
{
child.Send(response);
}
}
// Stop listening and shutdown the connection with the sender.
server.StopListening();
}
public Message ProcessRequest(Request request)
{
var tupleSchema = new TupleSchema(request.Tuple);
if (request.GetType() == typeof(WriteRequest))
{
TupleSpace.Write(request.Tuple);
// notify a blocked thread that tried to read/take this tuple before
Request readOrTakeRequest = GetAndRemoveSinglePendingRequest(request.Tuple);
if (readOrTakeRequest != null)
{
PulseMessage(readOrTakeRequest);
}
// Send back an Ack of the write
return(new Ack(EndpointURL, request));
}
if (request.GetType() == typeof(ReadRequest))
{
List <Tuple> tuples = TupleSpace.Read(tupleSchema);
while (!tuples.Any())
{
lock (PendingRequestList){
PendingRequestList.Add(request);
}
WaitMessage(request, View.Nodes);
tuples = TupleSpace.Read(tupleSchema);
}
Response response = new Response(request, tuples, EndpointURL);
return(response);
}
if (request.GetType() == typeof(TakeRequest))
{
tupleSchema = new TupleSchema(request.Tuple);
List <Tuple> resultTuples = TupleSpace.Take(tupleSchema);
Response response = null;
while (!resultTuples.Any())
{
lock (PendingRequestList){
PendingRequestList.Add(request);
}
WaitMessage(request, View.Nodes);
resultTuples = TupleSpace.Take(tupleSchema);
}
// "lock" the tuples taken from the tuple space
LockedTuples.TryAdd(request.SeqNum, resultTuples);
response = new Response(request, resultTuples, EndpointURL);
SendMessageToRemoteURL(request.SrcRemoteURL, response);
return(response);
}
throw new NotImplementedException();
}
