static void Main(string[] args)
{
var serviceLocator = new ServiceLocator(CreateDIContainer());
var baseurl = new Uri("http://localhost:1000/");
var serverState = new ServerState();
serverState["Hello"] = "World";
var config = new HttpConfiguration();
config.CreateInstance = (type, context, request) => serviceLocator.GetInstance(type);
config.RequestHandlers = (handlers, se, od) => handlers.Add(new ServerStateOperationHandler(serverState));
config.ResponseHandlers = (handlers, se, od) => {
handlers.Add(new LoggingOperationHandler(new Logger()));
handlers.Add(new CompressionHandler());
};
config.Formatters.Insert(0, new JsonMediaTypeFormatter());
HttpServiceHost host = new HttpServiceHost(typeof(FooService), config, baseurl);
host.Open();
Console.WriteLine("Host open. Hit enter to exit...");
Console.WriteLine("Use a web browser and go to " + baseurl + " or do it right and get fiddler!");
Console.Read();
host.Close();
}
public HttpResponseMessage GetServerState(ServerState serverState)
{
var httpResponseMessage = new HttpResponseMessage();
httpResponseMessage.StatusCode = HttpStatusCode.OK;
httpResponseMessage.Content = new StringContent((string)serverState["Hello"], System.Text.Encoding.UTF8, "text/plain");
return httpResponseMessage;
}
private void HandleMenuStartServer(object sender, RoutedEventArgs e)
{
serverState = ServerState.RUNNING;
serverMiniCheckers.UpdateMenuState(serverState);
updateRequestResponse("Server started");
Debug.WriteLine("Server Starting");
}
public void Initialize()
{
_state = ServerState.LOADING;
CreateRemotingObjects();
_residentOpenSAGEReadyMutex = new Mutex(true, OpenSAGERemoteSettings.ResidentOpenSAGEReadyMutexName);
_state = ServerState.READY;
}
private void HandleMenuStopServer(object sender, RoutedEventArgs e)
{
serverState = ServerState.STOPPED;
serverMiniCheckers.UpdateMenuState(serverState);
updateRequestResponse("Server stopped");
Debug.WriteLine("Server Stopping");
}
private void RaisePacketHandled(int id, IPacket packet, ServerState? state)
{
if (DebugPackets)
PacketsReceived.Add(packet);
if (OnPacketHandled != null)
OnPacketHandled(id, packet, state);
}
internal WebSocketServiceHostManager(Logger logger)
{
_logger = logger;
_keepClean = true;
_serviceHosts = new Dictionary<string, WebSocketServiceHost> ();
_state = ServerState.READY;
_sync = new object ();
}
public void ListenForConnections()
{
state = ServerState.RUNNING;
connectionListenerThread = new Thread(new ThreadStart(ConnectionListenerHandler));
connectionListenerThread.Start();
//eventCheckerThread = new Thread(new ThreadStart(CheckForEvents));
//eventCheckerThread.Start();
}
protected void stepDown(IConsensus model, int term)
{
if (_state == ServerState.Leader || _state == ServerState.Candidate)
_state = ServerState.Follower;
_persistedState.UpdateState(term, null);
if (isElectionTimeout(model))
updateElectionAlarm(model);
}
private void HandleServerStatusChange(ServerState currentState)
{
//suport for calls from other threads
if (InvokeRequired)
{
Invoke((MethodInvoker) (() => HandleServerStatusChange(currentState)));
}
else
{
switch (currentState)
{
case ServerState.Starting:
btnStartStop.Enabled = false;
btnRestart.Enabled = false;
btnStartStop.Text = Locale.Tr("Starting...");
break;
case ServerState.Running:
if (ProcessHandler.Server.IsLocal)
{
btnStartStop.Text = Locale.Tr("Stop");
metroToolTip.SetToolTip(btnStartStop, "Stop the server");
}
else
{
metroToolTip.SetToolTip(btnStartStop, "Disconnect from the server");
btnStartStop.Text = Locale.Tr("Disconnect");
}
btnStartStop.Enabled = true;
btnRestart.Enabled = true;
btnStartStop.Text = Locale.Tr("Stop");
break;
case ServerState.Stopping:
btnStartStop.Enabled = false;
btnRestart.Enabled = false;
btnStartStop.Text = Locale.Tr("Stopping...");
break;
case ServerState.Stopped:
btnStartStop.Enabled = true;
btnRestart.Enabled = false;
if (ProcessHandler.Server.IsLocal)
{
btnStartStop.Text = Locale.Tr("Start");
metroToolTip.SetToolTip(btnStartStop, "Start the server");
}
else
{
btnStartStop.Text = Locale.Tr("Connect");
metroToolTip.SetToolTip(btnStartStop, "Connect to the server");
}
break;
}
}
}
public ServerOld(int id, string dataDir)
{
_id = id;
_dataDir = dataDir;
_peers = new List<Peer>();
_random = new Random(id ^ (int)DateTime.Now.Ticks);
_state = ServerState.Stopped;
}
protected override void HandleAsync(Packet packet)
{
_state = _state ?? (ServerState) State;
foreach (var endPoint in _state.Users.GetAllExcept(packet.Address))
{
LogManager.Debug("Packet from {0} redirected to {1}", packet.UserName, endPoint);
_state.Client.Send(packet, endPoint);
}
}
void ChangeState(ServerState newState)
{
Debug.Log("Change State: " + serverState + " >> " + newState);
if (serverState == newState) {
return;
}
ExitState();
serverState = newState;
EnterState();
}
public void UpdateServerState(FeedbackLevel workload, int peerCount, ServerState state)
{
if (!this.IsRegistered)
{
return;
}
var contract = new UpdateServerEvent { LoadIndex = (byte)workload, PeerCount = peerCount, State = (int)state };
var eventData = new EventData((byte)ServerEventCode.UpdateServer, contract);
this.SendEvent(eventData, new SendParameters());
}
internal WebSocketSessionManager(Logger logger)
{
_logger = logger;
_forSweep = new object ();
_keepClean = true;
_sessions = new Dictionary<string, IWebSocketSession> ();
_state = ServerState.Ready;
_sync = new object ();
setSweepTimer (60000);
}
public Server(int genSeed)
{
this.genSeed = genSeed;
serverName = "Test server";
maxPlayers = 4;
players = new Dictionary<IPAddress, ServerPlayer>();
port = 19283;
state = ServerState.Lobby;
Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerEnteredErrorStateException"/> class
/// with the specified error state.
/// </summary>
/// <param name="status">The error state entered by the server.</param>
/// <exception cref="ArgumentNullException">If <paramref name="status"/> is <see langword="null"/>.</exception>
public ServerEnteredErrorStateException(ServerState status)
: base(string.Format("The server entered an error state: '{0}'", status))
{
if (status == null)
throw new ArgumentNullException("status");
_state.Status = status.Name;
#if !NET35
SerializeObjectState += (ex, args) => args.AddSerializedState(_state);
#endif
}
internal WebSocketSessionManager(Logger logger)
{
_logger = logger;
_clean = true;
_forSweep = new object ();
_sessions = new Dictionary<string, IWebSocketSession> ();
_state = ServerState.Ready;
_sync = ((ICollection) _sessions).SyncRoot;
_waitTime = TimeSpan.FromSeconds (1);
setSweepTimer (60000);
}
public Server()
{
Rooms = new Dictionary<MobMap, MapRoom>();
InsertAllRooms();
DisplayUp = zUpload = 0;
DisplayDown = Download = 0;
NextId = 1;
ClientMutex = new Mutex();
Socket = null;
State = ServerState.Stopped;
AcceptClientsThread = new Thread(new ThreadStart(AcceptClients));
AcceptClientsThread.IsBackground = true;
}
/// <summary>
/// The NetworkServer will be instantiated once in the DDD Server.
/// External applications such as agents and custom GUIs should ignore this class.
/// </summary>
/// <param name="port"></param>
/// <param name="dist"></param>
public NetworkServer(int port, ref SimulationEventDistributor dist)
{
server = null;
state = ServerState.STOPPING;
eventDist = dist;
m_serverIP = null;
this.port = port;
connectionListenerThread = null;
//eventCheckerThread = null;
clientHandlers = new List<NetworkServerConnectionHandler>();
clientHandlersLock = new object();
//clientCount = 0;
}
public void UpdateMenuState(ServerState serverState)
{
switch (serverState)
{
case ServerState.RUNNING:
menuStartServer.IsEnabled = false;
menuStopServer.IsEnabled = true;
break;
case ServerState.STOPPED:
menuStopServer.IsEnabled = false;
menuStartServer.IsEnabled = true;
break;
}
}
public void ChangeSiteState(string siteId, ServerState state)
{
try
{
Log.WriteStart("'{0}' ChangeSiteState", ProviderSettings.ProviderName);
WebProvider.ChangeSiteState(siteId, state);
Log.WriteEnd("'{0}' ChangeSiteState", ProviderSettings.ProviderName);
}
catch (Exception ex)
{
Log.WriteError(String.Format("'{0}' ChangeSiteState", ProviderSettings.ProviderName), ex);
throw;
}
}
protected void startNewElection(IConsensus model)
{
if ((_state == ServerState.Follower || _state == ServerState.Candidate) &&
isElectionTimeout(model))
{
updateElectionAlarm(model);
_persistedState.UpdateState(_persistedState.Term + 1, _id);
_state = ServerState.Candidate;
//only request from peers that are allowed to vote
foreach (var peer in _peers)
peer.Reset();
Console.WriteLine("{0}: Starting new election for term {1}", _id, _persistedState.Term);
}
}
public ServerClient(string identity, IExtensionRegistry extensionRegistry, BufferManager bufferManager)
{
ServerName = identity;
_bufferManager = bufferManager;
_extensionService = new ExtensionService(extensionRegistry, DeliverMessage);
_connection = new Connection.Connection(ServerName, _extensionService, true, _bufferManager)
{
ExtensionFrameReceived = OnExtensionFrame,
MessageFrameReceived = OnMessageFrame,
WriteCompleted = OnWriteCompleted,
};
_connection.HandshakeReceived += OnHandshakeFrame;
_connection.Disconnected += HandleRemoteDisconnect;
_state = ServerState.WaitingOnInitialHandshake;
ServerName = "FastSocket v" + Major + "." + Minor;
}
protected override void Handle(Packet packet)
{
_state = _state ?? (ServerState) State;
LogManager.Info("User {0} with address {1} has logged on", packet.UserName, packet.Address);
try
{
_state.Users.Add(packet.UserName, packet.Address);
_queue.Enqueue(packet.Address);
State.Client.Send(PacketFactory.TypedPacket(PacketType.LogOn), packet.Address);
}
catch (Exception e)
{
LogManager.Error(e, "Error occured in register handler: '{0}'", e.Message);
}
}
private void RaisePacketHandled(int id, IPacket packet, ServerState? state)
{
if (state != ServerState.ModernStatus)
return;
switch ((PacketsServer) id)
{
case PacketsServer.Ping:
if (FirePingPacket != null)
FirePingPacket(packet);
break;
case PacketsServer.Response:
if (FireResponsePacket != null)
FireResponsePacket(packet);
break;
}
}
/// <summary>
/// Starts receiving the WebSocket connection requests.
/// </summary>
public void Start()
{
lock (_sync) {
var msg = _state.CheckIfStopped() ?? checkIfCertExists();
if (msg != null)
{
_logger.Error(
String.Format(
"{0}\nstate: {1}\nsecure: {2}", msg, _state, _secure));
return;
}
_serviceHosts.Start();
_listener.Start();
startReceiving();
_state = ServerState.START;
}
}
private void render(ServerState newState)
{
this.itsState = newState;
if (itsState == ServerState.MANAGING_PRODUCTS || itsState == ServerState.PRODUCT_ADDED_SUCCESSFULLY || itsState == ServerState.DUPLICATE_PRODUCT_NOT_ADDED)
{
this.Show();
this.productsList.Items.Clear();
foreach (var keyValuePair in this.itsModel.productsInventory)
{
Product product = keyValuePair.Value;
this.productsList.Items.Add(product.productID + ") " + product.item.name + " - [" + product.item.startingBidPrice + "] - " + product.productStatus);
}
}
else
{
this.Hide();
}
}
/// <summary>
/// Changes site's state.
/// </summary>
/// <param name="siteId">Site's id to change state for.</param>
/// <param name="state">State to be set.</param>
/// <exception cref="ArgumentException">Is thrown in case site name is null or empty.</exception>
public void ChangeSiteState(string siteId, ServerState state)
{
if (String.IsNullOrEmpty(siteId))
{
throw new ArgumentException("Site name is null or empty.");
}
switch (state)
{
case ServerState.Continuing:
case ServerState.Started:
this.ftpSitesService.StartSite(siteId);
break;
case ServerState.Stopped:
case ServerState.Paused:
this.ftpSitesService.StopSite(siteId);
break;
}
}
public void Start()
{
object sync = this._sync;
lock (sync)
{
string text = this._state.CheckIfStartable() ?? this.checkIfCertExists();
if (text != null)
{
this._logger.Error(string.Format("{0}\nstate: {1}\nsecure: {2}", text, this._state, this._secure));
}
else
{
this._services.Start();
this._listener.Start();
this.startReceiving();
this._state = ServerState.Start;
}
}
}
public void Shutdown()
{
if (m_State == ServerState.None)
{
return;
}
m_State = ServerState.None;
try {
m_AcceptEvent.Completed -= AcceptAsyncCompleted;
m_AcceptEvent.Dispose();
m_AcceptEvent = null;
m_Socket.Close();
while (m_Connects.Count > 0)
{
m_Connects[0].Disconnect();
}
} finally {
m_Socket = null;
}
}
public override Task StopAsync(CancellationToken cancellationToken)
{
switch (state)
{
case ServerState.Unstarted:
logger.LogInformation("{Type} has not been started", GetType().Name);
break;
case ServerState.Running:
state = ServerState.Stopped;
logger.LogInformation("{Type} was stopped", GetType().Name);
break;
case ServerState.Stopped:
logger.LogInformation("{Type} has already been stopped", GetType().Name);
break;
}
return(Task.CompletedTask);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var listener = new TcpListener(IPAddress.Any, port);
listener.Start();
state = ServerState.Running;
logger.LogInformation("{Type} started on Port:{Port}", GetType().Name, port);
await using CancellationTokenRegistration registry = stoppingToken.Register(() => listener.Stop());
while (!stoppingToken.IsCancellationRequested)
{
TcpClient client = await listener.AcceptTcpClientAsync(stoppingToken);
var session = context.Resolve <T>();
session.Init(client);
session.OnPacket += router.OnPacket;
AddSession(session);
}
}
public void Listen(int port)
{
if (m_State != ServerState.None)
{
return;
}
try {
m_AcceptEvent = new SocketAsyncEventArgs();
m_AcceptEvent.Completed += AcceptAsyncCompleted;
m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
m_Socket.NoDelay = false;
m_Socket.Bind(new IPEndPoint(IPAddress.Any, port));
m_Socket.Listen(10);
m_State = ServerState.Listened;
BeginAccept();
} catch (System.Exception ex) {
m_State = ServerState.None;
logger.error("服务器监听失败 [" + port + "] " + ex.ToString());
};
}
internal void Stop(byte [] data, bool send)
{
lock (_sync) {
_state = ServerState.ShuttingDown;
var payload = new PayloadData(data);
var args = new CloseEventArgs(payload);
var frameAsBytes = send
? WsFrame.CreateCloseFrame(Mask.Unmask, payload).ToByteArray()
: null;
foreach (var host in _hosts.Values)
{
host.Sessions.Stop(args, frameAsBytes);
}
_hosts.Clear();
_state = ServerState.Stop;
}
}
public void StartGame()
{
State = ServerState.GameStarted;
listener.Stop();
Console.WriteLine("Game started");
foreach (var c in conns)
{
foreach (var d in conns)
{
DispatchOrdersToClient(c, d.PlayerIndex, 0x7FFFFFFF, new byte[] { 0xBF });
}
}
// Drop any unvalidated clients
foreach (var c in preConns.ToArray())
{
DropClient(c);
}
DispatchOrders(null, 0,
new ServerOrder("StartGame", "").Serialize());
foreach (var t in ServerTraits.WithInterface <IStartGame>())
{
t.GameStarted(this);
}
// Check TimeOut
if (Settings.TimeOut > 10000)
{
gameTimeout = new XTimer(Settings.TimeOut);
gameTimeout.Elapsed += (_, e) =>
{
Console.WriteLine("Timeout at {0}!!!", e.SignalTime);
Environment.Exit(0);
};
gameTimeout.Enabled = true;
}
}
public async Task Test()
{
using var _ = HConsoleForTest();
var options = HazelcastOptions.Build();
options.Messaging.RetryTimeoutSeconds = 1;
var loggerFactory = new NullLoggerFactory();
var address = NetworkAddress.Parse("127.0.0.1:11000");
var state = new ServerState
{
Id = 0,
MemberId = Guid.NewGuid(),
Address = address
};
await using var server = new Server(address, ServerHandler, loggerFactory, state, "0")
{
MemberId = state.MemberId,
};
await server.StartAsync();
var serializationService = HazelcastClientFactory.CreateSerializationService(options.Serialization, loggerFactory);
var authenticator = new Authenticator(options.Authentication, serializationService, loggerFactory);
ISequence <long> correlationIdSequence = new Int64Sequence();
var memberConnection = new MemberConnection(address, authenticator,
options.Messaging, options.Networking, options.Networking.Ssl,
correlationIdSequence,
loggerFactory);
var memberConnectionHasClosed = false;
memberConnection.Closed += connection =>
{
memberConnectionHasClosed = true;
return(default);
// resolver for waiting players server state
private void WaitingPlayersStateResolver()
{
foreach (Player conPlayer in _connectedPlayers)
{
switch (conPlayer.GameState)
{
case GameState.Disconnected:
// handle if a player is in disconneted state
// fornow if this happens the game ends and the connections are droped
// todo func that close connection and remove the player from the list
break;
case GameState.Connecting:
// call handler for connecting state
Connecting(conPlayer);
break;
case GameState.Sync:
// sending the last layer info to the other player
SyncNewPlayer(conPlayer);
break;
}
}
// need to confirm if all players are waiting players
// if soo and the player connected cout is 2, this means that server is ready
// to start a match
// if exists 2 players connected
// and all players waiting player
if (_connectedPlayers.Count == 2 && CheckAllPlayersState(GameState.WaitPlayer))
{
// Debug that all players are waiting for other player and there is
// 2 players connect
Debug.Log(_connectedPlayers.Count + " players connected and all synced");
Console.Write(_connectedPlayers.Count + " players connected and synced", Color.yellow);
// change the serve to server started the match
_serverState = ServerState.ServerLoadingClients;
}
}
/// <summary>
/// Stops receiving the incoming requests, and closes the connections with
/// the specified <paramref name="code"/> and <paramref name="reason"/> for
/// the WebSocket connection close.
/// </summary>
/// <param name="code">
/// One of the <see cref="CloseStatusCode"/> enum values that represents
/// the status code indicating the reason for the WebSocket connection close.
/// </param>
/// <param name="reason">
/// A <see cref="string"/> that represents the reason for the WebSocket
/// connection close. The size must be 123 bytes or less.
/// </param>
public void Stop(CloseStatusCode code, string reason)
{
string msg;
if (!checkIfAvailable(false, true, false, false, out msg))
{
_logger.Error(msg);
return;
}
if (!WebSocket.CheckParametersForClose(code, reason, false, out msg))
{
_logger.Error(msg);
return;
}
lock (_sync)
{
if (!checkIfAvailable(false, true, false, false, out msg))
{
_logger.Error(msg);
return;
}
_state = ServerState.ShuttingDown;
}
if (code == CloseStatusCode.NoStatus)
{
_services.Stop(new CloseEventArgs(), true, true);
}
else
{
var send = !code.IsReserved();
_services.Stop(new CloseEventArgs(code, reason), send, send);
}
stopReceiving(5000);
_state = ServerState.Stop;
}
private void stop(ushort code, string reason)
{
if (_state == ServerState.Ready)
{
_logger.Info("The server is not started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
_logger.Info("The server is shutting down.");
return;
}
if (_state == ServerState.Stop)
{
_logger.Info("The server has already stopped.");
return;
}
lock (_sync) {
if (_state == ServerState.ShuttingDown)
{
_logger.Info("The server is shutting down.");
return;
}
if (_state == ServerState.Stop)
{
_logger.Info("The server has already stopped.");
return;
}
_state = ServerState.ShuttingDown;
}
stopReceiving(5000);
_services.Stop(code, reason);
_state = ServerState.Stop;
}
public static bool CheckModuleState(MessageEventArgs e, string module, bool isDirectMessage)
{
ulong srvrid = e.Server.Id;
ulong chnlid = e.Channel.Id;
ServerStateRepository.AddServer(e.Server);
ChannelStateRepository.AddChannel(e.Channel, e.Server);
if (isDirectMessage) return true;
ServerState srvr = ServerStateRepository.GetServerState(srvrid);
ChannelState chnl = ChannelStateRepository.GetChannelState(chnlid);
switch (module.ToLower())
{
case "ask":
return (srvr.AskEnabled || chnl.AskEnabled);
case "comic":
return (srvr.ComicModuleEnabled || chnl.ComicModuleEnabled);
case "gamertag":
return (srvr.GamertagModuleEnabled || chnl.GamertagModuleEnabled);
case "motd":
return (srvr.MOTDEnabled || chnl.MOTDEnabled);
case "quote":
return (srvr.QuoteModuleEnabled || chnl.QuoteModuleEnabled);
case "roll":
return (srvr.RollEnabled || chnl.RollEnabled);
case "table":
return (srvr.TableUnflipEnabled || chnl.TableUnflipEnabled);
case "twitter":
return (srvr.TwitterModuleEnabled || chnl.TwitterModuleEnabled);
case "note":
return (srvr.NoteModuleEnabled || chnl.NoteModuleEnabled);
case "politics":
return (srvr.PoliticsEnabled || chnl.PoliticsEnabled);
case "battle":
return (srvr.ChatBattleEnabled || chnl.ChatBattleEnabled);
case "chatty":
return (srvr.ChattyModeEnabled || chnl.ChattyModeEnabled);
case "markov":
return (srvr.MarkovListenerEnabled || chnl.MarkovListenerEnabled);
default:
return false;
}
}
void interpMuzzle()
{
float timeSinceFire;
if (OperationNetwork.isServer)
{
timeSinceFire = ServerState.getLifeTime(firedAt);
}
else
{
timeSinceFire = Interp.getLifeTime(firedAt);
}
if (timeSinceFire < 0.025f)
{
enableMuzzle();
}
else
{
disableMuzzle();
}
}
protected override void AssertFinalState(AppServices services, ServerState finalServerState, DatabaseState finalDatabaseState)
{
if (finalServerState.DefaultWorkspace == null)
{
throw new NoDefaultWorkspaceException();
}
finalServerState.Workspaces.Should().HaveCount(1)
.And
.Contain(ws => ws.Id == finalServerState.DefaultWorkspace.Id);
finalDatabaseState.Workspaces.Should().HaveCount(1)
.And
.Contain(ws => ws.Id == finalServerState.DefaultWorkspace.Id);
finalDatabaseState.Clients.Should().HaveCount(0);
finalDatabaseState.Tags.Should().HaveCount(0);
finalDatabaseState.Projects.Should().HaveCount(0);
finalDatabaseState.Tasks.Should().HaveCount(0);
finalDatabaseState.TimeEntries.Should().HaveCount(0);
}
public void ApplyServerState(ref ServerState serverState)
{
for (int i = 0; i < serverState.PlayerStatesCount; i++)
{
var state = serverState.PlayerStates[i];
if (!_players.TryGetValue(state.Id, out var handler))
{
return;
}
if (handler.Player == _clientPlayer)
{
_clientPlayer.ReceiveServerState(serverState, state);
}
else
{
var rp = (RemotePlayer)handler.Player;
rp.OnPlayerState(state);
}
}
}
public virtual void ChangeSiteState(string siteId, ServerState state)
{
ManagementObject objSite = wmi.GetObject(String.Format("IIsFtpServer='{0}'", siteId));
string methodName = "Continue";
switch (state)
{
case ServerState.Started: methodName = "Start"; break;
case ServerState.Stopped: methodName = "Stop"; break;
case ServerState.Paused: methodName = "Pause"; break;
case ServerState.Continuing: methodName = "Continue"; break;
default: methodName = "Start"; break;
}
// invoke method
objSite.InvokeMethod(methodName, null);
}
/// <summary>
/// A dispatch event to be rasied upon reception of an assembly from another Presto server..
/// </summary>
/// <param id="state">The server state object recieved along with this event.</param>
private static void recieveAssemblySlave(ServerState state)
{
//get the slave assembly struct
SerializationEngine serializer = new SerializationEngine();
SlaveAssembly slaveAssembly = (SlaveAssembly)serializer.Deserialize(state.GetDataArray());
//create the domain and add the assembly to it
DomainManager.CreateDomain(slaveAssembly.DomainKey);
if (!DomainManager.DomainHasAssembly(slaveAssembly.DomainKey, slaveAssembly.AssemblyName))
{
DomainManager.LoadAssemblyIntoDomain(slaveAssembly.DomainKey, slaveAssembly.AssemblyImage);
}
Presto.Remote.Node from = Nodes.GetNodeByID(slaveAssembly.NodeID);
if (from != null)
{
from.SetLoadedAssembly(slaveAssembly.AssemblyName);
from.SetLoadedDomain(slaveAssembly.DomainKey);
}
//send back assembly transfer complete message
state.Write(MessageType.ASSEMBLY_TRANSFER_COMPLETE);
}
public void Stop()
{
AssertActive();
Debug.Log("Stopping server...");
UnspawnNetObjects(NetObjectManager.Instance.NetObjects);
foreach (NetworkConnection networkConnection in _connections)
{
networkConnection.Disconnect(_serverDriver);
}
if (_serverDriver.IsCreated)
{
_serverDriver.Dispose();
}
if (_connections.IsCreated)
{
_connections.Dispose();
}
State = ServerState.Stopped;
Stopped?.Invoke();
}
public void StopServer()
{
if (State != ServerState.Working)
{
return;
}
Logger.I.Log(this, "Stopping server");
State = ServerState.Stopping;
_connectionsGroup.GetEntities(_connectionsBuffer);
foreach (var e in _connectionsBuffer)
{
_disconnectData.Enqueue(new DisconnectData {
Peer = e.connectionPeer.Value
});
e.isDestroyed = true;
}
_requests.Enqueue(NetworkThreadRequest.Stop);
}
public ScadaServer(string _name, string _ip, ushort _port, SvcManage svc)
{
state = ServerState.Stoped;
serverName = _name;
server.Address = _ip;
server.Port = _port;
Svc = svc;
//绑定事件
//绑定监听地址前触发
server.OnPrepareListen += new ServerPrepareListenEventHandler(server_OnPrepareListen);
//客户端连接请求被接受后触发
server.OnAccept += new ServerAcceptEventHandler(server_OnAccept);
//发送消息后触发
server.OnSend += new ServerSendEventHandler(server_OnSend);
//收到消息后触发
server.OnReceive += new PullServerReceiveEventHandler(server_OnReceive);
//连接关闭后触发（服务端的连接通常是多个，只要某一个连接关闭了都会触发）
server.OnClose += new ServerCloseEventHandler(server_OnClose);
//组件停止后触发
server.OnShutdown += new ServerShutdownEventHandler(server_OnShutdown);
}
public bool Start(int port)
{
try
{
Socket = new TcpListener(IPAddress.Any, port);
Socket.Start();
}
catch (SocketException se)
{
//address/port occupied
if (se.ErrorCode == 10048)
{
return(false);
}
throw se;
}
Globals.EventManager.AddEvent(UpdateTransfer, "updatetransfer", false, 0, 0, 1);
State = ServerState.Running;
Debug.Write("Server started");
return(true);
}
public void ClientInitialization4ProcessFirstPacketSendTest()
{
BouncyCastleServices clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
BouncyCastleServices serverServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var client = new MicroRatchetContext(clientServices, true);
var server = new MicroRatchetContext(serverServices, false);
var clientInitPacket = client.InitiateInitialization();
var responsePacket = server.Receive(clientInitPacket).ToSendBack;
var firstPacket = client.Receive(responsePacket).ToSendBack;
var firstResponse = server.Receive(firstPacket).ToSendBack;
var cs = client.SaveStateAsByteArray();
var ss = server.SaveStateAsByteArray();
ClientState clientState = ClientState.Load(cs, DefaultKexFactory.Instance);
ServerState serverState = ServerState.Load(ss, DefaultKexFactory.Instance);
Assert.NotNull(firstResponse);
Assert.Equal(2, clientState.Ratchets.Count);
Assert.Equal(1, serverState.Ratchets.Count);
}
/// <summary>
/// Stops receiving the WebSocket connection requests with the specified
/// <see cref="CloseStatusCode"/> and <see cref="string"/>.
/// </summary>
/// <param name="code">
/// One of the <see cref="CloseStatusCode"/> enum values, represents the status code indicating
/// the reason for stop.
/// </param>
/// <param name="reason">
/// A <see cref="string"/> that represents the reason for stop.
/// </param>
public void Stop(CloseStatusCode code, string reason)
{
byte [] data = null;
lock (_sync) {
var msg = _state.CheckIfStart() ??
(data = ((ushort)code).Append(reason)).CheckIfValidControlData("reason");
if (msg != null)
{
_logger.Error(String.Format("{0}\nstate: {1}\nreason: {2}", msg, _state, reason));
return;
}
_state = ServerState.ShuttingDown;
}
stopListener(5000);
_services.Stop(data, !code.IsReserved());
_state = ServerState.Stop;
}
/// <summary>
/// 启动服务器，使其正在侦听传入的连接请求
/// </summary>
/// <param name="localEndPoint">侦听的网络端点</param>
public void Start(IPEndPoint localEndPoint)
{
try
{
//创建侦听传入连接的socket
m_listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
m_listenSocket.Bind(localEndPoint);
//限定100个监听压力
m_listenSocket.Listen(100);
StartAccept(null);
m_heartthread = new Thread(ServerHeart);
m_heartthread.IsBackground = true;
m_heartthread.Start();
}
catch (Exception e)
{
ServerState?.Invoke(HCServerStateEnmu.Failed, e.Message);
}
}
public static void changeState(ServerState aState, string caller, string reason = "Not Specified")
{
string format = "StateChange requested by {0} to {1}: {2}";
switch (aState)
{
case ServerState.Crashed:
logWarn(string.Format(format, caller, aState, reason));
break;
case ServerState.GracefulShutdown:
logWarn(string.Format(format, caller, aState, reason));
break;
default:
logDebug("StarryboundServer::changeState", string.Format(format, caller, aState, reason));
break;
}
aServerState = aState;
}
public void Init()
{
this.m_bufferManager.InitBuffer();
DuplexSocketAsyncEventArgsWithId _readWirted;
for (int i = 0; i < this.m_numConcurrence; i++)
{
_readWirted = new DuplexSocketAsyncEventArgsWithId();
//_readWirted.State = true;
_readWirted.ReceiveSAEA.Completed += OnCompleted;
_readWirted.SendSAEA.Completed += OnCompleted;
_readWirted.ReceiveSAEA.UserToken = new AsyncUserToken(null);
_readWirted.SendSAEA.UserToken = new AsyncUserToken(null);
//只给接收的SocketAsyncEventArgs设置缓冲区
this.m_bufferManager.SetBuffer(_readWirted.ReceiveSAEA);
this.m_readWritePool.Push(_readWirted);
}
m_serverState = ServerState.Inited;
}
/// <summary>
/// Starts receiving the HTTP requests.
/// </summary>
public void Start ()
{
lock (_sync)
{
var msg = _state.CheckIfAvailable (true, false, false)
#if !NETCF || BCC || SSL
?? checkIfCertificateExists ()
#endif
;
if (msg != null)
{
_logger.Error (msg);
return;
}
_services.Start ();
startReceiving ();
_state = ServerState.Start;
}
}
internal void Stop(CloseEventArgs e, byte[] frameAsBytes, TimeSpan timeout)
{
lock (_sync) {
_state = ServerState.ShuttingDown;
_sweepTimer.Enabled = false;
foreach (var session in _sessions.Values.ToList ())
session.Context.WebSocket.Close (e, frameAsBytes, timeout);
_state = ServerState.Stop;
}
}
private void BindSiteState(ServerState state)
{
if (state == ServerState.Continuing)
state = ServerState.Started;
litStatus.Text = GetLocalizedString("SiteState." + state.ToString());
cmdStart.Visible = (state == ServerState.Stopped);
cmdContinue.Visible = (state == ServerState.Paused);
cmdPause.Visible = (state == ServerState.Started);
cmdStop.Visible = (state == ServerState.Started || state == ServerState.Paused);
}
internal void Start()
{
lock (_sync) {
_sweepTimer.Enabled = _clean;
_state = ServerState.Start;
}
}
private void HandleMenuStartServer(object sender, RoutedEventArgs e)
{
loggedOnUsers = new List<string>();
serverState = ServerState.RUNNING;
requestResponseThread.Start();
serverMiniCheckers.UpdateMenuState(serverState);
updateRequestResponse("Server started");
updateRequestResponse("Current GameState: " + gameState);
Debug.WriteLine("Server Starting");
}
