public override async Task IfEffect(StateMachineEvent evt, Command parameter)
 {
     var supportsMessage = new Supports(InformationMessageHeader, new HashSet<string>(Features), null);
     await Sender.SendMessage(supportsMessage.ToMessage());
     var sidMessage = new Sid(new InformationMessageHeader(), User.Sid);
     await Sender.SendMessage(sidMessage.ToMessage());
 }
 protected async Task EchoedDirectCommand(Command command)
 {
     var echoMessageType = (EchoMessageHeader)command.Header;
     var sender = ActorProxy.Create<ISender>(new ActorId(echoMessageType.TargetSid));
     await sender.SendMessage(command.OriginalMessage);
     await Sender.SendMessage(command.OriginalMessage);
 }
 public override async Task IfEffect(StateMachineEvent evt, Command parameter)
 {
     var command = (Information)parameter;
     await _user.UpdateInformation(command);
     var hubInformation = CreateHubInformation();
     await Sender.SendMessage(hubInformation.ToMessage());
 }
        public override async Task<bool> Guard(StateMachineEvent evt, Command parameter)
        {
            var command = (Information)parameter;
            if (!command.Pid.IsDefined)
            {
                CreateRequiredFieldIsMissing("PD");
                return false;
            }

            if (!command.Cid.IsDefined)
            {
                CreateRequiredFieldIsMissing("ID");
                return false;
            }

            var cid = AdcBase32Encoder.Decode(command.Cid.Value);
            var pid = AdcBase32Encoder.Decode(command.Pid.Value);
            var hash = new TigerHash().ComputeHash(pid);
            if (!hash.SequenceEqual(cid))
            {
                CreateInvalidPid();
                return false;
            }

            if (!command.IpAddressV4.IsDefined && !command.IpAddressV6.IsDefined)
            {
                CreateRequiredFieldIsMissing("I4");
                return false;
            }

            if (command.IpAddressV4.IsDefined && command.IpAddressV4.Value != _user.ClientIPv4.ToString())
            {
                CreateInvalidIPv4(_user.ClientIPv4.ToString());
                return false;
            }

            if (command.IpAddressV6.IsDefined && command.IpAddressV6.Value != _user.ClientIPv6.ToString())
            {
                CreateInvalidIPv6(_user.ClientIPv6.ToString());
                return false;
            }

            if (!command.Nickname.IsDefined || string.IsNullOrWhiteSpace(command.Nickname.Value))
            {
                CreateInvalidNick();
                return false;
            }

            var catalog = ServiceProxy.Create<ICatalog>(new Uri("fabric:/FabricAdcHub.ServiceFabric/Catalog"));
            if (!await catalog.ReserveNick(_user.Sid, command.Nickname.Value))
            {
                CreateNonUniqueNick();
                return false;
            }

            return true;
        }
        public override async Task Effect(StateMachineEvent evt, Command parameter)
        {
            if (parameter != null)
            {
                var status = new Status(new InformationMessageHeader(), Status.ErrorSeverity.Fatal, Status.ErrorCode.InvalidState, $"Command {parameter.FourCc()} is invalid or not available in PROTOCOL state.");
                status.OffendingCommandOrMissingFeature.Value = parameter.FourCc();
                await Sender.SendMessage(status.ToMessage());
            }

            await User.Close();
        }
        public override Task<bool> Guard(StateMachineEvent evt, Command parameter)
        {
            var command = (Supports)parameter;
            for (var index = 0; index != Features.Length; index++)
            {
                var feature = Features[index];
                if (!command.AddFeatures.Value.Contains(feature))
                {
                    CreateRequiredFeatureIsMissing(feature);
                    return Task.FromResult(false);
                }
            }

            return Task.FromResult(true);
        }
        public override async Task Effect(StateMachineEvent evt, Command parameter)
        {
            if (parameter != null)
            {
                var status = new Status(new InformationMessageHeader(), Status.ErrorSeverity.Fatal, Status.ErrorCode.InvalidState, $"Command {parameter.FourCc()} is invalid or not available in IDENTIFY state.");
                status.OffendingCommandOrMissingFeature.Value = parameter.FourCc();
                await Sender.SendMessage(status.ToMessage());
            }

            if (evt.InternalEvent != InternalEvent.DisconnectOccured)
            {
                var quit = new Quit(new InformationMessageHeader(), User.Sid);
                await Sender.SendMessage(quit.ToMessage());
            }

            await User.Close();
        }
        public static bool TryCreateFromMessage(string message, out Command command)
        {
            command = null;
            if (string.IsNullOrWhiteSpace(message))
            {
                return false;
            }

            var parts = SplitText(message);
            var messageTypeAndName = parts[0];
            if (messageTypeAndName.Length != 4)
            {
                return false;
            }

            var parameters = parts.Skip(1).ToList();

            var messageTypeSymbol = messageTypeAndName[0];
            if (!MessageHeaderCreators.ContainsKey(messageTypeSymbol))
            {
                return false;
            }

            var messageHeader = MessageHeaderCreators[messageTypeSymbol](parameters);
            var commandName = messageTypeAndName.Substring(1, 3);
            if (!CommandCreators.ContainsKey(commandName))
            {
                return false;
            }

            var commandType = CommandType.FromText(commandName);
            var positionalParameters = parameters
                .Skip(messageHeader.Type.NumberOfParameters)
                .Take(commandType.NumberOfParameters)
                .ToList();
            var namedParameters = parameters
                .Skip(messageHeader.Type.NumberOfParameters)
                .Skip(commandType.NumberOfParameters)
                .ToList();
            command = CommandCreators[commandName](messageHeader, positionalParameters, namedParameters, message);
            return true;
        }
        public override async Task Effect(StateMachineEvent evt, Command parameter)
        {
            if (evt.InternalEvent == InternalEvent.ConnectionTimedOut)
            {
                // do nothing
                return;
            }

            if (parameter.Type == CommandType.Information)
            {
                await User.UpdateInformation((Information)parameter);
            }
            else if (parameter.Type == CommandType.Supports)
            {
                await User.UpdateInformation((Supports)parameter);
            }

            if (parameter.Header is BroadcastMessageHeader)
            {
                await BroadcastCommand(parameter);
                return;
            }

            if (parameter.Header is DirectMessageHeader)
            {
                await DirectCommand(parameter);
                return;
            }

            if (parameter.Header is EchoMessageHeader)
            {
                await EchoedDirectCommand(parameter);
                return;
            }

            if (parameter.Header is FeatureBroadcastMessageHeader)
            {
                await FeatureBroadcastCommand(parameter);
            }
        }
 public override async Task ElseEffect(StateMachineEvent evt, Command parameter)
 {
     var quit = new Quit(new InformationMessageHeader(), _user.Sid);
     await Sender.SendMessage(quit.ToMessage());
     await _user.Close();
 }
 public async Task ProcessCommand(Command command)
 {
     await _stateMachine.Fire(new StateMachineEvent(InternalEvent.AdcMessageReceived, command.Type), command);
 }
 protected async Task FeatureBroadcastCommand(Command command)
 {
     var featureBroadcastMessageHeader = (FeatureBroadcastMessageHeader)command.Header;
     var catalog = ServiceProxy.Create<ICatalog>(new Uri("fabric:/FabricAdcHub.ServiceFabric/Catalog"), targetReplicaSelector: TargetReplicaSelector.RandomReplica);
     await catalog.FeatureBroadcastMessage(User.Sid, featureBroadcastMessageHeader.RequiredFeatures.ToList(), featureBroadcastMessageHeader.ExcludedFeatures.ToList(), command.ToMessage());
 }
Exemple #13
0
 public override Task ElseEffect(StateMachineEvent evt, Command parameter)
 {
     return Sender.SendMessage(_errorCommand.ToMessage());
 }
 protected async Task BroadcastCommand(Command command)
 {
     var catalog = ServiceProxy.Create<ICatalog>(new Uri("fabric:/FabricAdcHub.ServiceFabric/Catalog"), targetReplicaSelector: TargetReplicaSelector.RandomReplica);
     await catalog.BroadcastMessage(User.Sid, command.OriginalMessage);
 }
 public override async Task Effect(StateMachineEvent evt, Command parameter)
 {
     await User.Close();
 }
Exemple #16
0
        private async Task SendCommand(Command command)
        {
            var message = command.ToMessage();
            ServiceEventSource.Current.AdcMessageSent(message);

            var messageBytes = Encoding.UTF8.GetBytes(message + "\n");
            await _tcpClient.GetStream().WriteAsync(messageBytes, 0, messageBytes.Length);
        }
 public override Task<bool> Guard(StateMachineEvent evt, Command parameter)
 {
     var status = (Status)parameter;
     return Task.FromResult(status.Severity == Status.ErrorSeverity.Fatal);
 }
 public override Task IfEffect(StateMachineEvent evt, Command parameter)
 {
     return Task.CompletedTask;
 }