Esempio n. 1
0
        /// <summary>
        /// Callback function to process read's server' replies
        /// <param name="IAsyncResult"A AsyncResult Delgate Object.</param>
        /// </summary>
        public static void CallbackRead(IAsyncResult ar)
        {
            RemoteAsyncReadDelegate del = (RemoteAsyncReadDelegate)((AsyncResult)ar).AsyncDelegate;

            lock (ReadLock)
            {
                //Only care about one reply, ignore others
                if (_responseRead == null)
                {
                    _responseRead = del.EndInvoke(ar);
                    readHandles[0].Set();
                }
            }
        }
Esempio n. 2
0
        public Tuple Read(Tuple tuple)
        {
            readHandles    = new AutoResetEvent[1];
            readHandles[0] = new AutoResetEvent(false);

            View actualView = this.GetView();
            List <ITupleSpaceXL> serversObj = new List <ITupleSpaceXL>();
            List <string>        toRemove   = new List <string>();

            ITupleSpaceXL tupleSpace = null;

            _responseRead = null;

            //save remoting objects of all members of the view
            foreach (string serverPath in actualView.Servers)
            {
                try
                {
                    tupleSpace = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), serverPath);
                    tupleSpace.ItemCount(); //just to check availability of the server
                }
                catch (System.Net.Sockets.SocketException) {
                    tupleSpace = null;
                    toRemove.Add(serverPath);
                }
                if (tupleSpace != null)
                {
                    serversObj.Add(tupleSpace);
                }
            }

            if (serversObj.Count > 0)
            {
                foreach (string crashed in toRemove)
                {
                    //only one can crash so serverObj is obviously online
                    _view = serversObj[0].Remove(crashed);
                }
            }
            else
            {
                Console.WriteLine("All servers are dead! Exiting...");
                Environment.Exit(1);
            }


            foreach (ITupleSpaceXL server in serversObj)
            {
                try
                {
                    RemoteAsyncReadDelegate RemoteDel      = new RemoteAsyncReadDelegate(server.read);
                    AsyncCallback           RemoteCallback = new AsyncCallback(CallbackRead);
                    IAsyncResult            RemAr          = RemoteDel.BeginInvoke(tuple, CallbackRead, null);
                }
                catch (System.Net.Sockets.SocketException) { Console.WriteLine("** FRONTEND READ: Cannot invoke read on server!"); }
            }

            while (_responseRead == null)
            {
                Console.WriteLine("** FRONTEND READ: Not yet receive any reply let me wait...");

                WaitHandle.WaitAny(readHandles);
            }

            _requestId++;
            Console.WriteLine("** FRONTEND READ: Here is a response: " + _responseRead);
            return(_responseRead);
        }