public void Start <T>() where T : class
{
Task.Factory.StartNew(() => {
var tType = typeof(T);
if (!tType.IsInterface || tType.ReflectedType == null)
{
throw new InvalidOperationException(string.Format("{0}不是接口", tType.FullName));
}
var processorTypeName = tType.ReflectedType.FullName + "+Processor";
var processorType = tType.Assembly.GetType(processorTypeName, false);
if (processorType == null)
{
string Info = "没有发现将要向外公开的服务接口,请确保您用的是Thrift生成的服务接口";
throw new InvalidOperationException(string.Format(Info, new object[0]));
}
TServerSocket socket = new TServerSocket(_serverEndPointConfig.Port, ClientTimeoutDefault, false);
TProcessor processor = (TProcessor)ContainerSingleton.Instance.Resolve(processorType);
_server = new TThreadedServer(processor, socket,
new TTransportFactory(),
new TTransportFactory(),
new TCompactProtocol.Factory(),
new TCompactProtocol.Factory(),
MaxThreadsDefault,
new TServer.LogDelegate((str) => {
//写日志。。。。
}));
try
{
_server.Serve();
}
finally
{
}
});
}
public UrlConfiguration(TServer ServerName, string Environment, TService ServiceType, string Url)
{
this.ServerName = ServerName;
this.Environment = Environment;
this.ServiceType = ServiceType;
this.Url = Url;
}
private void InitTransportService()
{
ServiceHandler _serviceHandler = new ServiceHandler();
_serviceHandler._login = _business.Login;
_serviceHandler._logout = _business.Logout;
_serviceHandler._loadCustomers = _business.LoadCustomer;
_serviceHandler._loadOrderItems = _business.LoadOrderItem;
_serviceHandler._loadRegularOrders = _business.LoadRegularOrder;
_serviceHandler._loadIrregularOrders = _business.LoadIrregularOrder;
_serviceHandler._loadSystemConfig = _business.LoadSystemConfig;
_serviceHandler._loadTickets = _business.LoadTicket;
_serviceHandler._createOrder = _business.CreateOrder;
_serviceHandler._deleteOrder = _business.DeleteOrder;
_serviceHandler._updateOrderInfo = _business.UpdateOrderInfo;
_serviceHandler._updateSingleOrderInfo = _business.UpdateSingleOrderInfo;
_serviceHandler._updateTicket = _business.UpdateTicket;
_serviceHandler._insertTicket = _business.InsertTicket;
_serviceHandler._cancelTicket = _business.CancelTicket;
_serviceHandler._syncIrregularOrders = _business.SyncIrregularOrder;
_serviceHandler._syncOrderItems = _business.SyncOrderItem;
_serviceHandler._syncRegularOrders = _business.SyncRegularOrder;
_serviceHandler._syncTickets = _business.SyncTicket;
TransportServer.Processor serverProcessor = new TransportServer.Processor(_serviceHandler);
IPAddress ip = IPAddress.Parse(_serverIP);
TcpListener listener = new TcpListener(ip, _serverPort);
TServerTransport transport = new TServerSocket(listener);
_server = new TThreadPoolServer(serverProcessor, transport);
_server.Serve();
}
public MainPage()
{
this.InitializeComponent();
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
logger = new Logger(ServerLogTime);
server = new TServer(Guid.NewGuid(), "Server Name", logger);
client = new TClient(Guid.NewGuid(), "Client Name", logger);
serverManager = new TServerProfileManager(server);
clientManager = new TClientProfileManager(client);
server.NetworkNotAvailable += event_NetworkNotAvailable;
client.ConnectionTimeout += client_ConnectionTimeout;
serverManager.ConnectedFolder.New += ServerConnectedFolder_New;
serverManager.ConnectedFolder.Delete += ServerConnectedFolder_Delete;
clientManager.ConnectedFolder.New += ClientConnectedFolder_New;
clientManager.ConnectedFolder.Delete += ClientConnectedFolder_Delete;
clientManager.AvailableFolder.New += AvailableFolder_New;
clientManager.AvailableFolder.Updated += AvailableFolder_Updated;
SocketReset();
}
public void default_newrelic_config_Correct()
{
var expected = new XmlDocument();
expected.Load(string.Format(@"{0}\newrelic.config", TestContext.CurrentContext.TestDirectory));
var actual = TServer.LoadXmlFile(string.Format("{0}default_newrelic.config", TServer.InstallPath));
Assert.AreEqual(expected.InnerXml, actual.InnerXml);
}
public static void Start()
{
ThriftConfig tc = ThriftConfig.CreateInstance();
TServerSocket serverTransport = new TServerSocket(tc.Port, 0, true);
BrokerCenter.Processor processor = new BrokerCenter.Processor(new BusinessImpl());
_server = new TThreadedServer(processor, serverTransport,Log.Log.ConsoleWriteLine,200);
new Thread(_server.Serve) { IsBackground = true }.Start();//开启业务服务
State = true;
}
internal SimpleServer(int port)
{
TSampleService.Iface remoteService = new SampleService(port);
TServerTransport transport = new TServerSocket(port);
var processor = new TSampleService.Processor(remoteService);
server = new TSimpleServer(processor, transport);
}
public void WAS_Environment()
{
var registryValues = new List <string>(TServer.GetRegistryKeyValue(RegistryHive.LocalMachine, @"SYSTEM\CurrentControlSet\Services\WAS", "Environment") as string[]);
Assert.NotNull(registryValues);
Assert.IsTrue(registryValues.Contains(CorEnableProfile), CorEnableProfile);
Assert.IsTrue(registryValues.Contains(CorProfiler), CorProfiler);
Assert.IsTrue(registryValues.Contains(NewRelicInstallPath), NewRelicInstallPath);
Assert.IsTrue(registryValues.Contains(CoreCorProfiler), CoreCorProfiler);
Assert.IsTrue(registryValues.Contains(CoreNewRelicHomePath), CoreNewRelicHomePath);
}
public PElementHostedService()
{
var protoFactory = new TBinaryProtocol.Factory();
var transFactory = new TBufferedTransport.Factory();
var handler = new PElementServiceImplementation();
var processor = new PElementService.AsyncProcessor(handler);
var transport = new TServerSocketTransport(5550, new TConfiguration());
server = new TThreadPoolAsyncServer(processor, transport, transFactory, protoFactory);
}
/// <summary>
/// Returns an appropriate class that implements IDataUtils based on the passed in Sql type
/// </summary>
public static IDataUtils GetInstance(Logger logger, TServer server, SqlFlavor flavor)
{
switch (flavor) {
case SqlFlavor.MSSQL:
return new MSSQLDataUtils(logger, server);
case SqlFlavor.Netezza:
return new NetezzaDataUtils(logger, server);
}
//if we get here without returning it means something was passed in that isn't supported
throw new NotImplementedException("Specified SQL types not supported for data copying!");
}
public TProcessor GetProcessor(TTransport trans, TServer server = null)
{
if (trans.IsOpen)
{
HelloWorldBidirectionServer.TransportCollection.Add(trans);
Console.WriteLine("有客户端上船啦");
}
HelloWorldBidirectionServer srv = new HelloWorldBidirectionServer();
return(new global::HelloWorldBidirectionService.Processor(srv));
}
public TProcessor GetProcessor(TTransport trans, TServer server = null)
{
H handler = (H)Activator.CreateInstance(typeof(H), handlerArgs);
TControllingHandler handlerServerRef = handler as TControllingHandler;
if (handlerServerRef != null)
{
handlerServerRef.server = server;
}
return(Activator.CreateInstance(typeof(P), new object[] { handler }) as TProcessor);
}
public void StartRpc(string host, int port)
{
var Service = new ServerImpl(ServiceProvider);
tConnect.Processor processor = new tConnect.Processor(Service);
TServerTransport transport = new TServerSocket(port);
server = new TThreadPoolServer(processor, transport);
System.Threading.Tasks.Task.Run(() => {
server.Serve();
});
}
public void Start()
{
if (_server != null)
{
throw new InvalidOperationException("Cannot start server that has already been started");
}
WPWithinCallback.Processor processor = new WPWithinCallback.Processor(this);
TServerTransport serverTransport = _config.GetThriftServerTransport();
TServer server = new TThreadPoolServer(processor, serverTransport);
Log.InfoFormat("Starting callback server on {0}", _config.ServiceHost);
_serverTask = Task.Run(() => server.Serve());
_server = server;
}
private static string GetURL(TServer ServerName, string Environment, TService ServiceType)
{
CreateUrlTable();
var urlConfig = urlsTable.FirstOrDefault(p => p.Environment == Environment &&
p.ServerName == ServerName &&
p.ServiceType == ServiceType);
if (urlConfig == null)
{
throw new Exception("Url não foi definida.");
}
return(urlConfig.Url);
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
if (_server != null)
{
_server.Stop();
_server = null;
}
}
_disposed = true;
}
}
public CallbackService(Salon handlerSalon, Salon handlerChat, Salon handlerPresentacion)
{
ProcessorSalon = new SalonDeClasesCallback.Processor(handlerSalon);
ProcessorChat = new ChatCallback.Processor(handlerChat);
ProcessorPresentacion = new PresentacionCallback.Processor(handlerPresentacion);
Processor = new TMultiplexedProcessor();
Processor.RegisterProcessor(nameof(SalonDeClasesCallback), ProcessorSalon);
Processor.RegisterProcessor(nameof(ChatCallback), ProcessorChat);
Processor.RegisterProcessor(nameof(PresentacionCallback), ProcessorPresentacion);
Transporte = new TServerSocket(9091);
Servidor = new TThreadPoolServer(Processor, Transporte);
//servidor.Serve();
}
public void startingSimpleServer()
{
Debug.Log("Try to start Receiver SimpleServer on " + getHost() + " - " + getPort());
try {
serverTransport = new TServerSocket(getPort());
server = new TSimpleServer(processor, serverTransport);
// Use this for a multithreaded server
// TServer server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport).processor(processor));
Debug.Log("Starting the simple server...");
setConnected(true);
server.Serve();
} catch (Exception e) {
Debug.LogError(e);
}
}
// main entry creates and launches the server
static void Main(string[] args)
{
Console.WriteLine("Andl Thrift Server");
Logger.Open(0); // no default logging
var options = OptionParser.Create(_options, Help);
if (!options.Parse(args))
{
return;
}
GatewayBase gateway = null;
try {
gateway = AppStartup(options.GetPath(0), _settings);
Processor processor = new Processor(gateway);
TServerTransport serverTransport = new TServerSocket(ServerPort);
// There are several different servers available. They should all work.
Server = new TThreadPoolServer(processor, serverTransport);
//TServer server = new TThreadPoolServer(processor, serverTransport);
//TServer server = new TThreadPoolServer(processor, serverTransport, new TTransportFactory(), new TCompactProtocol.Factory());
//TServer server = new TThreadedServer(processor, serverTransport);
//TServer server = new TSimpleServer(processor, serverTransport);
Server.setEventHandler(new ServerEventHandler());
gateway.OpenSession();
Console.WriteLine($"Starting server...database '{gateway.DatabaseName}' {gateway.DatabaseKind}");
Server.Serve();
gateway.CloseSession(true);
} catch (ProgramException ex) {
Console.WriteLine(ex.ToString());
if (gateway != null)
{
gateway.CloseSession(false);
}
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
if (gateway != null)
{
gateway.CloseSession(false);
}
}
Console.WriteLine("done.");
}
public void Run()
{
var processor = new RendererService.RendererService.Processor(handler);
transport = new TServerSocket(port);
server = new TThreadPoolServer(processor, transport);
serverThread = new Thread(() => {
Debug.Log("Starting Renderer-Service...");
server.Serve();
transport.Close();
})
{
IsBackground = true
};
serverThread.Start();
}
private void btnOpen_Click(object sender, EventArgs e)
{
int port;
if (!Int32.TryParse(comboBox1.Text, out port))
{
return;
}
if (tcpServer == null)
{
tcpServer = new TServer(GetCommandArrived);
}
tcpServer.ServerStartListen(MyIP, port);
comboBox1.Enabled = false;
IsCalc = false;
}
public static void Start()
{
TServerSocket serverTransport = new TServerSocket(Anno.Const.SettingService.Local.Port, 0, true);
BrokerService.Processor processor = new BrokerService.Processor(new BusinessImpl());
int maxThreads = Const.SettingService.MaxThreads;
if (maxThreads <= 0)
{
maxThreads = 200;
}
_server = new TThreadedServer(processor, serverTransport, Log.Log.ConsoleWriteLine, maxThreads);
new Thread(_server.Serve)
{
IsBackground = true
}.Start(); //开启业务服务
State = true;
}
private void btn_start_Click(object sender, EventArgs e)
{
if (tB_myport.Enabled == false)
{
if (rB_tcp.Checked)
{
if (tServer == null)
{
tServer = new TServer(TcpGetDataArrived);
}
tServer.ServerStartListen(comboBox1.Text, Convert.ToInt16(tB_myport.Text));
btn_start.Enabled = false;
btn_close.Enabled = true;
gB_mode.Enabled = false;
btn_check.Enabled = false;
//textBox1.Enabled = true;
}
else if (rB_udp.Checked)
{
if (uServer == null)
{
uServer = new UDPService(UdpGetDataArrived);
}
uServer.PrepareClient(Convert.ToInt16(tB_myport.Text));
btn_start.Enabled = false;
btn_close.Enabled = true;
gB_mode.Enabled = false;
btn_check.Enabled = false;
//textBox1.Enabled = true;
}
else
{
MessageBox.Show("Please Select Mode.");
}
}
else if (tB_myport.Enabled == true)
{
MessageBox.Show("Please Select Port.");
}
}
/// <summary>
/// Returns an appropriate class that implements IDataUtils based on the passed in Sql type
/// </summary>
public static IDataUtils GetInstance(Logger logger, TServer server, SqlFlavor flavor)
{
switch (flavor)
{
case SqlFlavor.MSSQL:
return(new MSSQLDataUtils(logger, server));
case SqlFlavor.Netezza:
return(new NetezzaDataUtils(logger, server));
case SqlFlavor.MySQL:
return(new MySQLDataUtils(logger, server));
case SqlFlavor.Vertica:
return(new VerticaDataUtils(logger, server));
}
//if we get here without returning it means something was passed in that isn't supported
throw new NotImplementedException("Specified SQL types not supported for data copying!");
}
public void AgentEnabledTrue_ILLoaded()
{
var installTestApp = new TestApplication(application: Applications.DotNet_Functional_InstallTestApp);
TServer.IISCommand("Stop");
TServer.PurgeAgentLogs();
TServer.ModifyOrCreateXmlAttribute("//x:configuration", "agentEnabled", "true");
TServer.ModInstallAppWebConfigXML(agentEnabled: true);
// Start the service, wait for logging to occur
TServer.IISCommand("Start");
installTestApp.SimpleTestRequest(resource: "service/start");
installTestApp.WaitForLog(TestApplication.LogEntry.fullyConnected);
// Verify the 'NewRelic.Profiler' is loaded, stop the service
Assert.IsTrue(Common.FileLoadedInProcess(TServer.MgmtScope, "NewRelic.Profiler", "w3wp.exe"));
TServer.IISCommand("Stop");
}
public static void StartSocket(int nPort, Action <string> debugAction)
{
try
{
CalculatorHandler handler = new CalculatorHandler();
SendLog.Processor processor = new SendLog.Processor(handler);
TServerTransport serverTransport = new TServerSocket(nPort);
server = new TSimpleServer(processor, serverTransport);
debugAction("开始监听端口：" + nPort);
server.Serve();
}
catch (Exception x)
{
debugAction(x.StackTrace);
}
debugAction("停止监听, port:" + nPort);
}
public void NewRelicAgentEnabledFalse_ProfilerNotLoaded()
{
var installTestApp = new TestApplication(application: Applications.DotNet_Functional_InstallTestApp);
TServer.IISCommand("Stop");
TServer.PurgeAgentLogs();
TServer.ModifyOrCreateXmlAttribute("//x:configuration", "agentEnabled", "false");
TServer.ModInstallAppWebConfigXML(agentEnabled: true);
// Start the service, let run for 5 seconds
TServer.IISCommand("Start");
installTestApp.SimpleTestRequest(resource: "service/start");
Thread.Sleep(5000);
// Verify the 'NewRelic.Profiler' is NOT loaded
Assert.IsFalse(Common.FileLoadedInProcess(TServer.MgmtScope, "NewRelic.Profiler", "w3wp.exe"));
TServer.IISCommand("Stop");
}
public Engine(INetworkServer server,
IPolicyServer policyServer,
TServer thriftServer,
DbLoader dbLoader,
IPlayerSelectorFactory playerSelector,
IPlayersRemoverFactory playersRemoverFactory,
IStrongholdManager strongholdManager,
IBarbarianTribeManager barbarianTribeManager,
IWorld world,
SystemVariablesUpdater systemVariablesUpdater,
IScheduler scheduler,
IDbManager dbManager,
StrongholdActivationChecker strongholdActivationChecker,
StrongholdChecker strongholdChecker,
BarbarianTribeChecker barbarianTribeChecker,
ICityChannel cityChannel,
IStrongholdManagerLogger strongholdManagerLogger,
StoreSync storeSync,
IQueueListener queueListener,
MapDataExport mapDataExport)
{
this.server = server;
this.policyServer = policyServer;
this.thriftServer = thriftServer;
this.dbLoader = dbLoader;
this.playerSelector = playerSelector;
this.playersRemoverFactory = playersRemoverFactory;
this.strongholdManager = strongholdManager;
this.barbarianTribeManager = barbarianTribeManager;
this.world = world;
this.systemVariablesUpdater = systemVariablesUpdater;
this.scheduler = scheduler;
this.dbManager = dbManager;
this.strongholdActivationChecker = strongholdActivationChecker;
this.strongholdChecker = strongholdChecker;
this.barbarianTribeChecker = barbarianTribeChecker;
this.cityChannel = cityChannel;
this.strongholdManagerLogger = strongholdManagerLogger;
this.storeSync = storeSync;
this.queueListener = queueListener;
this.mapDataExport = mapDataExport;
}
async Task InitializeEngine()
{
server = new TServer();
serverManager = new TServerProfileManager(server, dispatcher);
await server.ResetAsync();
server.NetworkNotAvailable += (o, e) =>
{
var ignore = dispatcher.RunAsync(CoreDispatcherPriority.High, async() =>
{
MessageDialog dialog = new MessageDialog(
"Network is not available. Please connect to a network and then restart the appplication.");
dialog.Commands.Add(new UICommand("Exit application", new UICommandInvokedHandler((c) => {
Application.Current.Exit();
})));
await dialog.ShowAsync();
});
};
}
public void AgentEnabledFalse_NewRelicCoreNotLoaded()
{
var installTestApp = new TestApplication(application: Applications.DotNet_Functional_InstallTestApp);
TServer.IISCommand("Stop");
TServer.PurgeAgentLogs();
TServer.ModifyOrCreateXmlAttribute("//x:configuration", "agentEnabled", "true");
TServer.ModInstallAppWebConfigXML(agentEnabled: false);
// Start the service, let run for 5 seconds
TServer.IISCommand("Start");
installTestApp.SimpleTestRequest(resource: "service/start");
Thread.Sleep(5000);
// Verify the 'NewRelic.Core' is NOT loaded
//Web apps load and keep the profiler, agent.core, and extensions in the scenario. Console apps drop everything.
Assert.IsFalse(Common.FileLoadedInProcess(TServer.MgmtScope, "NewRelic.Core", "w3wp.exe"));
TServer.IISCommand("Stop");
}
protected override void OnStart(string[] args)
{
try
{
mTServer = new TServer(null);
mTServer.EventNewConnection += new NewConnectionEventHandler(OnTWSTServerEventNewConnection);
mTServer.StartServer();
base.OnStart(args);
LOG.Info("{Message}", $"RES REQ Service Started, listening on port {mTServer.ServerTcpPort}");
}
catch (Exception ex)
{
LOG.Fatal(ex, "{Message}", "Exception caught.");
}
finally
{
LOG.Trace("EXIT");
}
}
public NetezzaDataUtils(Logger logger, TServer server)
{
this.logger = logger;
this.server = server;
}
/// <summary>
/// Constructor for unit tests that don't need the config or logger elements
/// </summary>
public TestDataUtils(TServer server)
{
this.server = Convert.ToString(server);
testData = new DataSet();
}
/// <summary>
/// Constructor for unit tests that use config and logger elements
/// </summary>
public TestDataUtils(Logger logger, TServer server)
{
this.logger = logger;
this.server = Convert.ToString(server);
testData = new DataSet();
}
protected void HandleUnconnectPong(byte[] _baData, RakNet.SystemAddress _cServerSystemAddress, RakNet.RakNetGUID _cServerGuid)
{
// Create stream
CNetworkStream cStream = new CNetworkStream(_baData);
// Ignore message identifier
cStream.IgnoreBytes(1);
// Read time
uint uiTime = cStream.ReadUInt();
// Read response data
byte[] baOfflinePingResponse = cStream.ReadBytes(cStream.NumUnreadBytes);
// Create server info
TServer tLanServerInfo = new TServer();
tLanServerInfo.sIp = _cServerSystemAddress.ToString();
tLanServerInfo.usPort = _cServerSystemAddress.GetPort();
tLanServerInfo.uiLatency = RakNet.RakNet.GetTimeMS() - uiTime;
tLanServerInfo.cGuid = new RakNet.RakNetGUID(_cServerGuid.g);
// Convert response data to server info
tLanServerInfo.tServerInfo = new CNetworkServer.TServerInfo(baOfflinePingResponse);
uint uiLocalNumberOfAddresses = m_cRnPeer.GetNumberOfAddresses();
string sIpPrefix = _cServerSystemAddress.ToString().Substring(0, _cServerSystemAddress.ToString().IndexOf('.'));
bool bIsLanServer = false;
for (uint i = 0; i < uiLocalNumberOfAddresses; ++ i)
{
string sMyLanIp = m_cRnPeer.GetLocalIP(i);
string sLanIpPrefix = sMyLanIp.Substring(0, sMyLanIp.IndexOf('.'));
if (sLanIpPrefix == sIpPrefix)
{
bIsLanServer = true;
break;
}
}
if (!bIsLanServer)
{
m_aOnlineServers.Add(tLanServerInfo);
}
else
{
m_aLanServers.Add(tLanServerInfo);
}
//Logger.WriteError("Added server ({0}:({1}) lan ({2})", tLanServerInfo.sIp, tLanServerInfo.usPort, bIsLanServer);
// Notify event observers
if (EventFoundServer != null)
{
EventFoundServer(tLanServerInfo);
}
}
