private static void ServerInit()
{
ConsoleHelper.WriteLine("SAEA.Message服务器正在启动...");
MessageServer server = new MessageServer(39654, 100, 100000, 30 * 60 * 1000);
server.OnAccepted += Server_OnAccepted;
server.OnError += Server_OnError;
server.OnDisconnected += Server_OnDisconnected;
server.Start();
Task.Factory.StartNew(() =>
{
while (true)
{
ConsoleHelper.Title = "MessageServer ClientCounts: " + server.ClientCounts;
Thread.Sleep(1000);
}
}, TaskCreationOptions.LongRunning);
ConsoleHelper.WriteLine("SAEA.Message服务器已就绪!");
}
MessagePayload CreateLongPollPayload(MessageServer toListenFor)
{
var payload = new MessagePayload();
payload.SetLongPollRequest(toListenFor);
return payload;
}
private void Init()
{
try
{
DirectoryInfo topDir = Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory);
CommonPars.ScreenTipConfigFilePath = topDir.Parent.FullName + "\\Configuration\\SuperMap.ZS.Config.xml";
XElement root = XElement.Load(CommonPars.ScreenTipConfigFilePath);
CommonPars.ScreenTipName = root.Element("ScreenTipProgremName").Value;
CommonPars.ScreenTipType = (ScreenTipType)Enum.Parse(typeof(ScreenTipType), root.Element("ScreenTipType").Value);
if (CommonPars.ScreenTipType == ScreenTipType.Next)
{
MessageServer server = new MessageServer();
server.StartReceive();
server.OnReceived += Server_OnReceived;
}
string sql = "select * from workspaceserverinfo";
DataSet dt = DbHelperMySQL.GetDataSet(DbHelperMySQL.Conn, CommandType.Text, sql);
if (dt.Tables.Count > 0 && dt.Tables[0].Rows.Count > 0)
{
CommonPars.DataRootDirInServer = dt.Tables[0].Rows[0]["WorkspaceServerPath"].ToString();
CommonPars.OriginalDirInServer = dt.Tables[0].Rows[0]["OriginalDir"].ToString();
}
}
catch (Exception ex)
{
Log.OutputBox(ex);
}
}
public void Go(ServerContext sCtx, ClientContext cCtx)
{
_sCtx = sCtx;
_cCtx = cCtx;
var mr = false;
var server = new MessageServer(sCtx);
sCtx.M.RegisterAsync <HelloRequest>(this, x =>
{
sCtx.M.Send(new HelloResponse(x));
});
cCtx.Messenger.RegisterAsync <HelloResponse>(this, x =>
{
cCtx.Logger.Log(x.Response + " " + x.ClientId);
mr = true;
});
server.Start();
SendAsClient(server, cCtx.Messenger, new HelloRequest());
do
{
Thread.Sleep(1);
} while (!mr);
server.Stop();
}
public bool RecieveMessage(MessageID id, Message message)
{
Message sentMessage = new Message(message.getInt());
MessageServer.SendMessage(MessageID.ERROR_MSG, sentMessage);
return(true);
}
public TcpServer(MessageServer server, IMessenger messenger = null)
{
_server = null;
L = _server?.Context?.MessageServer?.L ?? new NullLogger();
M = messenger ?? _server.Context.MessageServer.M;
_dataProvider = new JsonDataProvider(server);
}
static void Main(string[] args)
{
try
{
TestExecutive currentProgram = new TestExecutive();
MessageServer msgReciever = new MessageServer();
FileServer fileServer = new FileServer();
Console.WriteLine("\n(Main thread)Constructing host to download/upload files");
fileServer.CreateFileServiceHost("http://localhost:4140/ICommService/BasicHttp");
fileServer.open();
Console.WriteLine("\n(Main thread)Constructing host to communicate with client and repository");
msgReciever.CreateMessageServiceHost("http://localhost:8180/ICommService/BasicHttp");
msgReciever.open();
while (true)
{
Console.WriteLine("\n(Main thread)Recieveing message from client...");
Message msg = msgReciever.TryGetMessage("Client", string.Empty);
Console.WriteLine("\n(Main thread)Recieved message from client.");
Thread childTH = new Thread(() => { currentProgram.CLMsgProc(msg, msgReciever); });
childTH.Start();
}
}
catch (Exception except)
{
Console.Write("\n {0}\n\n", except.Message);
}
///////////////////////////////////////////////////////////////////////////////////////////
}
public override void ExecuteMenuCommand()
{
GlobalInputController.LockInput();
switch (MenuAction)
{
case MenuCommand.EXIT_GAME:
Application.Quit();
break;
case MenuCommand.RESUME:
MessageServer.SendMessage(MessageID.PAUSE, new Message(0));
break;
case MenuCommand.CONFIRM:
break;
case MenuCommand.UPDATE_GAME_DATA:
GlobalGameData.playerOneCharacter = currentCharacter;
MessageServer.SendMessage(MessageID.CHARACTER_SELECTED, new Message((uint)PlayerID.PLAYER1));
break;
case MenuCommand.MENU_BACK:
MessageServer.SendMessage(MessageID.MENU_BACK, new Message());
break;
}
}
public override void ExecuteMenuCommand()
{
GlobalInputController.LockInput();
switch (MenuAction)
{
case MenuCommand.EXIT_GAME:
Application.Quit();
break;
case MenuCommand.RESTART:
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex, LoadSceneMode.Single);
break;
case MenuCommand.CHANGE_SCENE:
if (c_itemActiveData.i_nextScene > -1 && c_itemActiveData.i_nextScene < SceneManager.sceneCountInBuildSettings)
{
MessageServer.OnSceneChange();
SceneManager.LoadScene(c_itemActiveData.i_nextScene, LoadSceneMode.Single);
}
break;
case MenuCommand.RESUME:
MessageServer.SendMessage(MessageID.PAUSE, new Message(0));
break;
case MenuCommand.CONFIRM:
break;
}
}
private void InitializeMessageClient()
{
cl_timer = new TimerMessageClient(ref c_stateData);
MessageServer.Subscribe(ref cl_timer, MessageID.PAUSE);
MessageServer.Subscribe(ref cl_timer, MessageID.PLAYER_FINISHED);
MessageServer.Subscribe(ref cl_timer, MessageID.COUNTDOWN_OVER);
}
// Start is called before the first frame update
void Start()
{
InitializeSpriteDisplay();
this.c_messageClient = new InputHelpPromptMessageClient(this);
MessageServer.Subscribe(ref c_messageClient, MessageID.EDIT_DISPLAY_UPDATE);
MessageServer.Subscribe(ref c_messageClient, MessageID.INPUT_TYPE_CHANGED);
}
private static void Main(string[] args)
{
Console.Title = "GFFServer";
ConsoleHelper.WriteLine("正在初始化消息服务器...", ConsoleColor.Green);
messageServer = new MessageServer(count: 100);
messageServer.OnAccepted += Server_OnAccepted;
messageServer.OnError += Server_OnError;
messageServer.OnDisconnected += Server_OnDisconnected;
ConsoleHelper.WriteLine("消息服务器初始化完毕...", ConsoleColor.Green);
ConsoleHelper.WriteLine("正在启动消息服务器...", ConsoleColor.Green);
messageServer.Start();
ConsoleHelper.WriteLine("消息服务器启动完毕...", ConsoleColor.Green);
ConsoleHelper.WriteLine("正在初始化文件服务器...", ConsoleColor.DarkYellow);
var filePort = ServerConfig.Instance().FilePort;
fileServer = new SAEAMvcApplication(port: filePort);
fileServer.SetDefault("File", "Test");
ConsoleHelper.WriteLine("文件服务器初始化完毕...", ConsoleColor.DarkYellow);
ConsoleHelper.WriteLine("正在启动文件服务器...", ConsoleColor.DarkYellow);
fileServer.Start();
ConsoleHelper.WriteLine("文件服务器初始化完毕，http://127.0.0.1:" + filePort + "/...", ConsoleColor.DarkYellow);
ConsoleHelper.WriteLine("点击回车，结束服务");
Console.ReadLine();
}
void FixedUpdate()
{
debugAccessor.DisplayFloat("Speed", c_playerData.f_currentSpeed);
debugAccessor.DisplayState("air state", c_airMachine.GetCurrentState());
if (!c_stateData.b_updateState)
{
return;
}
c_lastFrameData.v_lastFramePosition = c_playerData.v_currentPosition;
c_lastFrameData.q_lastFrameRotation = c_positionData.q_currentModelRotation;
c_lastFrameData.q_lastFrameCoGRotation = c_positionData.q_currentModelRotation * c_positionData.q_centerOfGravityRotation;
UpdateStateMachine();
c_airMachine.Act();
c_accelMachine.Act();
c_turnMachine.Act();
sm_tricking.Act();
sm_trickPhys.Act();
EngineUpdate();
LateEnginePull();
// send normal
MessageServer.SendMessage(MessageID.PLAYER_POSITION_UPDATED, new Message(c_playerData.v_currentPosition, c_playerData.q_currentRotation, c_playerData.f_currentSpeed)); // NOT the model rotation INCLUDE AIR STATE
}
public void StartServer(IPEndPoint socketInfo, int maxRequests = 0)
{
if (IsOnline)
{
_messages.Add(new Tuple <Guid, string>(Guid.Empty, "Cannot Start Server While Online"));
UpdateText();
return;
}
_networkServer = new NetworkServer(socketInfo);
_messageServer = new MessageServer(_networkServer);
_messageServer.Started += ServerOnServerStarted;
_messageServer.Stopped += ServerOnSeverStopped;
_messageServer.ClientConnected += ServerOnClientConnected;
_messageServer.ClientDisconnected += ServerOnClientDisconnected;
_messageServer.ReceivedFrom.Register(NetCode.UserMessage, ServerOnUserMessageReceived);
_messageServer.ReceivedFrom.Register(NetCode.RawMessage, ServerOnUserMessageReceived);
_messageServer.ReceivedFrom.Register(NetCode.UpdateUsername, ServerOnUpdateUserNameReceived);
// _messageServer.SentTo.Register(NetCode.GuidNotification, ServerOnGuidNotifcationSent);
// _messageServer.Sent.Register(NetCode.UpdateUsername, ServerOnUpdateUsernameSent);
if (maxRequests <= 0)
{
_messageServer.Start();
}
else
{
_messageServer.Start(maxRequests);
}
}
/// <summary>
/// Initialises the TCP Server
/// </summary>
/// <param name="port">Port listening to</param>
/// <param name="timeout">Timeout in seconds</param>
protected void InitializeTCPServer(int port, int timeout = 60)
{
_messageServerError = false;
if (!MessageServerActive)
{
return;
}
_messageServer = new MessageServer(Utilities.CheckMinMax(port, 0, 65535));
_messageServer.MessageReceived += _messageServer_MessageReceived;
_messageServer.ClientConnected += _messageServer_ClientConnected;
_messageServer.ClientDisconnected += _messageServer_ClientDisconnected;
_messageServer.OnError += _messageServer_OnError;
_messageServer.Started += _messageServer_Started;
_messageServer.Stopped += _messageServer_Stopped;
_messageServer.AllowClientConnect += _messageServer_AllowClientConnect;
_messageServer.ClientLogin += _messageServer_ClientLogin;
_messageServer.ClientTimeOut = (ushort)Utilities.CheckMinMax(timeout, 5, 180); // 60 second timeout
_messageServer.LoginRequird = MessageServerLogin;
_messageServer.Start();
if (!Classes.ThreadManager.Exists("Service Message Server Manager"))
{
MessageServerManagementThread thread = new MessageServerManagementThread(this);
Classes.ThreadManager.ThreadStart(thread, "Service Message Server Manager",
System.Threading.ThreadPriority.Lowest);
}
}
private void InitializeMessageClient()
{
cl_character = new CharacterMessageClient(ref c_stateData, ref c_entityData, ref c_audioController);
MessageServer.Subscribe(ref cl_character, MessageID.PAUSE);
MessageServer.Subscribe(ref cl_character, MessageID.PLAYER_FINISHED);
MessageServer.Subscribe(ref cl_character, MessageID.COUNTDOWN_OVER);
}
public EndpointAddress Build(string address, MessageServer defaultServer)
{
Contract.Requires(!string.IsNullOrEmpty(address));
Contract.Requires(defaultServer != null);
return new EndpointAddress(GetChannelName(address), GetServer(address, defaultServer));
}
public override void ExecuteMenuCommand()
{
GlobalInputController.LockInput();
switch (MenuAction)
{
case MenuCommand.EXIT_GAME:
Application.Quit();
break;
case MenuCommand.RESTART:
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex, LoadSceneMode.Single);
break;
case MenuCommand.CHANGE_SCENE:
if (c_itemActiveData.i_nextScene > -1)
{
MessageServer.OnSceneChange();
SceneManager.LoadScene(c_itemActiveData.i_nextScene, LoadSceneMode.Single);
}
break;
case MenuCommand.RESUME:
MessageServer.SendMessage(MessageID.PAUSE, new Message(0));
break;
case MenuCommand.MENU_BACK:
MessageServer.SendMessage(MessageID.MENU_BACK, new Message());
break;
case MenuCommand.MENU_FORWARD:
if (ChildMenuController == null)
{
return;
}
MessageServer.SendMessage(MessageID.MENU_FORWARD, new Message(ChildMenuController.GetSuperMenuIndex()));
break;
case MenuCommand.CONFIRM:
break;
case MenuCommand.EDIT_DATA:
if (DataItem == DataTarget.ERROR_TARGET)
{
return;
}
if (ChildEditController == null)
{
return;
}
// open data editor, wait for return
ChildEditController.Activate(DataItem);
MessageServer.SendMessage(MessageID.EDIT_START, new Message());
break;
case MenuCommand.RESET_CONTROLS:
GlobalGameData.SetControlsToDefault(DataItem == DataTarget.CONTROLLER_CONTROLS ? InputType.CONTROLLER_GENERIC : InputType.KEYBOARD_GENERIC);
break;
}
}
public void Track(MessageServer server, AuthenticationSession toTrack)
{
Contract.Requires(toTrack != null);
Contract.Requires(server != null);
if (toTrack.NeverExpires()) return;
ScheduleDecache(server, toTrack);
}
public IEnumerable<MessagePayload> DequeueAll(MessageServer server)
{
Contract.Requires(server != null);
CreateQueueIfNonExistant(server);
return queues[server].DequeueAll();
}
public override void ConfirmDataEdit(DataTarget targetIn)
{
MessageServer.SendMessage(MessageID.EDIT_END, new Message());
GlobalInputController.UpdateAction(InputAction, c_controllerData.k, this.InputType);
GlobalGameData.SetActionSetting(InputAction, c_controllerData.k, this.InputType);
MessageServer.SendMessage(MessageID.EDIT_DISPLAY_UPDATE, new Message((int)c_controllerData.k, (uint)InputAction).withInputType(this.InputType));
Deactivate();
}
private void EnginePush()
{
if (c_countdownData.i_countdownTime == c_countdownData.i_targetTime)
{
MessageServer.SendMessage(MessageID.COUNTDOWN_OVER, new Message());
Destroy(gameObject);
}
}
public AuthenticationSessionCachedChange(MessageServer server, AuthenticationSession session)
{
Contract.Requires(session != null);
Contract.Requires(server != null);
Server = server;
Session = session;
}
// Update is called once per frame
void FixedUpdate()
{
if (GlobalInputController.GetInputAction(ControlAction.PAUSE, KeyValue.PRESSED))
{
Message pauseMessage = new Message((c_data.b_isPaused ? 0 : 1)); // if we want to pause, send 1, otherwise 0
//isPaused = !isPaused;
MessageServer.SendMessage(MessageID.PAUSE, pauseMessage);
}
}
public override void InitializeData()
{
c_controllerData = new EditControllerData();
c_controllerData.b_editorActive = false;
c_controllerData.k = GlobalGameData.GetActionSetting(InputAction, this.InputType);
c_messageClient = new InputEditMessageClient(this);
MessageServer.Subscribe(ref c_messageClient, MessageID.EDIT_SWAP);
MessageServer.Subscribe(ref c_messageClient, MessageID.EDIT_RESET);
}
public JsonDataProvider(MessageServer server)
{
_server = server;
_typeBinder = server.TypeBinder;
_settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
SerializationBinder = _typeBinder
};
}
public override void KeyPressed(KeyPayload payload)
{
base.KeyPressed(payload);
var pid = GetForeground().processId;
if (IsUnityForeground(pid))
{
MessageServer.Send(pid.ToString(), new ToggleObjectStateMessage(settings.State));
}
}
private void Awake()
{
c_messageClient = new CharacterSelectSceneClient(this);
MessageServer.Subscribe(ref c_messageClient, MessageID.CHARACTER_SELECTED);
MessageServer.Subscribe(ref c_messageClient, MessageID.CHARACTER_UNSELECTED);
b_messageRecieved = false;
playersReady = new Dictionary <PlayerID, bool>();
playersReady.Add(PlayerID.PLAYER1, false);
}
public override void KeyPressed(KeyPayload payload)
{
base.KeyPressed(payload);
var pid = GetForeground().processId;
if (IsUnityForeground(pid))
{
MessageServer.Send(pid.ToString(), new ExecuteMenuMessage(settings.Path));
}
}
/// <summary>
/// Stops the message server.
/// </summary>
private void Stop()
{
lock (_objLock) {
if (_messageServer != null)
{
_messageServer.Stop();
}
_messageServer = null;
Log.Info("Stopped GodLesZ.Library.Amf Gateway");
}
}
public override void KeyPressed(KeyPayload payload)
{
base.KeyPressed(payload);
var pid = GetForeground().processId;
if (IsUnityForeground(pid))
{
MessageServer.Send(pid.ToString(), new PasteComponentMessage());
}
}
public void TestMethod1()
{
LogManager.Factory = new Nega.Entlib.LoggerFactoryImpl();
MessageServer server = new MessageServer();
server.Initialize();
Assert.IsTrue(server.IsInitialized);
server.Destroy();
Assert.IsFalse(server.IsInitialized);
}
public override void KeyPressed(KeyPayload payload)
{
base.KeyPressed(payload);
var pid = GetForeground().processId;
if (IsUnityForeground(pid))
{
MessageServer.Send(pid.ToString(), new SelectObjectMessage(settings.Name, settings.Tag));
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// free managed resources
if (_server != null)
{
_server.Dispose();
_server = null;
}
}
}
/// <summary>
/// Stops the message server.
/// </summary>
private void Stop()
{
lock (_objLock)
{
if (_messageServer != null)
{
_messageServer.Stop();
}
_messageServer = null;
Log.Info("Stopped FluorineFx Gateway");
}
}
public ChannelConfiguration(
EndpointAddress address,
MessageServer server,
MessagingConfiguration messagingConfiguration)
{
Contract.Requires(address != EndpointAddress.Empty);
Contract.Requires(server != null);
Contract.Requires(messagingConfiguration != null);
this.address = address;
this.server = server;
this.messagingConfiguration = messagingConfiguration;
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
// 启动服务器
using (MessageServer server = new MessageServer()) {
server.Port = 8088;
server.Start();
Console.WriteLine("Press enter key to exit...");
Console.ReadLine();
server.Stop();
}
}
public MessageServerConfiguration(MessagingConfiguration messagingConfiguration, MessageServer server)
{
Contract.Requires(messagingConfiguration != null);
Contract.Requires(server != null);
this.server = server;
this.messagingConfiguration = messagingConfiguration;
IIocContainer container = IocContainerLocator.Locate();
RegisterNullPersistence(container);
RegisterJsonSerialiser(container);
ConfigureExternalSources(container);
}
void Poll(MessageServer toListenFor)
{
Logger.Debug("Long polling for messages for {0}", toListenFor);
this.requestor.SendPut(
toListenFor.GetUrl(),
requestStream => this.formatter.Serialise(requestStream, CreateLongPollPayload(toListenFor)),
RecieveResponse,
e =>
{
Logger.Info("Cannot long poll server: {0}", e.Message);
StartNextPoll(toListenFor, TimeSpan.FromSeconds(4));
},
() => StartNextPoll(toListenFor));
}
public void Register(MessageServer toRegister)
{
Contract.Requires(toRegister != null);
Register(toRegister.Name);
}
public ServerSession(MessageServer server, AuthenticationSession session)
{
Server = server;
Session = session;
}
public void Build(MessageServer toListenFor)
{
httpServerBuilder
.Build(toListenFor.GetUrl(), BuildMessagingServerHandler())
.Start();
}
public void ListenTo(MessageServer toListenFor)
{
Contract.Requires(toListenFor != null);
StartNextPoll(toListenFor);
}
static void ExpireSession(MessageServer server, AuthenticationSession toTrack)
{
Logger.Debug("Expiring authentication session {0}", toTrack.Id);
Messenger.Send(new AuthenticationSessionExpired {Server = server, Session = toTrack});
}
public void Build(MessageServer toListenFor)
{
Contract.Requires(toListenFor != null);
}
void StartNextPoll(MessageServer toListenFor)
{
this.starter.StartTask(() => Poll(toListenFor));
}
public LongPollRequestHeader(MessageServer server)
{
Server = server;
}
void ReassignServerAddressIfRegistered(MessageServer serverToCheck)
{
if (serverToCheck.IsUnspecified || !ServerIsInRegistry(serverToCheck)) return;
serverToCheck.Address = registry.Lookup(serverToCheck.Name);
}
void StartNextPoll(MessageServer toListenFor, TimeSpan after)
{
this.scheduler.ScheduleTask(after,() => Poll(toListenFor));
}
void ScheduleDecache(MessageServer server, AuthenticationSession toTrack)
{
taskScheduler.ScheduleTask(GetDecacheTime(toTrack), () => ExpireSession(server, toTrack));
}
void CreateQueueIfNonExistant(MessageServer server)
{
if (!queues.ContainsKey(server))
queues[server] = new UniqueBlockingQueue<MessagePayload>(blockingTimeout);
}
public bool Contains(MessageServer toCheck)
{
Contract.Requires(toCheck != null);
return !toCheck.IsUnspecified && servers.ContainsKey(toCheck.Name);
}
public void Build(MessageServer toListenFor)
{
this.longPoller.ListenTo(toListenFor);
}
public void Build(MessageServer toListenFor)
{
container.RegisterInstance(() => messageServerFactory.Create(
new MessageReceiverHandler(messageReceiver),
new DirectChannelMessageReceiverHandler(messageReceiver)));
}
bool ServerIsInRegistry(MessageServer serverToCheck)
{
return registry.Contains(serverToCheck.Name);
}
MessageServer GetServer(string address, MessageServer defaultServer)
{
return AddressHasServerName(address)
? messageServerBuilder.Build(GetServerName(address))
: defaultServer;
}
