Beispiel #1
0
        public TSpaceMsg XLProcessRequest(TSpaceMsg msg)
        {

            TSMan.CheckFreeze();
            TSMan.CheckDelay();

            TSpaceMsg response = new TSpaceMsg
            {
                ProcessID = TSMan.URL,
                RequestID = msg.RequestID,
                MsgView = TSMan.GetTotalView()
            };

            // Verifying View! Wrong view sends updated view
            if (!TSMan.ValidView(msg))
            {
                //Console.WriteLine("client:" +  msg.MsgView.ToString() + "server:" +TSMan.GetTotalView().ToString());
                Console.WriteLine("Wrong View ( s = " + TSMan.ServerView + "; c = " + msg.MsgView + " )");
                return TSMan.CreateBadViewReply(msg);
            }

            if (TSMan.Verbose)
                Console.WriteLine(msg);


            lock (TSpaceManager.ProcessedRequests)
            {
                // Check if request as already been processed
                if (TSpaceManager.ProcessedRequests.Contains(msg.RequestID))
                {
                    LogEntry Temp = TSpaceManager.ProcessedRequests.GetByKey(msg.RequestID);
                    // Check if it was processed in a previous viwew
                    if (Temp.Request.MsgView.ID < TSMan.ServerView.ID ||
                        (Temp.Response != null && Temp.Response.ProcessID != TSMan.URL))
                    {
                        //Console.WriteLine("Processed in previous view");
                        
                        TSpaceMsg resp = TSpaceManager.ProcessedRequests.GetByKey(msg.RequestID).Response;
                        
                        if (resp == null)
                        {
                            Console.WriteLine("NULL RESPONSE SAVED");
                            return null;
                        }

                        resp.MsgView = TSMan.ServerView;

                        TSpaceManager.ProcessedRequests.UpdateView(msg.RequestID, TSMan.ServerView);
                        TSpaceManager.ProcessedRequests.UpdateResponse(msg.RequestID, resp);


                        //Console.WriteLine(resp);
                        return resp;
                    }
                    else
                    {
                        
                        //Console.WriteLine("repeated");
                        response.Code = "Repeated";
                        
                        return response;
                    }

                }
                //Console.WriteLine("Starting processing of request " + msg.RequestID);

                // Add sequence number of request to processed requests

                TSpaceManager.ProcessedRequests.Add(msg);

            }

            string command = msg.Code;


            switch (command)
            {
                case "add":
                    TSMan.TSpace.Add(msg.Tuple);
                    response.Code = "ACK";
                    break;

                case "read":
                    response.Tuple = TSMan.TSpace.Read(msg.Tuple);
                    response.Code = "OK";
                    break;

                case "take1":
                    lock (TSLockHandler.Lock)
                    {
                        // find suitable matches for tuple
                        List<ITuple> matches = TSMan.TSpace.Take1(msg.Tuple);
                        // Locks all unlocked and matchable tuples for UserID
                        response.Tuples = TSLockHandler.LockTuples(msg.ProcessID, matches);
                    }
                    
                    response.Code = "OK";
                    break;

                case "take2":
                    lock (TSLockHandler.Lock)
                    {
                        // Deletes tuple
                        TSMan.TSpace.Take2(msg.Tuple);
                        // Unlocks all tuples previously locked under UserID
                        TSLockHandler.UnlockTuples(msg.ProcessID);
                    }
                    response.Code = "ACK";
                    break;

                // Operation exclusive of the XL Tuple Space
                case "releaseLocks":
                    try
                    {
                        TSLockHandler.UnlockTuples(msg.ProcessID);
                        response.Code = "ACK";
                    }
                    catch (InvalidCastException)
                    {
                        Console.WriteLine("Current Tuple Space not in XL mode");
                        response.Code = "ERR";
                    }

                    break;
                default:
                    Console.WriteLine("Invalid command.");
                    break;
            }
            return response;
        }
Beispiel #2
0
        public TSpaceMsg SMRProcessRequest(TSpaceMsg msg)
        {
            TSMan.CheckFreeze();

            TSMan.CheckDelay();

            TSpaceMsg response = new TSpaceMsg
            {
                ProcessID   = TSMan.URL,
                OperationID = msg.OperationID,
                RequestID   = msg.RequestID,
                MsgView     = TSMan.GetTotalView()
            };

            //Console.WriteLine("client:" +  msg.MsgView.ToString() + "server:" +TSMan.GetTotalView().ToString());
            // Verifying View! Wrong view sends updated view
            if (!TSMan.ValidView(msg))
            {
                //Console.WriteLine("client:" +  msg.MsgView.ToString() + "server:" +TSMan.GetTotalView().ToString());
                Console.WriteLine("Wrong View ( s = " + TSMan.ServerView + "; c = " + msg.MsgView + " )");
                return(TSMan.CreateBadViewReply(msg));
            }

            lock (TSpaceManager.ProcessedRequests)
            {
                // Check if request as already been processed
                if (TSpaceManager.ProcessedRequests.Contains(msg.RequestID))
                {
                    // Check if it was processed in a previous viwew
                    if (TSpaceManager.ProcessedRequests.GetByKey(msg.RequestID).Request.MsgView.ID < TSMan.ServerView.ID)
                    {
                        //Console.WriteLine(TSMan.ServerView.ID);
                        TSpaceManager.ProcessedRequests.UpdateView(msg.RequestID, TSMan.ServerView);
                        TSpaceMsg resp = TSpaceManager.ProcessedRequests.GetByKey(msg.RequestID).Response;
                        if (resp == null)
                        {
                            Console.WriteLine("NULL RESPONSE SAVED");
                            return(null);
                        }

                        return(resp);
                    }
                    else
                    {
                        //Console.WriteLine("repeated");
                        response.Code = "Repeated";

                        //Console.WriteLine("Repeated message response was:" + TSpaceManager.ProcessedRequests.GetByKey(msg.RequestID).Response);
                        return(response);
                    }
                }
                Console.WriteLine("Starting processing of request " + msg.RequestID);

                // Add sequence number of request to processed requests

                TSpaceManager.ProcessedRequests.Add(msg);
            }

            string command = msg.Code;
            //Console.WriteLine("Processing Request " + command + " (seq = " + msg.RequestID + ")");

            Message update = null;

            // Sequence number proposal request
            if (command.Equals("proposeSeq"))
            {
                Console.WriteLine("Propose request received " + msg.OperationID);
                // Increment sequence number
                Interlocked.Increment(ref SequenceNumber);
                response.SequenceNumber = SequenceNumber;
                response.Code           = "proposedSeq";

                lock (MessageQueue)
                {
                    Message newMessage = new Message();
                    newMessage.ProcessID      = msg.ProcessID;
                    newMessage.SequenceNumber = SequenceNumber;
                    newMessage.Deliverable    = false;
                    newMessage.MessageID      = msg.OperationID;

                    // Add message to queue
                    MessageQueue.Add(newMessage);
                    MessageQueue.Sort();
                }

                Console.WriteLine("Return propose answer" + msg.OperationID);
                return(response);
            }
            // Message with agreed sequence number
            else
            {
                update = UpdateMessage(msg.OperationID, msg.SequenceNumber);
                if (update == null)
                {
                    Console.WriteLine("Err: operation message not in queue");
                    response.Code = "Err";

                    return(response);
                }
            }
            // Wait for message to be in the head of the queue
            Monitor.Enter(MessageQueue);
            while (MessageQueue.Count == 0 || !MessageQueue[0].MessageID.Equals(msg.OperationID))
            {
                //Console.WriteLine("stuck at while");
                Monitor.Wait(MessageQueue);
            }
            Monitor.Exit(MessageQueue);

            Console.WriteLine("Execute operation " + msg.OperationID + ": code = " + command);

            // Execute the operation

            if (TSMan.Verbose)
            {
                Console.WriteLine(msg);
            }



            switch (command)
            {
            case "add":
                lock (TakeLock)
                {
                    if (msg.Tuple == null)
                    {
                        response.Code = "ERR";
                        break;
                    }

                    TSMan.TSpace.Add(msg.Tuple);
                    response.Code = "ACK";
                    break;
                }

            case "read":
                if (msg.Tuple == null)
                {
                    response.Code = "ERR";
                    break;
                }
                response.Tuple = TSMan.TSpace.Read(msg.Tuple);
                response.Code  = "OK";
                if (response.Tuple == null)
                {
                    Console.WriteLine("Match not Found");
                }
                //else
                //Console.WriteLine("Match found");
                break;

            case "take1":
                lock (TakeLock)
                {
                    if (msg.Tuple == null)
                    {
                        response.Code = "ERR";
                        break;
                    }

                    // Get matching tuple
                    response.Tuple = TSMan.TSpace.Read(msg.Tuple);
                    response.Code  = "OK";
                    if (response.Tuple != null)
                    {
                        // Delete it
                        TSMan.TSpace.Take2(response.Tuple);
                    }
                }

                response.Code = "OK";


                break;

            case "take2":
                Console.WriteLine("Current Tuple Space not in XL mode");
                response.Code = "ERR";

                break;


            // Operation exclusive of the XL Tuple Space
            case "releaseLocks":

                lock (TakeLock)
                    response.Code = "ERR";
                Console.WriteLine("Current Tuple Space not in XL mode");

                break;

            default:
                Console.WriteLine("Invalid command.");
                break;
            }

            // Delete processed message from queue
            if (update != null)
            {
                lock (MessageQueue)
                {
                    MessageQueue.Remove(update);
                    Monitor.PulseAll(MessageQueue);
                }
            }
            Console.WriteLine("Return response " + msg.OperationID);

            return(response);
        }