public void SetProcessDied()
{
m_eProcessState = PROCESS_STATE.DIED;
m_eServableState = SERVABLE_STATE.INACTIVE;
m_nProcessID = 0;
m_nCurPlayerCount = 0;
}
public void SetProcessStarting(int nProcessID)
{
m_eProcessState = PROCESS_STATE.STARTING;
m_nProcessID = nProcessID;
m_timeLatestStart = DateTime.Now;
ResetEventSignal();
}
//-------------------------------------------------------------------------------------------------
public void SetProcState(int procNo, PROCESS_STATE procState)
{
m_nProcessState = (int)procState;
var b = ConvertIntToByte((int)procState);
Array.Copy(b, 0, curState.ProcessState.processState, procNo * 4, 4);
}
private bool OnGetServerInfoRes(NetCommand command)
{
byte nServerCount;
if (command.ReadByte(out nServerCount) == false)
{
return(false);
}
TRANS_SERVERINFONODE[] arrServerInfo = new TRANS_SERVERINFONODE[nServerCount];
for (int i = 0; i < nServerCount; ++i)
{
if (command.ReadString(out arrServerInfo[i].strServerName) == false)
{
return(false);
}
if (command.ReadByte(out arrServerInfo[i].nProcessState) == false)
{
return(false);
}
if (command.ReadByte(out arrServerInfo[i].nServableState) == false)
{
return(false);
}
if (command.ReadBoolean(out arrServerInfo[i].bRevivable) == false)
{
return(false);
}
if (command.ReadInt32(out arrServerInfo[i].nCurServerPlayerCount) == false)
{
return(false);
}
}
UInt64 nSessionID = command.SessionID;
MachineInfo refMachineInfo = m_refServerMonitorClient.refMachineInfoMgr.Find(nSessionID);
if (null == refMachineInfo)
{
return(false);
}
for (int i = 0; i < nServerCount; ++i)
{
string strServerName = arrServerInfo[i].strServerName;
PROCESS_STATE eProcessState = (PROCESS_STATE)arrServerInfo[i].nProcessState;
SERVABLE_STATE eServableState = (SERVABLE_STATE)arrServerInfo[i].nServableState;
bool bRevivable = arrServerInfo[i].bRevivable;
int nCurServerPlayerCount = arrServerInfo[i].nCurServerPlayerCount;
m_refServerMonitorClient.UpdateServerInfo(refMachineInfo.GetName(), strServerName, eProcessState, eServableState, bRevivable, nCurServerPlayerCount);
}
m_refServerMonitorClient.UpdateMachinePlayerCount(refMachineInfo.GetName());
return(true);
}
internal void setState(int p)
{
idState = p;
this.state = (PROCESS_STATE)p;
if (state == PROCESS_STATE.Open)
stateString = Constants.KP_PROCESS_STATE_OPEN;
else
stateString = Constants.KP_PROCESS_STATE_CLOSE;
}
public void SetProcessTerminated()
{
m_eProcessState = PROCESS_STATE.TERMINATED;
m_eServableState = SERVABLE_STATE.INACTIVE;
m_nProcessID = 0;
m_nCurPlayerCount = 0;
ResetEventSignal();
}
public bool GetProcessState(string strServerName, out PROCESS_STATE eProcessState)
{
eProcessState = PROCESS_STATE.TERMINATED;
ServerInfo serverInfo = Find(strServerName);
if (null == serverInfo)
{
return(false);
}
eProcessState = serverInfo.ProcessState;
return(true);
}
public void UpdateServerInfo(string strMachineName, string strServerName, PROCESS_STATE eProcessState, SERVABLE_STATE eServableState, bool bRevivable, int nCurServerPlayerCount)
{
ServerInfoMgr refServerInfoMgr = m_machineInfoMgr.GetServerInfoMgr(strMachineName);
if (null == refServerInfoMgr)
{
return;
}
ServerInfo refServerInfo = refServerInfoMgr.Find(strServerName);
if (null == refServerInfo)
{
return;
}
refServerInfo.SetProcessState(eProcessState);
refServerInfo.SetServableState(eServableState);
refServerInfo.bRevivable = bRevivable;
refServerInfo.CurPlayerCount = nCurServerPlayerCount;
m_refView.refTreeViewCntroller.SetServerIcon(strMachineName, strServerName, eProcessState, eServableState, bRevivable);
if (refServerInfo.GetServerType() == SERVER_TYPE.SERVER_GAME)
{
m_refView.refTreeViewCntroller.UpdateServerNodeExpansionInfo(strMachineName, strServerName, nCurServerPlayerCount);
}
if (m_refView.refTreeViewCntroller.IsSelectedServerNode() == false)
{
return;
}
string strSelectedMachineName;
string strSelectedServerName;
m_refView.refTreeViewCntroller.GetSelectedMachineName(out strSelectedMachineName);
m_refView.refTreeViewCntroller.GetSelectedServerName(out strSelectedServerName);
if (strSelectedMachineName.Length == 0 ||
strSelectedServerName.Length == 0 ||
strSelectedMachineName.Equals(strMachineName) == false ||
strSelectedServerName.Equals(strServerName) == false)
{
return;
}
UpdateView_SelectedServerInfo(strMachineName, strServerName);
m_refView.UpdateButtonEnableState();
}
public void SetServerIcon(string strMachineName, string strServerName, PROCESS_STATE eProcessState, SERVABLE_STATE eServableState, bool bRevivable)
{
TreeNode tnodeServer = FindServerNode(strMachineName, strServerName);
if (tnodeServer == null)
{
return;
}
NODE_ICON eServerIcon = m_treeIconSelector.GetServerIcon(eProcessState, eServableState, bRevivable);
tnodeServer.ImageIndex = (int)eServerIcon;
tnodeServer.SelectedImageIndex = (int)eServerIcon;
}
private void AnimateTitle(PROCESS_STATE state)
{
switch (state)
{
case PROCESS_STATE.CONNECTING:
this.Text = "Đang kết nối...";
break;
case PROCESS_STATE.LOGIN:
this.Text = "Đang đăng nhập...";
break;
default:
break;
}
}
public NODE_ICON GetServerIcon(PROCESS_STATE eProcessState, SERVABLE_STATE eServableState, bool bRevivable)
{
NODE_ICON eServerIcon = NODE_ICON.ICON_INDEX_NONE;
if (PROCESS_STATE.DIED == eProcessState ||
PROCESS_STATE.NOUPDATE == eProcessState)
{
eServerIcon = NODE_ICON.ICON_INDEX_SERVER_ERROR;
}
else if (PROCESS_STATE.TERMINATING == eProcessState ||
PROCESS_STATE.STARTING == eProcessState)
{
eServerIcon = NODE_ICON.ICON_INDEX_SERVER_PROCESS_CHANGING;
}
else if (PROCESS_STATE.TERMINATED == eProcessState)
{
eServerIcon = NODE_ICON.ICON_INDEX_SERVER_BAD;
}
else if (PROCESS_STATE.RUNNING == eProcessState)
{
if (SERVABLE_STATE.INACTIVE == eServableState)
{
return(NODE_ICON.ICON_INDEX_SERVER_INACTIVE);
}
if (bRevivable)
{
eServerIcon = NODE_ICON.ICON_INDEX_SERVER_FINE;
}
else
{
eServerIcon = NODE_ICON.ICON_INDEX_SERVER_FINE_NOT_REVIVE;
}
}
else if (PROCESS_STATE.STARTING == eProcessState)
{
eServerIcon = NODE_ICON.ICON_INDEX_SERVER_PROCESS_CHANGING;
}
return(eServerIcon);
}
public void Terminate()
{
m_state = PROCESS_STATE.TERMINATED;
}
public void SetProcessNoUpdate()
{
m_eProcessState = PROCESS_STATE.NOUPDATE;
m_eServableState = SERVABLE_STATE.INACTIVE;
}
public PageSetting_Manual_PMC()
{
InitializeComponent();
//Timer 생성
m_UpdateTimer.IsEnabled = false;
m_UpdateTimer.Interval = TimeSpan.FromMilliseconds(100);
m_UpdateTimer.Tick += new EventHandler(fn_tmUpdate);
//Back Color Set
this.Background = UserConst.G_COLOR_PAGEBACK;
ubComm1.Tag = COMMAND.cmdStop;
ubComm2.Tag = COMMAND.cmdCycleStop;
ubComm3.Tag = COMMAND.cmdOrigin;
ubComm4.Tag = COMMAND.cmdModeChange;
ubComm5.Tag = COMMAND.cmdPrepareProc;
ubComm6.Tag = COMMAND.cmdLoadStart;
ubComm7.Tag = COMMAND.cmdUnloadStart;
ubComm8.Tag = COMMAND.cmdAlarm;
ubComm9.Tag = COMMAND.cmdAreYouAlive;
ubComm10.Tag = COMMAND.cmdRunProc;
ubComm11.Tag = COMMAND.cmdVersion;
ubComm12.Tag = COMMAND.cmdCurrentState;
ubComm13.Tag = COMMAND.cmdCurrentData;
ubComm1.Content = COMMAND.cmdStop;
ubComm2.Content = COMMAND.cmdCycleStop;
ubComm3.Content = COMMAND.cmdOrigin;
ubComm4.Content = COMMAND.cmdModeChange;
ubComm5.Content = COMMAND.cmdPrepareProc;
ubComm6.Content = COMMAND.cmdLoadStart;
ubComm7.Content = COMMAND.cmdUnloadStart;
ubComm8.Content = COMMAND.cmdAlarm;
ubComm9.Content = COMMAND.cmdAreYouAlive;
ubComm10.Content = COMMAND.cmdRunProc;
ubComm11.Content = COMMAND.cmdVersion;
ubComm12.Content = COMMAND.cmdCurrentState;
ubComm13.Content = COMMAND.cmdCurrentData;
EN_PORT_ID portId = new EN_PORT_ID();
for (int i = 0; i < Enum.GetNames(typeof(EN_PORT_ID)).Length; i++)
{
cbPortNo.Items.Add(portId++);
}
EN_PORT_ID procId = new EN_PORT_ID();
for (int i = 0; i < Enum.GetNames(typeof(EN_PORT_ID)).Length; i++)
{
cbProcNo.Items.Add(procId++);
}
PORT_STATE temp = new PORT_STATE();
for (int i = 0; i < Enum.GetNames(typeof(PORT_STATE)).Length; i++)
{
cbPortState.Items.Add(temp++);
}
PROCESS_STATE tempProc = new PROCESS_STATE();
for (int i = 0; i < Enum.GetNames(typeof(PROCESS_STATE)).Length; i++)
{
cbProcState.Items.Add(tempProc++);
}
CONTROL_STATE tempCont = new CONTROL_STATE();
for (int i = 0; i < Enum.GetNames(typeof(CONTROL_STATE)).Length; i++)
{
cbContState.Items.Add(tempCont++);
}
}
public void SetProcessTerminating()
{
m_eProcessState = PROCESS_STATE.TERMINATING;
m_eServableState = SERVABLE_STATE.INACTIVE;
m_nCurPlayerCount = 0;
}
public void SetProcessState(PROCESS_STATE eState)
{
m_eProcessState = eState;
}
public void SetProcessRunning()
{
m_eProcessState = PROCESS_STATE.RUNNING;
}
private void fn_SetState(COMM_STATE nComState, CONTROL_STATE nConState, PORT_STATE nPortState, PROCESS_STATE nProcState, ALARM_STATE nAlarmState)
{
stState.CommunicationState = (int)nComState;
stState.ControlState = (int)nConState;
stState.PortState = (int)nPortState;
stState.ProcessState = (int)nProcState;
stState.AlarmState = (int)nAlarmState;
Server.SendPacket.DataClear();
Server.SendPacket.Reply = (int)REPLY.ack_Success;
Server.SendPacket.PushData <State>(stState);
Server.fn_PushSendQueue(Server.SendPacket);
}
static KeyValuePair <List <byte>, StateObject> ReadWrite(long connectionNumber, PROCESS_STATE ps, Socket handler, IAsyncResult ar)
{
KeyValuePair <List <byte>, StateObject> byteState = new KeyValuePair <List <byte>, StateObject>();;
StateObject state = null;
Object thisLock = new Object();
lock (thisLock)
{
switch (ps)
{
case PROCESS_STATE.ACCEPT:
state = new StateObject();
state.buffer = new byte[BUFFER_SIZE];
state.connectionNumber = connectionNumber;
connectionDict.Add(connectionNumber++, new KeyValuePair <List <byte>, StateObject>(new List <byte>(), state));
// Create the state object.
state.workSocket = handler;
byteState = new KeyValuePair <List <byte>, StateObject>(null, state);
break;
case PROCESS_STATE.READ:
//catch when client disconnects
try
{
// Read data from the client socket.
int bytesReads = handler.EndReceive(ar);
if (bytesReads > 0)
{
byteState = connectionDict[connectionNumber];
byteState.Key.AddRange(byteState.Value.buffer.Take(bytesReads).ToArray());
}
//only put one instance of connection number into fifo
if (!fifo.Contains(connectionNumber))
{
fifo.Add(connectionNumber);
}
}
catch (Exception ex)
{
fifo.RemoveAll(x => x == connectionNumber);
connectionDict.Remove(connectionNumber);
byteState = new KeyValuePair <List <byte>, StateObject>();
}
break;
case PROCESS_STATE.PROCESS:
if (fifo.Count > 0)
{
byteState = connectionDict[fifo.First()];
fifo.RemoveAt(0);
byteState.Key.AddRange(byteState.Value.buffer);
}
break;
} // end switch
}
return(byteState);
}
static KeyValuePair <List <byte>, StateObject> ReadWrite(PROCESS_STATE ps, Socket handler, IAsyncResult ar, long unpackConnectionNumber)
{
KeyValuePair <List <byte>, StateObject> byteState = new KeyValuePair <List <byte>, StateObject>();;
StateObject stateObject = null;
int bytesRead = -1;
int workingBufferLen = 0;
List <byte> working_buffer = null;
byte[] buffer = null;
Object thisLock1 = new Object();
lock (thisLock1)
{
switch (ps)
{
case PROCESS_STATE.ACCEPT:
acceptDone.WaitOne();
acceptDone.Reset();
stateObject = new StateObject();
stateObject.buffer = new byte[BUFFER_SIZE];
connectionDict.Add(connectionNumber, new KeyValuePair <List <byte>, StateObject>(new List <byte>(), stateObject));
stateObject.connectionNumber = connectionNumber++;
stateObject.workSocket = handler;
byteState = new KeyValuePair <List <byte>, StateObject>(null, stateObject);
acceptDone.Set();
break;
case PROCESS_STATE.READ:
//catch when client disconnects
//wait if accept is being called
//acceptDone.WaitOne();
try
{
stateObject = ar.AsyncState as StateObject;
// Read data from the client socket.
bytesRead = stateObject.workSocket.EndReceive(ar);
if (bytesRead > 0)
{
byteState = connectionDict[stateObject.connectionNumber];
buffer = new byte[bytesRead];
Array.Copy(byteState.Value.buffer, buffer, bytesRead);
byteState.Key.AddRange(buffer);
}
//only put one instance of connection number into fifo
if (!fifo.Contains(byteState.Value.connectionNumber))
{
fifo.Add(byteState.Value.connectionNumber);
}
}
catch (Exception ex)
{
//will get here if client disconnects
fifo.RemoveAll(x => x == byteState.Value.connectionNumber);
connectionDict.Remove(byteState.Value.connectionNumber);
byteState = new KeyValuePair <List <byte>, StateObject>(new List <byte>(), null);
}
break;
case PROCESS_STATE.PROCESS:
if (fifo.Count > 0)
{
//get message from working buffer
//unpack will later delete message
//remove connection number from fifo
// the list in the key in known as the working buffer
byteState = new KeyValuePair <List <byte>, StateObject>(connectionDict[fifo[0]].Key, connectionDict[fifo[0]].Value);
fifo.RemoveAt(0);
//put a valid value in fifoCount so -1 below can be detected.
byteState.Value.fifoCount = fifo.Count;
}
else
{
//getting here is normal when there is no more work to be performed
//set fifocount to zero so rest of code know fifo was empty so code waits for next receive message
byteState = new KeyValuePair <List <byte>, StateObject>(null, new StateObject()
{
fifoCount = -1
});
}
break;
case PROCESS_STATE.UNPACK:
try
{
working_buffer = connectionDict[unpackConnectionNumber].Key;
workingBufferLen = working_buffer[2];
if ((working_buffer[0] != 0x78) && (working_buffer[1] != 0x78) && (working_buffer[workingBufferLen + 3] != 0x0D) && (working_buffer[workingBufferLen + 4] != 0x0A))
{
working_buffer.Clear();
return(new KeyValuePair <List <byte>, StateObject>(new List <byte>(), null));
}
List <byte> packet = working_buffer.GetRange(0, workingBufferLen + 5);
working_buffer.RemoveRange(0, workingBufferLen + 5);
byteState = new KeyValuePair <List <byte>, StateObject>(packet, null);
}
catch (Exception ex)
{
int testPoint = 0;
}
break;
} // end switch
}
return(byteState);
}
public void Cancel()
{
m_state = PROCESS_STATE.CANCELED;
}
