public ServerCommandHandler(IFactory factory, IMessengerSet messengerSet, ICommandSerializer serializer)
{
Factory = factory;
MessengerSet = messengerSet;
Serializer = serializer;
MessengerSet.ServerCommands.MessageReceived += ServerCommands_MessageReceived;
}
public SessionStore(
ICommandSerializer commandSerializer,
IFrameworkContextFactory frameworkContextFactory)
{
_commandSerializer = commandSerializer;
_frameworkContextFactory = frameworkContextFactory;
}
private static ICommandSerializer[] InitializeSerializers(params ICommandSerializer[] serializers)
{
int max = 0;
foreach (ICommandSerializer s in serializers)
{
if (s.CommandType > max)
{
max = s.CommandType;
}
}
ICommandSerializer[] res = new ICommandSerializer[max + 1];
foreach (ICommandSerializer s in serializers)
{
if (res[s.CommandType] != null && res[s.CommandType] != s)
{
throw new ArgumentException("two serializers with the same commandType!!");
}
res[s.CommandType] = s;
}
return(res);
}
public ClientManager(IServer server, ICommandQueueService commandQueueService, ICommandSerializer commandSerializer, IStreamIOService streamIoService)
{
_server = server;
_commandQueueService = commandQueueService;
_commandSerializer = commandSerializer;
_streamIoService = streamIoService;
}
public CommandProcessor(ICommandRegistry commandRegistry, ICommandExecutor commandExecutor, ICommandSerializer commandSerializer, IServiceLocator serviceLocator)
{
this.commandRegistry = commandRegistry;
this.commandExecutor = commandExecutor;
this.commandSerializer = commandSerializer;
this.serviceLocator = serviceLocator;
}
public CommandStream(int streamId, TcpClient tcpClient, ICommandSerializer serializer)
{
_bytesPool = new ObjectPool <byte>(100, () => new byte());
_stream = tcpClient.GetStream();
_socket = tcpClient.Client;
Id = streamId;
_serializer = serializer;
}
public Server(GameHost host, IFactory factory, ICommandSerializer serializer)
{
Factory = factory;
Serializer = serializer;
MessengerSet = Factory.CreatePlayerMessengerSet(host, "");
MessengerSet.ServerCommands.MessageReceived += ServerCommands_MessageReceived;
}
public DefaultCommandPersister(
ICommandSerializer serializer,
IContext context,
IRepository<CommandTable> repository)
{
m_serializer = serializer;
m_context = context;
m_repository = repository;
}
public QueueConsumer(ICommandSerializer serializer, IScenarioDeserializer deserializer, IIronMqSettings ironMqSettings, ILogger logger)
{
_serializer = serializer;
_deserializer = deserializer;
_ironMqSettings = ironMqSettings;
_logger = logger;
_client = _client = new RestClient(string.Format(ironMqSettings.IronMqUrl + "/1/projects/{0}", ironMqSettings.ProjectId));
}
public BusinessCodeFiniteStateMachine(
ICommandSerializer commandSerializer,
IBusinessCodeConfigManager businessCodeConfigManager,
IBusinessCodeCache businessCodeCache)
{
_commandSerializer = commandSerializer;
_businessCodeConfigManager = businessCodeConfigManager;
_businessCodeCache = businessCodeCache;
}
public RemotePeer(ICommandSerializer serializer, ICommandsTransportResource transport, IOutputStream stream, HostName host, string port)
{
_serializer = serializer;
_transport = transport;
_dataWriter = new DataWriter(stream);
HostName = host.RawName;
Port = port;
HandleActivity();
_transport.Received += _transport_Received;
}
public Client(TcpClient tcpClient, IClientInformation clientInformation)
{
ClientInformation = clientInformation;
_commandQueueService = new CommandQueueService();
_commandQueueService.OnCommandPending += _commandQueueService_OnCommandPending;
_tcpClient = tcpClient;
_clientCommandHandler = new ClientCommandHandler(_tcpClient, new CommandSerializer(), this) { ClientInfomation = clientInformation };
_commandFactory = new CommandFactory();
_commandSerializer = new CommandSerializer();
}
public ConnectionsManager(ITransportResource resource,
IUsersRepository userRepository,
ICommandSerializer serializer)
{
_resource = resource;
_userRepository = userRepository;
_serializer = serializer;
_resource.Received += _resource_OnReceived;
_timer = new Timer(OnTimerTick, null, TimerInterval);
}
public ConnectionsManager(ITransportResource resource,
IUsersRepository userRepository,
ICommandSerializer serializer)
{
_resource = resource;
_userRepository = userRepository;
_serializer = serializer;
_resource.Received += _resource_OnReceived;
_timer = new Timer(OnTimerTick, null, TimerInterval);
}
public CommandDispatcher(IRepository <Command> r, IContainer container)
{
m_projections = container.GetAllInstances <IProjection <TCommand> >().ToArray();
m_genericprojections = container.GetAllInstances <IProjection <object> >().ToArray();
m_handlers = container.GetAllInstances <IHandler <TCommand> >().OrderBy(x => x.Order).ToArray();
m_commandRepository = r;
CommandSerializer = new JsonCommandSerializer();
}
public RemotePeer(ICommandSerializer serializer, ICommandsTransportResource transport, IOutputStream stream, HostName host, string port)
{
_serializer = serializer;
_transport = transport;
_dataWriter = new DataWriter(stream);
HostName = host.RawName;
Port = port;
HandleActivity();
_transport.Received += _transport_Received;
}
public ConnectionsService(ICommandsTransportResource resource,
ITransactionFactory transactionFactory,
IUserRepository userRepository,
ICommandSerializer serializer)
: base(transactionFactory)
{
_userRepository = userRepository;
_serializer = serializer;
resource.Received += _resource_OnReceived;
_timer = new Timer(OnTimerTick, null, TimerInterval);
}
private WhitePeer(object automationPeer, object control, ICommandSerializer commandSerializer, GetValueDelegate getValueDelegate,
SetValueDelegate setValueDelegate)
{
if (!(automationPeer is IValueProvider)) throw new ArgumentException("Automation Peer should be a IValueProvider");
this.automationPeer = automationPeer;
this.control = control;
this.commandSerializer = commandSerializer;
this.getValueDelegate = getValueDelegate;
this.setValueDelegate = setValueDelegate;
}
public ConnectionsService(ICommandsTransportResource resource,
ITransactionFactory transactionFactory,
IUserRepository userRepository,
ICommandSerializer serializer)
: base(transactionFactory)
{
_userRepository = userRepository;
_serializer = serializer;
resource.Received += _resource_OnReceived;
_timer = new Timer(OnTimerTick, null, TimerInterval);
}
public void WhenConstructedWithNullQuerySerializerShouldThrowArgumentNullException()
{
var dbContextFactory = new Mock <IDbContextFactory>().Object;
ICommandSerializer commandSerializer = null;
var logger = new Mock <ILogger <EntityFrameworkCoreCommandStore> >().Object;
Action act = () => new EntityFrameworkCoreCommandStore(dbContextFactory: dbContextFactory, commandSerializer: commandSerializer, logger: logger);
act.Should().Throw <ArgumentNullException>().
And.ParamName.Should().Be("commandSerializer");
}
public ChatServer(int port, ICommandSerializer serializer)
{
_server = new TcpListener(IPAddress.Any, port);
_commandHandler = new CommandHandler(serializer);
_commandHandler.RegisterHandler <ClientLoginRequest>(LoginHandler);
_commandHandler.RegisterHandler <ClientJoinRoomRequest>(JoinRoomHandler);
_commandHandler.RegisterHandler <ClientSendMessageToRoom>(RoomMessageHandler);
_commandHandler.RegisterHandler <ClientListRoomsRequest>(ListRoomsHandler);
_commandHandler.RegisterHandler <ClientListRoomUsersRequest>(ListRoomUsersRequest);
_commandHandler.OnClose += OnCloseStream;
_server.Start();
FetchConnection();
}
public RestSharpIronMqClientAdapter(ICommandSerializer serializer,
ICommandDeserializer deserializer, ICommandDispatcher commandDispatcher, IIronMqSettings settings)
{
_serializer = serializer;
_deserializer = deserializer;
_commandDispatcher = commandDispatcher;
_settings = settings;
string ironMqUrl = _settings.IronMqUrl;
_client = new RestClient(string.Format(ironMqUrl + "/1/projects/{0}", _settings.ProjectId));
_maxCommandsToProcessEachPoll = Config.GetMaxCommandsToProcessPerPoll();
}
public Client(GameHost host, string playerName, IFactory factory, ICommandSerializer serializer)
{
Factory = factory;
Serializer = serializer;
MessengerSet = Factory.CreatePlayerMessengerSet(host, playerName);
MessengerSet.ServerCommands.MessageReceived += ServerCommands_MessageReceived;
var cmd = new AddPlayerCommand()
{
PlayerName = playerName
};
MessengerSet.ServerCommands.Send(Serializer.Serialize(cmd));
}
private WhitePeer(object automationPeer, object control, ICommandSerializer commandSerializer, GetValueDelegate getValueDelegate,
SetValueDelegate setValueDelegate)
{
if (!(automationPeer is IValueProvider))
{
throw new ArgumentException("Automation Peer should be a IValueProvider");
}
this.automationPeer = automationPeer;
this.control = control;
this.commandSerializer = commandSerializer;
this.getValueDelegate = getValueDelegate;
this.setValueDelegate = setValueDelegate;
}
internal ChatClient(string host, int port, ICommandSerializer serializer)
{
_host = host;
_port = port;
_client = new TcpClient();
_commandHandler = new CommandHandler(serializer);
_commandHandler.RegisterHandler <ServerRoomMessage>(OnRoomMessage);
_commandHandler.RegisterHandler <ServerServiceMessage>(OnServiceMessage);
_commandHandler.OnClose += OnClose;
ValidateConnection().ContinueWith(t =>
{
if (t.IsFaulted)
{
Console.WriteLine("Connection failed");
}
}
);
}
/// <summary>
/// Local node
/// </summary>
/// <param name="nodeId"></param>
/// <param name="stateMachine"></param>
/// <param name="log"></param>
/// <param name="electionTimeoutRandom"></param>
/// <param name="commandSerializer"></param>
/// <param name="settings"></param>
public LocalNode(
NodeId nodeId,
IReplicatedStateMachine stateMachine,
ILog log,
IElectionTimeoutRandom electionTimeoutRandom,
ICommandSerializer commandSerializer,
IRaftSettings settings)
{
Id = nodeId.Id;
ServiceUri = nodeId.ServiceUri;
Role = NodeRole.Follower;
_stateMachine = stateMachine;
_log = log;
_electionTimeoutRandom = electionTimeoutRandom;
_commandSerializer = commandSerializer;
_heartbeatMilliseconds = settings.HeartbeatMilliseconds <= 0 ? 100 : settings.HeartbeatMilliseconds;
_commandTimeoutMilliseconds = settings.CommandTimeoutMilliseconds <= 0 ? 3000 : settings.CommandTimeoutMilliseconds;
_appendEntriesBatchSize = settings.AppendEntriesBatchSize <= 0 ? 100 : settings.AppendEntriesBatchSize;
}
private static ICommandSerializer[] InitializeSerializers(string selectNamespace)
{
List <ICommandSerializer> list = new List <ICommandSerializer>();
foreach (Type t in Assembly.GetExecutingAssembly().GetTypes())
{
if (!t.Namespace.StartsWith(selectNamespace))
{
continue;
}
if (!t.IsAbstract && t.IsClass && typeof(ICommandSerializer).IsAssignableFrom(t))
{
ICommandSerializer obj = (ICommandSerializer)t.GetTypeInfo().GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance).First(c => c.GetParameters().Length == 0).Invoke(new object[0]);
list.Add(obj);
}
}
return(InitializeSerializers(list.ToArray()));
}
public EntityFrameworkCoreCommandStore(IDbContextFactory dbContextFactory,
ICommandSerializer commandSerializer,
ILogger <EntityFrameworkCoreCommandStore> logger)
{
if (dbContextFactory == null)
{
throw new ArgumentNullException(nameof(dbContextFactory));
}
if (commandSerializer == null)
{
throw new ArgumentNullException(nameof(commandSerializer));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_dbContextFactory = dbContextFactory;
_commandSerializer = commandSerializer;
_logger = logger;
}
public DesktopSerialListener(SerialPort port, ICommandSerializer serializer)
: base(serializer)
{
Port = port;
}
public WorkerSerialTransport(ICommandSerializer serializer, SerialPort serialPort)
: base(serializer)
{
SerialPort = serialPort;
}
public TestDirector(ICommandSerializer serializer, ITestTransport transport)
{
Transport = transport;
Serializer = serializer;
}
public MeadowSerialListener(ISerialPort port, ICommandSerializer serializer)
: base(serializer)
{
Port = port;
}
public WorkerSerialTransport(ICommandSerializer serializer, string serialPort, int baudRate = 9600)
: base(serializer)
{
SerialPort = new SerialPort(serialPort, baudRate);
}
public TransportManager(ITransportResource resource, ICommandSerializer serializer)
{
_resource = resource;
_serializer = serializer;
_resource.Received += _resource_OnReceived;
}
public virtual void ProcessResult(ICommandSerializer serializer, byte[] resultData)
{
}
public TransportResource(ICommandSerializer serializer)
{
_serializer = serializer;
_socket.MessageReceived += _socket_OnMessageReceived;
BindService();
}
public CommandHandler(ICommandSerializer serializer)
{
RequestTimeout = TimeSpan.FromSeconds(30);
_serializer = serializer;
}
public virtual void Prepare()
{
ServerInformation = new ServerInformation( "OSTBLOCK COMMAND SERVER", "OSTBLOCK COMMAND SERVER", new Version(0,1,0,0))
{ServerState = EServerState.Prepareing};
_commandSerializer = new CommandSerializer();
CommandFactory = new ServerCommandFactory();
_streamIOService = new StreamIOService();
CommandQueueService = new CommandQueueService();
ServerCommandHandler = new ServerCommandHandler(this);
ClientManager = new ClientManager(this,CommandQueueService, _commandSerializer, _streamIOService);
CommandQueueService.OnCommandPending += CommandQueueService_OnCommandPending;
ServerInformation.ServerState = EServerState.Prepared;
if(OnPrepared != null)
OnPrepared.Invoke(this,new EventArgs());
}
public TransportResource(ICommandSerializer serializer)
{
_serializer = serializer;
_socket.MessageReceived += _socket_OnMessageReceived;
BindService();
}
public object CreateCommandHandler(IMessengerSet messengerSet, ICommandSerializer serializer) => new ServerCommandHandler(this, messengerSet, serializer);
public TransportManager(ITransportResource resource, ICommandSerializer serializer)
{
_resource = resource;
_serializer = serializer;
_resource.Received += _resource_OnReceived;
}
public TestTransportBase(ICommandSerializer serializer)
{
Serializer = serializer;
}
