Exemplo n.º 1
0
        public void ExecuteFromUntil(int begin, int end)
        {
            Task.Factory.StartNew(() => {
                for (int i = begin; i < end; i++)
                {
                    Executor clientExecutor = ExecutorFactory.Factory(this.Logger[i], i + 1);

                    // Add request to queue
                    Log.Debug($"Trying to add request #{opNumber} in the Execution Queue");
                    OrderedQueue.AddRequestToQueue(this, this.Logger[i], clientExecutor);
                }
            });
        }
        private ProcessRequest RunProcessRequestProtocol(ClientRequest clientRequest)
        {
            if (this.replicaState.ClientTable.TryGetValue(clientRequest.ClientId, out Tuple <int, ClientResponse> clientResponse))
            {
                // Key is in the dictionary
                if (clientResponse == null || clientResponse.Item1 < 0 ||
                    clientRequest.RequestNumber < clientResponse.Item1)
                {
                    // Duplicate Request: Long forgotten => drop
                    return(ProcessRequest.DROP);
                }

                if (clientRequest.RequestNumber == clientResponse.Item1)
                {
                    // Duplicate Request
                    // If it is in execution.. wait.
                    if (clientResponse.Item2.GetType() == typeof(Executor))
                    {
                        Executor executor = (Executor)clientResponse.Item2;
                        executor.Executed.WaitOne();
                    }
                    return(ProcessRequest.LAST_EXECUTION);
                }

                // Execute the requests in client's casual order
                if (clientRequest.RequestNumber != clientResponse.Item1 + 1)
                {
                    if (!this.replicaState.HandlersClient.ContainsKey(clientRequest.ClientId))
                    {
                        this.replicaState.HandlersClient.TryAdd(
                            clientRequest.ClientId,
                            new EventWaitHandle(false, EventResetMode.ManualReset));
                    }

                    this.replicaState.HandlersClient.TryGetValue(
                        clientRequest.ClientId,
                        out EventWaitHandle myHandler);
                    while (clientRequest.RequestNumber != clientResponse.Item1 + 1)
                    {
                        if (clientRequest.RequestNumber > clientResponse.Item1 + 1)
                        {
                            return(ProcessRequest.DROP);
                        }
                        myHandler.WaitOne();
                    }
                }
            }
            else
            {
                // Not in dictionary... Add with value as null
                this.replicaState.ClientTable.Add(clientRequest.ClientId, new Tuple <int, ClientResponse>(-1, null));
            }

            // Send Prepare Message and waits for f replies. opNumber is the order we agreed upon.
            int      opNumber       = this.SendPrepareMessage(clientRequest);
            Executor clientExecutor = ExecutorFactory.Factory(clientRequest, opNumber);

            // Add request to queue
            OrderedQueue.AddRequestToQueue(this.replicaState, clientRequest, clientExecutor);

            // Wait execution
            clientExecutor.Executed.WaitOne();

            return(ProcessRequest.LAST_EXECUTION);
        }