Example #1
0
        private void HandleRejectRequest(RejectRequest message)
        {
            Console.WriteLine($"Host #{MachineId} request was rejected");
            if (EvacuateMode)
            {
            }
            if (message.Auctiontype == StrategyActionType.PullAction)
            {
                IncreaseBackOffTime();
            }

            if (EvacuateMode && message.Auctiontype == StrategyActionType.PullAction)
            {
                //EvacuateMode = false;
                throw new NotImplementedException();
            }

            if (message.RejectAction == RejectActions.Evacuate)
            {
                EvacuateMode = true;
                //SendPushRequest();
            }
            if (!EvacuateMode && message.RejectAction == RejectActions.CancelEvacuation)
            {
                throw new NotImplementedException();
            }
            if (message.RejectAction == RejectActions.CancelEvacuation)
            {
                EvacuateMode = false;
                Console.WriteLine($"Cancel Evacuation By Rejection for Host# {MachineId}");
            }
            BidLock = -1;
        }
Example #2
0
        /// <summary>
        /// Should Be Optimized for the reasons to add new host or remove one
        /// </summary>
        /// <param name="hostId"></param>
        /// <param name="atype"></param>
        protected void InitiateRejectAction(int hostId, StrategyActionType atype)
        {
            var action = RejectActions.Nothing;

            switch (atype)
            {
            case StrategyActionType.PushAction:
                if (DataHolder.GetUtilization(hostId) == UtilizationStates.UnderUtilization ||
                    DataHolder.GetUtilization(hostId) == UtilizationStates.Normal)
                {
                    //throw new NotImplementedException("How come");
                    action = RejectActions.TestWalid;
                }
                else if (DataHolder.GetUtilization(hostId) == UtilizationStates.Evacuating)
                {
                    action = RejectActions.CancelEvacuation;
                    //UpdateSate(hostId, UtilizationStates.UnderUtilization,"Master");
                    DataHolder.SetUtilization(hostId, UtilizationStates.UnderUtilization);
                }
                else if (DataHolder.GetCandidateHosts(UtilizationStates.UnderUtilization, hostId).Count == 0 &&
                         DataHolder.GetCandidateHosts(UtilizationStates.Evacuating, hostId).Count == 0)
                {
                    PowerController.PowerOnHost();
                }
                else
                {
                    //Should I cancell all evacuations
                }
                break;

            case StrategyActionType.PullAction:
                //Evacuate Host

                if (DataHolder.GetCandidateHosts(UtilizationStates.OverUtilization, hostId).Count == 0)
                {
                    action = RejectActions.Evacuate;
                    //UpdateSate(hostId, UtilizationStates.Evacuating, "Master");
                    DataHolder.SetUtilization(hostId, UtilizationStates.Evacuating);
                    //evacuating.Add(hostId, DateTime.Now);
                }
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            RejectRequest request = new RejectRequest(hostId, this.MachineId, atype, action);

            CommunicationModule.SendMessage(request);
        }
Example #3
0
        public async Task <RedirectResponse> RejectLogin(RejectRequest payload, string challenge)
        {
            var client = GetClient();
            var stringRequestContent = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
            var url             = $"{Constant.GetAuthURL()}/oauth2/auth/requests/login/reject?login_challenge={challenge}";
            var responseMessage = await client.PutAsync(url, stringRequestContent);

            var responseText = await responseMessage.Content.ReadAsStringAsync();

            if (responseMessage.StatusCode == HttpStatusCode.OK)
            {
                return(JsonSerializer.Deserialize <RedirectResponse>(responseText));
            }
            throw new Exception(responseText);
        }
        private void HandleRejectRequest(RejectRequest message)
        {
            switch (message.RejectAction)
            {
            case RejectActions.Nothing:
                if (_hostState.EvacuationMode)
                {
                    throw new NotImplementedException("how come");
                }
                break;

            case RejectActions.Busy:
                break;

            case RejectActions.Evacuate:
                if (_hostState.EvacuationMode)
                {
                    throw new NotImplementedException("how come");
                }
                _hostState.EvacuationMode = true;
                break;

            case RejectActions.CancelEvacuation:
                if (!_hostState.EvacuationMode)
                {
                    throw new NotImplementedException("how come");
                }
                _hostState.EvacuationMode = false;
                break;

            case RejectActions.TestWalid:
                _hostState.EvacuationMode = false;
                break;

            default:
                throw new ArgumentOutOfRangeException("How come");
            }
            IncreaseBackOffTime();
            _hostState.CurrentAction = HostCurrentAction.None;
        }
Example #5
0
 private void HandleRequest(Request message)
 {
     if (_masterState.CurrentHost == 0)
     {
         if (message.MessageType == MessageTypes.PushRequest)
         {
             HandlePushRequest(message as PushRequest);
         }
         else if (message.MessageType == MessageTypes.PullRequest)
         {
             HandlePullRequest(message as PullRequest);
         }
         else
         {
             throw new Exception("Exception");
         }
     }
     else
     {
         StrategyActionType atype;
         if (message.MessageType == MessageTypes.PushRequest)
         {
             atype = StrategyActionType.PushAction;
         }
         else if (message.MessageType == MessageTypes.PullRequest)
         {
             atype = StrategyActionType.PullAction;
         }
         else
         {
             throw new NotImplementedException();
         }
         RejectRequest request = new RejectRequest(message.SenderId, this.MachineId, atype, RejectActions.Busy);
         CommunicationModule.SendMessage(request);
     }
 }
 private void HandleRequest(Request message)
 {
     if (Used == 0)
     {
         //if (EvacuatingHost == 0
         //if (EvacuatingHosts.Count == 0||
         //    DataHolder.GetUtilization(message.SenderId) == UtilizationStates.OverUtilization)
         {
             if (message.MessageType == MessageTypes.PushRequest)
             {
                 HandlePushRequest(message as PushRequest);
             }
             else if (message.MessageType == MessageTypes.PullRequest)
             {
                 HandlePullRequest(message as PullRequest);
             }
             else
             {
                 throw new Exception("Exception");
             }
         }
         //else if (message.SenderId == EvacuatingHost)
         //else if (EvacuatingHosts.Contains(message.SenderId))
         //{
         //    if (message.MessageType == MessageTypes.PushRequest)
         //    {
         //        HandlePushRequest(message as PushRequest);
         //    }
         //    else
         //    {
         //        throw new Exception("Exception");
         //    }
         //}
         //else
         //{
         //    StrategyActionType atype;
         //    if (message.MessageType == MessageTypes.PushRequest)
         //        atype = StrategyActionType.PushAction;
         //    else if (message.MessageType == MessageTypes.PullRequest)
         //        atype = StrategyActionType.PullAction;
         //    else
         //    {
         //        throw new NotImplementedException();
         //    }
         //    RejectRequest request = new RejectRequest(message.SenderId, this.MachineId, atype, RejectActions.Nothing);
         //    CommunicationModule.SendMessage(request);
         //}
     }
     else
     {
         StrategyActionType atype;
         if (message.MessageType == MessageTypes.PushRequest)
         {
             atype = StrategyActionType.PushAction;
         }
         else if (message.MessageType == MessageTypes.PullRequest)
         {
             atype = StrategyActionType.PullAction;
         }
         else
         {
             throw new NotImplementedException();
         }
         RejectRequest request = new RejectRequest(message.SenderId, this.MachineId, atype, RejectActions.Nothing);
         CommunicationModule.SendMessage(request);
     }
 }
        /// <summary>
        /// Should Be Optimized for the reasons to add new host or remove one
        /// </summary>
        /// <param name="hostId"></param>
        /// <param name="atype"></param>
        protected void InitiateRejectAction(int hostId, StrategyActionType atype)
        {
            //Implement Conditions for How to Add New Nodes or Remove
            //Implement Add Host and Evacuation System Locks
            var action = RejectActions.Nothing;

            switch (atype)
            {
            case StrategyActionType.PushAction:
                //Create New Host
                //if (hostId != EvacuatingHost)
                //if (EvacuatingHost == 0)

                if (EvacuatingHosts.Count == 0)
                {
                    //if (_pushFailures > Global.GetNoOfFailures)
                    if (!DataHolder.GetCandidateHosts(UtilizationStates.UnderUtilization, 0).Any())
                    {
                        PowerController.PowerOnHost();
                    }
                    //_pushFailures = 0;

                    //else
                    //{
                    //    //_pushFailures++;
                    //}
                }
                //else if (hostId == EvacuatingHost)
                else if (EvacuatingHosts.Contains(hostId))
                {
                    action = RejectActions.CancelEvacuation;
                    Console.WriteLine($"Cancel Evacuation for {hostId}");
                    //EvacuatingHost = 0;
                    EvacuatingHosts.Remove(hostId);
                    DataHolder.SetUtilization(hostId, UtilizationStates.UnderUtilization);
                }
                else
                {
                    //throw new Exception("Evacuting Host with Push Request, What to Do");
                    //Options (Cancel Evacuation Mode @All Hosts)
                    foreach (var ehost in EvacuatingHosts)
                    {
                        DataHolder.SetUtilization(ehost, UtilizationStates.UnderUtilization);
                        var cem = new CancelEvacuation(ehost, this.MachineId);
                        CommunicationModule.SendMessage(cem);
                    }
                    EvacuatingHosts.Clear();
                }
                break;

            case StrategyActionType.PullAction:
                //Evacuate Host
                if (EvacuatingHosts.Contains(hostId))
                {
                    throw new NotImplementedException();
                }
                if (    //(EvacuatingHost == 0 &&
                    !DataHolder.GetCandidateHosts(UtilizationStates.OverUtilization, 0).Any())
                {
                    DataHolder.SetUtilization(hostId, UtilizationStates.Evacuating);
                    //EvacuatingHost = hostId;
                    EvacuatingHosts.Add(hostId);
                    if (EvacuatingHosts.Count > 1)
                    {
                    }
                    action = RejectActions.Evacuate;
                    Console.WriteLine($"Start Evacuation for {hostId}");
                }
                //else if (hostId == EvacuatingHost)
                //{
                //    throw new NotImplementedException();
                //}

                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            RejectRequest request = new RejectRequest(hostId, this.MachineId, atype, action);

            CommunicationModule.SendMessage(request);
        }