static void Main(string[] args)
{
log.Debug("--> Main");
SocketListener listener = new SocketListener();
IMessageFactory factory = new MessageFactoryFIX(ConfigurationManager.AppSettings["BeginString"]);
//IMessageFactory factory = new FIX_4_2.MessageFactoryFIX();
_factory = factory;
IEngine engine = new SocketEngine();
engine.MessageCacheFactory = new MessageCacheFlatFileFactory();
engine.MessageFactory = factory;
engine.Initialize(
ConfigurationManager.AppSettings["SenderCompID"], null,
ConfigurationManager.AppSettings["TargetCompID"], null);
engine.Received += new MessageEventHandler(engine_Received);
engine.Sent += new MessageEventHandler(engine_Sent);
listener.Add(engine);
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
listener.Init(port);
Console.WriteLine("press <Enter> to exit...");
Console.ReadLine();
listener.Dispose();
engine.Dispose();
log.Debug("<-- Main");
}
void Awake()
{
instance = this;
controllers = new Dictionary <byte, ControllerBase>();
peer = new ClientPeer(this);
peer.Connect("192.168.1.20", "26680");
}
public void RegisterToSockEngine(SocketEngine sockEngine)
{
if (sockEngine != null)
{
sockEngine.Socket_OnException = Sock_OnException;
sockEngine.Socket_OnReceive = Sock_OnReceive;
sockEngine.Socket_CommException = Sock_OnCommonExcption;
}
}
/********************************************************************************************
* Method: private void btnPort_CLick(object sender, EventArgs e)
* Purpose: Will start listening for the socket connections and call the listener socket from the
* class-Socket Engine dll.
* Parameters: object sender,EventArgs e
* Returns: nothing
* //*********************************************************************************************/
private void buttonPort_Click(object sender, EventArgs e)
{
if (int.TryParse(tbPort.Text, out portNumber))
{
portNumber = int.Parse(tbPort.Text);
PortNum = portNumber;
}
SocketEngine.CreateListenerSocket(PortNum, new SocketEngine.delVoidStringBool(TransferToError),
new SocketEngine.delVoidSocket(TransferToConnectionErrors));
tbMessages.Text = "Started Listening to the Socket Connections";
// btnListen.Enabled = false;
}
public FrmMain()
{
InitializeComponent();
_socketEngine = new SocketEngine();
_socketEngine.CbException += HandleException;
_socketEngine.ConnectionBuilt += _socketEngine_ConnectionBuilt;
ProxySocket.InitRules();
LogHelper.CbRecordPacket += LogPacket;
LogHelper.CbLog += LogHelper_CbLog;
DataManagers.Init();
//ThreadPool.SetMaxThreads(MAX_SOCKET_SERVER_COUNT, MAX_SOCKET_SERVER_COUNT * 3);
}
/// <summary>
/// 依赖的网络层
/// </summary>
public EventCenter(HttpThread httpEngine, SocketEngine sockEngine, EntityManager entityMgr)
{
exchange = new Dictionary <MsgType, Action <BaseTaskAbstract> >();
this.httpEngine = httpEngine;
this.sockEngine = sockEngine;
this.entityMgr = entityMgr;
if (httpEngine != null)
{
httpEngine.Http_OnException = Http_OnException;
httpEngine.Http_OnReceive = Http_OnReceive;
}
if (sockEngine != null)
{
sockEngine.Socket_OnException = Sock_OnException;
sockEngine.Socket_OnReceive = Sock_OnReceive;
sockEngine.Socket_CommException = Sock_OnCommonExcption;
}
}
//********************************************************************************************
//Method: private void ConnectionSucceeded(Socket connection)
//Purpose: Creating the connected sockets which uses
//Parameters: Socket connection -connected socket to the client from server
//Returns: nothing
//*********************************************************************************************
private void ConnectionSucceeded(Socket connection)
{
connectedSocket = new SocketEngine(connection, new SocketEngine.delVoidStringBool(TransferToError),
new SocketEngine.delVoidObj(TransferToProcessObject),
new SocketEngine.delVoidSocket(ErrorList));
listClients.Add(connectedSocket);
//Display appropriate message depending on how many connections exist
if (listClients.Count == 1)
{
tbMessages.Text = "Connected to # " + listClients.Count + " client!";
}
else
{
tbMessages.Text = "Connected to- #" + listClients.Count + " clients!";
}
buttonPort.Enabled = false;
}
public void TestFixtureSetUp()
{
engineListen = new SocketEngine();
engineListen.MessageCacheFactory = new MessageCacheFlatFileFactory();
engineListen.MessageFactory = factory;
engineListen.AllowOfflineSend = true;
engineListen.Initialize("LISTEN", "CONNECT");
engineListen.Received += new MessageEventHandler(engineListen_Received);
engineListen.Sent += new MessageEventHandler(engineListen_Sent);
listener = new SocketListener();
listener.Add(engineListen);
listener.Init(9050);
engineConnect = new SocketEngine();
engineConnect.MessageCacheFactory = new MessageCacheFlatFileFactory();
engineConnect.MessageFactory = factory;
engineConnect.AllowOfflineSend = true;
engineConnect.Initialize("CONNECT", "LISTEN");
engineConnect.Received += new MessageEventHandler(engineConnect_Received);
engineConnect.Sent += new MessageEventHandler(engineConnect_Sent);
}
public GameSocket(Socket remoteSocket) : base()
{
_remoteSocket = remoteSocket;
ThreadPool.QueueUserWorkItem(e =>
{
while (Connected)
{
try
{
var data = new byte[1024];
var read = _remoteSocket.Receive(data);
if (read > 0)
{
if (read < data.Length)
{
var tmp = new byte[read];
Array.Copy(data, tmp, tmp.Length);
ReceivePacket(tmp);
}
else
{
ReceivePacket(data);
}
}
else
{
break;
}
}
catch (Exception)
{
break;
}
}
SocketEngine.StopSocket(SocketId);
});
}
public static SocketEngine getInstance()
{
return(_engine ?? (_engine = new SocketEngine()));
}
public NetworkEngine()
{
httpEngine = HttpThread.getInstance();
SockEngine = SocketEngine.getInstance();
}
public ProxySocket(int socketId, Socket localSocket, Socket remoteSocket)
{
SocketId = socketId;
_processes = new List <IProcesser>
{
new ItemProcesser(this),
new SignProcesser(this),
new LotteryProcesser(this),
new PlayerProcesser(this),
new WoodManProcesser(this),
new PetProcesser(this),
new PkProcesser(this)
};
PlayerInfo = new PlayerInfo(this);
WoodManInfo = new WoodManInfo(this);
LocalSocket = localSocket;
RemoteSocket = remoteSocket;
ThreadPool.QueueUserWorkItem(e =>
{
while (Connected)
{
// if (!_isReceive)
// {
// Thread.Sleep(50);
// continue;
// }
try
{
var data = new byte[1024];
var read = LocalSocket.Receive(data);
if (read > 0)
{
DirectSendPacket(ToBuffer(data, read));
}
else
{
break;
}
}
catch (Exception ex)
{
if (ex is SocketException)
{
}
else
{
LogHelper.SilentLog(ex);
}
break;
}
}
SocketEngine.StopSocket(SocketId);
});
ThreadPool.QueueUserWorkItem(e =>
{
while (Connected)
{
try
{
var data = new byte[1024];
var read = RemoteSocket.Receive(data);
if (read > 0)
{
if (read < data.Length)
{
var tmp = new byte[read];
Array.Copy(data, tmp, tmp.Length);
ReceivePacket(tmp);
}
else
{
ReceivePacket(data);
}
}
else
{
break;
}
}
catch (Exception ex)
{
if (ex is SocketException)
{
}
else
{
LogHelper.SilentLog(ex);
}
break;
}
}
SocketEngine.StopSocket(SocketId);
});
}
static void Main(string[] args)
{
log.Debug("--> Main");
try
{
SocketLogonArgs logonArgs = new SocketLogonArgs();
logonArgs.IPAddress = IPAddress.Parse(ConfigurationManager.AppSettings["Host"]);
logonArgs.Port = int.Parse(ConfigurationManager.AppSettings["Port"]);
//set additional logon tags
FIX4NET.FieldCollection fieldsLogon = (FIX4NET.FieldCollection)ConfigurationManager.GetSection("fixLogonFieldsSection");
if (fieldsLogon != null)
{
foreach (IField field in fieldsLogon)
{
logonArgs.AddField(field);
}
}
MessageFactoryFIX factory = new MessageFactoryFIX(ConfigurationManager.AppSettings["BeginString"]);
//IMessageFactory factory = new FIX_4_4.MessageFactoryFIX();
//IMessageFactory factory = new FIX_4_2.MessageFactoryFIX();
_factory = factory;
//additional tags for factory to append on every message
FIX4NET.FieldCollection fields = (FIX4NET.FieldCollection)ConfigurationManager.GetSection("fixMessageFieldsSection");
if (fields != null)
{
foreach (FIX4NET.IField field in fields)
{
factory.AddField(field);
}
}
//create instance of FIX engine
SocketEngine engine = new SocketEngine();
//set message timeout
string messageTimeout = ConfigurationManager.AppSettings["MessageTimeout"];
if (!string.IsNullOrEmpty(messageTimeout))
{
engine.MessageTimeout = int.Parse(messageTimeout);
}
//initialize FIX engine
_engine = engine;
_engine.MessageCacheFactory = new MessageCacheFlatFileFactory();
_engine.MessageFactory = factory;
_engine.Initialize(
ConfigurationManager.AppSettings["SenderCompID"], ConfigurationManager.AppSettings["SenderSubID"],
ConfigurationManager.AppSettings["TargetCompID"], ConfigurationManager.AppSettings["TargetSubID"]);
_engine.AllowOfflineSend = true;
_engine.Received += new MessageEventHandler(engine_Received);
_engine.Sent += new MessageEventHandler(engine_Sent);
//reset MsgSeqNum(Out)
string resetMsgSeqNumOut = ConfigurationManager.AppSettings["ResetMsgSeqNumOut"];
if (!string.IsNullOrEmpty(resetMsgSeqNumOut))
{
_engine.ResetMsgSeqNumOut(int.Parse(resetMsgSeqNumOut));
}
//reset MsgSeqNum(In)
string resetMsgSeqNumIn = ConfigurationManager.AppSettings["ResetMsgSeqNumIn"];
if (!string.IsNullOrEmpty(resetMsgSeqNumIn))
{
_engine.ResetMsgSeqNumIn(int.Parse(resetMsgSeqNumIn));
}
_engine.Logon(logonArgs);
if (!_engine.IsConnected)
{
throw new Exception("Logong failed");
}
Console.WriteLine("press <Enter> to continue...");
Console.ReadLine();
string sendMessageFromFile = ConfigurationManager.AppSettings["SendMessagesFromFile"];
if (!string.IsNullOrEmpty(sendMessageFromFile))
{
SendMessagesFromFile(sendMessageFromFile);
}
Console.WriteLine("press <Enter> to exit...");
Console.ReadLine();
_engine.Logout("USER LOGOUT REQUESTED");
_engine.Dispose();
}
catch (Exception ex)
{
log.Error("Error running FIX test", ex);
}
log.Debug("<-- Main");
}
