public static void StartUpTransService()
{
var host = new ServerHost("文件传输");
// 启动登录连接服务线程
ThreadPool.QueueUserWorkItem(new WaitCallback(obj =>
{
while (true)
{
var binding = new NetTcpBinding(SecurityMode.None)
{
Name = "TransferFileBinding",
MaxReceivedMessageSize = 1024 * 1024 * 1024 * 1024L,
TransferMode = TransferMode.Streamed,
};
if (!host.StartService(typeof(DownloadTransmissionService), typeof(IFileTransmissionService),
binding, DownloadTransmissionService.ServicePort, "DownloadTransmissionService"))
{
Thread.Sleep(1000);
continue;
}
TransServerHost = host;
break;
}
}));
}
/// <summary>
/// Event handler for the listen button of the server GUI. When
/// the user selects the listen button of the server, a host
/// channel is created and opened which will be used by the client
/// to communicate with the server. The port number and the server
/// IP address can be entered in the GUI.
/// </summary>
/// <param name="sender">The default sender object for which the callback is
/// associated</param>
/// <param name="e">Platform event object for the button click operation</param>
private void ListenButton1_Click(object sender, RoutedEventArgs e)
{
string localPort1 = RemotePortTextBox1.Text;
string endpoint1 = RemoteAddressTextBox1.Text + localPort1 + "/IBasicService";
try
{
if (localPort1.Equals("") || RemoteAddressTextBox1.Text.Equals(""))
{
throw new Exception("Input URI not proper. Please provide valid URL");
}
String projectLocation = "";
server = new ServerHost();
server.CreateReceiveChannel(endpoint1);
listBox1.Items.Insert(0, "Started.. Waiting for a Client");
ListenButton1.IsEnabled = false;
StopButton.IsEnabled = true;
projectLocation = "The test files directory is " + Directory.GetCurrentDirectory();
listBox1.Items.Insert(1, projectLocation);
BrowseButton.IsEnabled = true;
selectedFolderPath = Directory.GetCurrentDirectory();
UpdateFileContents();
}
catch (Exception ex)
{
Window temp = new Window();
StringBuilder msg = new StringBuilder(ex.Message);
msg.Append("\nport = ");
msg.Append(localPort1.ToString());
temp.Content = msg.ToString();
temp.Height = 100;
temp.Width = 500;
temp.Show();
}
}
public async Task CancelGame(IUser user, bool forceClose = false)
{
if (Status > GameStatus.Cancelled && (user.Id == Hoster?.Id || forceClose))
{
if (Status < GameStatus.GaiaEnding)
{
await(await ServerHost.GetTextChannelsAsync()).First((x) => x.Name == "public_gvg").SendMessageAsync("The game has been cancelled by the host.");
}
Status = GameStatus.Cancelled;
foreach (var mem in GaiaMembers.Concat(GuardianMembers).Concat(OCMembers).Concat(Civilians))
{
try
{
await mem.RemoveRolesAsync(new IRole[] { GvG_Player, GvG_Dead_Player });
} catch (Exception)
{
// do nothing
}
}
GaiaMembers.Clear();
GuardianMembers.Clear();
OCMembers.Clear();
Civilians.Clear();
PhaseTimer?.Change(Timeout.Infinite, Timeout.Infinite);
}
}
void WebSearch()
{
ws = AppSoftware.GetComponent <WebSec>();
sm = AppSoftware.GetComponent <SystemMap>();
testsite = Database.GetComponent <TestSite>();
becas = Database.GetComponent <Becas>();
RevaTest = Database.GetComponent <Test>();
ping = Database.GetComponent <Ping>();
uc = Database.GetComponent <Unicom>();
jd = Database.GetComponent <JailDew>();
LEC = Database.GetComponent <LECBank>();
reva = Database.GetComponent <Reva>();
st = Database.GetComponent <ShareTrades>();
mgw = Minigames.GetComponent <MiniGameWeb>();
tug = Database.GetComponent <TUG>();
sh = Database.GetComponent <ServerHost>();
test1 = Database.GetComponent <Test1>();
gstocks = Database.GetComponent <GStocks>();
hs = Database.GetComponent <HardwareSite>();
//cc = Database.GetComponent<CabbageCorp>();
dr = Minigames.GetComponent <DragRacer>();
ib = AppSoftware.GetComponent <InternetBrowser>();
}
public static void OnStartUpMainService(ServerHost host)
{
// 启动主服务线程
ThreadPool.QueueUserWorkItem(new WaitCallback(obj =>
{
while (IsAppRunning)
{
var binding = new NetTcpBinding(SecurityMode.None);
binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
binding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
binding.OpenTimeout = TimeSpan.MaxValue;
binding.SendTimeout = TimeSpan.MaxValue;
binding.ReceiveTimeout = TimeSpan.MaxValue;
binding.MaxReceivedMessageSize = 1024 * 1024 * 1024;
binding.MaxBufferPoolSize = 1024 * 1024 * 1024;
if (!host.StartService(typeof(MainService), typeof(IMainService), binding, (int)PortID.MainService, "MainService"))
{
Thread.Sleep(1000);
continue;
}
ServerHostMain = host;
break;
}
}));
// 启动登录断连检测线程
UserMgr.StartUserKickingDetectingThread();
}
static void AddODataSupport(ServerHost server)
{
var objectModelBuilder = new ODataConventionModelBuilder();
var bornInfo = objectModelBuilder.ComplexType <BornInfoView>();
bornInfo.Property(bi => bi.When);
bornInfo.Property(bi => bi.Where);
var person = objectModelBuilder.EntitySet <PersonView>("PeopleView")
.EntityType.HasKey(p => p.Id);
person.Property(p => p.Name);
person.Property(p => p.Version);
person.ComplexProperty(p => p.BornInfo);
var address = objectModelBuilder.EntitySet <AddressView>("AddressesView")
.EntityType.HasKey(a => a.AddressId);
address.Property(a => a.Street);
address.Property(a => a.PersonId);
server.AddHttpConfigurationCustomization(cfg =>
{
cfg.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: objectModelBuilder.GetEdmModel()
);
});
}
static void ServerThreadLoop(object mrevent)
{
ManualResetEvent resetEvent = (ManualResetEvent)mrevent;
var host = new ServerHost();
SingleonIPCService.Instance.OnMessageRecieved += IPCService_OnMessageRecieved;
BindingScheme schemes = BindingScheme.NAMED_PIPE;
foreach (var sch in _options.BindingScheme)
{
switch (sch)
{
case 't':
schemes |= BindingScheme.TCP;
break;
case 'p':
schemes |= BindingScheme.NAMED_PIPE;
break;
}
}
host.Start(SingleonIPCService.Instance, resetEvent, new ServerOptions(_options.ServerName, new Dictionary <string, string>()
{
{ "Description", "Report CPU and RAM usage" }
})
{
Scheme = schemes, EnableDiscovery = true
});
}
public void Accept()
{
ServerAE = ServerAE.Trim();
ServerName = ServerName.Trim();
ServerLocation = ServerLocation.Trim();
ServerHost = ServerHost.Trim();
if (base.HasValidationErrors)
{
this.ShowValidation(true);
}
else
{
var current = _serverTree.CurrentNode;
var allButCurrent = _serverTree.RootServerGroup.GetAllServers().Where(s => s != current).Cast <IServerTreeDicomServer>();
var sameAETitleCount = allButCurrent.Count(s => s.AETitle == _serverAE);
if (sameAETitleCount > 0)
{
var message = sameAETitleCount == 1
? SR.ConfirmAETitleConflict_OneServer
: String.Format(SR.ConfirmAETitleConflict_MultipleServers, sameAETitleCount);
if (DialogBoxAction.No == Host.DesktopWindow.ShowMessageBox(message, MessageBoxActions.YesNo))
{
return;
}
}
var newServer = new ServerTreeDicomServer(
_serverName,
_serverLocation,
_serverHost,
_serverAE,
_serverPort,
_isStreaming,
_headerServicePort,
_wadoServicePort);
// edit current server
if (_serverTree.CurrentNode.IsServer)
{
_serverTree.ReplaceDicomServerInCurrentGroup(newServer);
}
// add new server
else if (_serverTree.CurrentNode.IsServerGroup)
{
((IServerTreeGroup)_serverTree.CurrentNode).AddChild(newServer);
_serverTree.CurrentNode = newServer;
}
_serverTree.Save();
SetServerNodeMetaProperties(_serverName, _isPriorsServer);
_serverTree.FireServerTreeUpdatedEvent();
this.ExitCode = ApplicationComponentExitCode.Accepted;
Host.Exit();
}
}
void server_ChunksACKed(ServerHost host)
{
Dispatcher.BeginInvoke((Action)(() =>
{
UpdateServerProgress(host);
}), System.Windows.Threading.DispatcherPriority.Background);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
ServerHost = new ServerHost();
ServerHost.Start();
}
static void Main(string[] args)
{
Init();
ServerHost httpHost = new ServerHost();
httpHost.Run();
Console.WriteLine("HTTP监听设置成功。");
Console.WriteLine("站点网址：" + httpHost.Option.HttpListenerOptions.First().ToUrl());
Console.WriteLine("EXIT: 退出模拟服务，cls: 清屏。");
while (true)
{
string input = Console.ReadLine();
if (input.Is("exit"))
{
return;
}
if (input.Is("cls"))
{
Console.Clear();
}
}
}
public async Task Listens()
{
ServerSettings settings = GetDefaultSettings();
using (CancellationTokenSource cancellation = new CancellationTokenSource())
{
ServerHost host = new ServerHost(settings);
Task serveForever = host.ServeForeverAsync(cancellation.Token);
Task test = Task.Run(
async () =>
{
var getTasks = host.Endpoints.Select(ep => _client.GetAsync(ep)).ToList();
foreach (var task in getTasks)
{
using (HttpResponseMessage response = await task)
{
_output.WriteLine($"Response from {response.RequestMessage.RequestUri}");
_output.WriteLine(response.ToString());
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
});
await Task.WhenAny(test, serveForever);
}
}
void server_ClientJoined(ServerHost host, Guid clientIdentity)
{
Dispatcher.BeginInvoke((Action)(() =>
{
this.lblServerClients.Text = host.Clients.Count.ToString();
// TODO: add an event to a log window
}), System.Windows.Threading.DispatcherPriority.Background);
}
static void AddSignalRSupport(ServerHost server)
{
server.AddAppBuilderCustomization(appBuilder =>
{
appBuilder.UseCors(CorsOptions.AllowAll);
appBuilder.MapSignalR();
});
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
ServerHost = new ServerHost();
ServerHost.Start();
}
void server_ChunkSent(ServerHost host, int chunkIdx)
{
serverCurrentIndex = chunkIdx;
Dispatcher.BeginInvoke((Action)(() =>
{
UpdateServerProgress(host);
}), System.Windows.Threading.DispatcherPriority.Background);
}
private static void Main(string[] args)
{
string sUrlService = "http://127.0.0.1:8000/GameFind";
ServerHost pHost = new ServerHost(sUrlService);
pHost.Start();
Console.WriteLine("Press any key to stop");
Console.ReadKey(true);
}
/// <summary>
/// 设置小程序业务域名
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <param name="wechatid">微信号</param>
/// <returns></returns>
public static ServerHost SetWebviewDomain(string access_token, object data)
{
string url = string.Format(_setWebviewDomainUrl, access_token);
string dataJson = JsonConvert.SerializeObject(data);
string result = HttpHelper.DoPostJson(url, dataJson);
ServerHost model = GetResultModel <ServerHost>(result);
return(model);
}
protected override void OnStop()
{
if (this._server == null)
{
return;
}
this._server.Stop();
this._server = null;
}
/// <summary>
///
/// </summary>
public void Start()
{
if (AnyIpAddress == false)
{
for (int _ipadrs = 0; _ipadrs < IpAddresses.Length; _ipadrs++)
{
this.Start(IpAddresses[_ipadrs]);
}
}
else
{
this.Start(HostName);
}
var _ipOrLocalHost = (AnyIpAddress == false) ? IpAddresses[0] : "localhost";
{
var _urlBehavior = String.Format("http://{0}:{1}/{2}", _ipOrLocalHost, BehaviorPort, ServiceName);
ServiceThrottlingBehavior _throttling = ServerHost.Description.Behaviors.Find <ServiceThrottlingBehavior>();
if (_throttling == null)
{
_throttling = new ServiceThrottlingBehavior
{
MaxConcurrentCalls = int.MaxValue,
MaxConcurrentSessions = int.MaxValue,
MaxConcurrentInstances = int.MaxValue
};
ServerHost.Description.Behaviors.Add(_throttling);
}
//ServiceDebugBehavior _debugging = ServerHost.Description.Behaviors.Find<ServiceDebugBehavior>();
//if (_debugging == null)
//{
// _debugging = new ServiceDebugBehavior();
// _debugging.IncludeExceptionDetailInFaults = true;
// ServerHost.Description.Behaviors.Add(_debugging);
//}
ServiceMetadataBehavior _metadata = ServerHost.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (_metadata == null)
{
_metadata = new ServiceMetadataBehavior
{
HttpGetUrl = new Uri(_urlBehavior),
HttpGetEnabled = true
};
ServerHost.Description.Behaviors.Add(_metadata);
}
this.BehaviorUrl = _urlBehavior;
ServerHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), _urlBehavior);
}
}
public async static Task SetUpServerClient(TestContext context)
{
_mockObject = new Tests.ServerLibrary.MockRoot();
_server = new ServerHost(1100, _mockObject);
_server.Start();
_client = new RemoteClient();
await _client.ConnectAsync("127.0.0.1:1100");
}
static void ServerThreadLoop(object mrevent)
{
ManualResetEvent resetEvent = (ManualResetEvent)mrevent;
var host = new ServerHost();
host.Start(SingleonIPCService.Instance, resetEvent, new ServerOptions("DatabaseServer", null)
{
Scheme = BindingScheme.NAMED_PIPE | BindingScheme.TCP
});
}
static void Main(string[] args)
{
var app = new ServerHost();
var addr = "http://*:8080/";
app.Init();
app.Start(addr);
Console.WriteLine("AppHost Created at {0}, listening on {1}", DateTime.Now, addr);
Console.WriteLine("CTRL + C to exit");
Thread.Sleep(Timeout.Infinite);
}
private void MainForm_Load(object sender, EventArgs e)
{
MinecraftServer = new ServerHost(398475);
InitializeMinecraftServer();
loadJson();
initItemData();
comboInit();
string[] property = { "flat", "normal", "largebiomes", "amplified" };
comboWorldProperty.Items.AddRange(property);
comboWorldProperty.SelectedIndex = 0;
}
public void ResolveProxyTypesLocal_ProxyObjectBase(ServerHost server, RemoteClient client, Type expectedType)
{
server.Start();
client.ConnectAsync($"127.0.0.1:{server.ListenPort}").Wait();
var proxy = client.GetRootObject <IMockRoot>();
server.Dispose();
client.Dispose();
Assert.IsNotNull(proxy, "GetRootObject returned null!");
Assert.IsTrue(proxy.GetType() == expectedType, $"Returned type not expected! {proxy} : {expectedType}");
}
private void Window_Closed(object sender, EventArgs e)
{
if (DialogResult == true)
{
ServerHost.GetBindingExpression(TextBox.TextProperty).UpdateSource();
QrServerAeTitle.GetBindingExpression(TextBox.TextProperty).UpdateSource();
QrServerPort.GetBindingExpression(IntegerUpDown.ValueProperty).UpdateSource();
StoreServerAeTitle.GetBindingExpression(TextBox.TextProperty).UpdateSource();
StoreServerPort.GetBindingExpression(IntegerUpDown.ValueProperty).UpdateSource();
ClientAeTitle.GetBindingExpression(TextBox.TextProperty).UpdateSource();
ClientPort.GetBindingExpression(IntegerUpDown.ValueProperty).UpdateSource();
}
}
private void RemoteService_Load(object sender, EventArgs e)
{
System.Net.ServicePointManager.DefaultConnectionLimit = 2000;
RS_CaseRunner_Timer.Interval = 1000;
RS_CaseRunner_Timer.Tick += AT_CaseRunner_Timer_Tick;
RS_CaseRunner_Timer.Enabled = true;
ShowIp();
serverHost = new ServerHost(new Uri("http://localhost:8087/SelService"));
serverHost.OnBackNowRunnerList += serverHost_OnBackNowRunnerList;
serverHost.OnServerHostMessage += serverHost_OnServerHostMessage;
}
public DataSourceCredentials(string connStr, DataSourceProvider?provider = null)
{
var connStrParams = ExtractConnStrParams(connStr);
DataSourceProvider = provider ?? GetDataSourceProvider(connStrParams);
if (connStrParams.ContainsKey("server"))
{
ServerHost = connStrParams["server"];
}
if (connStrParams.ContainsKey("data source"))
{
ServerHost = connStrParams["data source"];
}
if (connStrParams.ContainsKey("port") && int.TryParse(connStrParams["port"], out var port))
{
ServerPort = port;
}
if (connStrParams.ContainsKey("database"))
{
DbName = connStrParams["database"];
}
if (connStrParams.ContainsKey("user id"))
{
UserName = connStrParams["user id"];
}
if (connStrParams.ContainsKey("password"))
{
Pass = connStrParams["password"];
}
//oracle should use uid / pwd
//Post process...
if (DataSourceProvider == DataSourceProvider.SqlServer)
{
var hostAndPort = ServerHost.Split(',');
ServerHost = hostAndPort.First();
if (hostAndPort.Length > 1 && int.TryParse(hostAndPort[1], out var port1))
{
ServerPort = port1;
}
}
}
public static void Main(string[] args)
{
//iniciamos el host que va a escuchar por las solicitudes de compartir de los clientes de escrotorio
ServerAPI.Current = new ServerAPI();
ServerHost host = new ServerHost(new System.Net.IPEndPoint(IPAddress.Any, 1666));
ServerHost.Current = host;
host.Start();
//webapp
var webHost = BuildWebHost(args);
Services = webHost.Services;
webHost.Run();
}
private void btnServerStart_Click(object sender, RoutedEventArgs e)
{
if (IsServerRunning)
{
return;
}
server = new ServerHost(ZMQ.Transport.TCP, "*:12198", String.Empty, new TarballStreamWriter(Enumerable.Empty <FileInfo>()), txtServerFolder.Text, 512000, 50, false);
server.ClientJoined += new Action <ServerHost, Guid>(server_ClientJoined);
server.ClientLeft += new Action <ServerHost, Guid, ServerHost.ClientLeaveReason>(server_ClientLeft);
server.ChunkSent += new Action <ServerHost, int>(server_ChunkSent);
server.ChunksACKed += new Action <ServerHost>(server_ChunksACKed);
serverThread = new Thread(new ParameterizedThreadStart(server.Run));
serverThread.Start();
IsServerRunning = true;
}
private void btnStart_Click(object sender, EventArgs e)
{
if (_host == null)
{
_host = new ServerHost();
_host.Run(); // 使用默认的配置文件启动监听服务
}
else
{
_host.Start();
}
btnStart.Enabled = false;
btnStop.Enabled = true;
tabControl1.SelectedIndex = 1;
}
protected override void OnStart(string[] args)
{
var baseAddress = ConfigurationManager.AppSettings["owin/baseAddress"];
var bootstrapper = new WindsorBootstrapper(AppDomain.CurrentDomain.BaseDirectory);
var windsor = bootstrapper.Boot();
this._server = new ServerHost(
baseAddress,
bootstrapper.ProbeDirectory,
windsor);
AddODataSupport(this._server);
AddSignalRSupport(this._server);
this._server.Start();
}
public void HttpServer_WhenSessionIsCorrectInASecuredContext_ThenChangesTheContext()
{
var server = new ServerHost(new Client("localhost", 901));
string response;
using (var httpServer = server.Do(
new StartHttpServer(
new[]
{
"/test-template/"
})))
{
httpServer.Modules.Add(new xTagsHttpContextForTest("<r><template id='a' /></r>", "template"));
var responseResult = HttpRequest.DoRequest("http://localhost:901/test-template/");
Assert.IsFalse(responseResult.HasError);
response = responseResult.Response;
}
Assert.AreEqual("<div id='a'></div>", response);
}
void RenderProgress(ServerHost host, bool display)
{
lock (lineWriter)
{
int numChunks = host.NumChunks;
if (numChunks == 0) return;
int usableWidth = consoleWidth - 3;
int blocks = numChunks / usableWidth;
int blocksRem = numChunks % usableWidth;
int subblocks = usableWidth / numChunks;
int subblocksRem = usableWidth % numChunks;
if (!display)
{
if (blocks > 0) display = (DateTimeOffset.UtcNow.Subtract(lastDisplayTime).TotalMilliseconds >= 500d) || (lastChunkBlock != (lastChunkBlock = lastWrittenChunk / blocks));
else display = true;
}
if (display)
{
lastDisplayTime = DateTimeOffset.UtcNow;
if (!wroteLegend)
{
Console.WriteLine();
Console.WriteLine(" '-' no NAKs '*' some NAKs '#' all NAKs 'S' currently sending");
Console.WriteLine();
wroteLegend = true;
}
var clients = host.Clients;
string backup = new string('\b', consoleWidth - 1);
Console.Write(backup);
#if true
string spaces = new string(' ', consoleWidth - 1);
Console.Write(spaces);
Console.Write(backup);
// Write ACK rates:
foreach (var cli in clients)
{
int bps = (cli.ACKsPerMinute * (host.ChunkSize / 60));
WriteRate(bps);
}
Console.WriteLine();
#endif
Console.Write('[');
BitArray naks = new BitArray(host.NumBitArrayBytes * 8, false);
foreach (var cli in clients)
{
naks = naks.Or(cli.NAK);
}
//IEnumerator<bool> boolACKs = naks.Cast<bool>().Take(host.NumChunks).GetEnumerator();
int nakI = 0;
if (blocks > 0)
{
int lastc = 0, c = 0, subc = 0;
while (c < usableWidth)
{
int numBlocks = blocks;
lastc = c++;
if ((blocksRem > 0) && (subc++ >= blocksRem))
{
++numBlocks;
++c;
subc = 0;
}
bool allOn = true;
bool allOff = false;
for (int i = 0; (i < numBlocks) && (nakI < host.NumChunks); ++i, ++nakI)
{
bool curr = naks[nakI];
allOn = allOn & curr;
allOff = allOff | curr;
}
for (int x = lastc; (x < c) && (c < usableWidth); ++x)
{
if ((lastWrittenChunk >= c * blocks) && (lastWrittenChunk < (c + 1) * blocks)) Console.Write('S');
else if (allOn) Console.Write('#');
else if (allOff) Console.Write('*');
else Console.Write('-');
}
}
}
else
{
int lastc = 0, c = 0, subc = 0;
for (int i = 0; i < numChunks; ++i)
{
lastc = c;
c += subblocks;
if ((subblocksRem > 0) && (subc++ >= subblocksRem))
{
++c;
subc = 0;
}
if (++nakI >= host.NumChunks) break;
bool curr = naks[nakI];
for (int x = lastc; (x < c) && (c < usableWidth); ++x)
{
if (lastWrittenChunk == i) Console.Write('S');
else if (curr) Console.Write('#');
else Console.Write('-');
}
}
}
Console.Write(']');
}
}
}
void ChunksACKed(ServerHost host)
{
RenderProgress(host, false);
}
private void btnServerStart_Click(object sender, RoutedEventArgs e)
{
if (IsServerRunning) return;
server = new ServerHost(ZMQ.Transport.TCP, "*:12198", String.Empty, new TarballStreamWriter(Enumerable.Empty<FileInfo>()), txtServerFolder.Text, 512000, 50, false);
server.ClientJoined += new Action<ServerHost, Guid>(server_ClientJoined);
server.ClientLeft += new Action<ServerHost, Guid, ServerHost.ClientLeaveReason>(server_ClientLeft);
server.ChunkSent += new Action<ServerHost, int>(server_ChunkSent);
server.ChunksACKed += new Action<ServerHost>(server_ChunksACKed);
serverThread = new Thread(new ParameterizedThreadStart(server.Run));
serverThread.Start();
IsServerRunning = true;
}
void ChunkSent(ServerHost host, int chunkIdx)
{
lastWrittenChunk = chunkIdx;
RenderProgress(host, false);
}
void server_ChunksACKed(ServerHost host)
{
Dispatcher.BeginInvoke((Action)(() =>
{
UpdateServerProgress(host);
}), System.Windows.Threading.DispatcherPriority.Background);
}
void server_ChunkSent(ServerHost host, int chunkIdx)
{
serverCurrentIndex = chunkIdx;
Dispatcher.BeginInvoke((Action)(() =>
{
UpdateServerProgress(host);
}), System.Windows.Threading.DispatcherPriority.Background);
}
void ClientJoined(ServerHost host, Guid id)
{
RenderProgress(host, true);
}
void server_ClientLeft(ServerHost host, Guid clientIdentity, ServerHost.ClientLeaveReason reason)
{
Dispatcher.BeginInvoke((Action)(() =>
{
this.lblServerClients.Text = host.Clients.Count.ToString();
// TODO: add an event to a log window
}), System.Windows.Threading.DispatcherPriority.Background);
}
public async Task HandlesManyRequests(Int64 requestCount)
{
ServerSettings settings = GetDefaultSettings();
using (CancellationTokenSource cancellation = new CancellationTokenSource())
{
ServerHost host = new ServerHost(settings);
Task serveForever = host.ServeForeverAsync(cancellation.Token);
Task test = Task.Run(
async () =>
{
var tortureTasks = host.Endpoints.Select(ep => HttpTorturer.TortureAsync(ep, requestCount)).ToList();
foreach (var task in tortureTasks)
{
var result = await task;
_output.WriteLine(result.ToString());
}
});
await Task.WhenAny(test, serveForever);
}
}
private void UpdateServerProgress(ServerHost host)
{
// TODO: update the progress bar control to accept a List<int> instead of BitArray and render it as a heat-map.
BitArray curr = new BitArray(host.NumBitArrayBytes * 8, false);
foreach (var cli in host.Clients)
{
if (!cli.HasNAKs) continue;
if (cli.IsTimedOut) continue;
curr = curr.Or(cli.NAK);
}
// Update the server progress bar:
this.pbServerProgress.UpdateProgress(curr, serverCurrentIndex);
}
void ClientLeft(ServerHost host, Guid id, ServerHost.ClientLeaveReason reason)
{
RenderProgress(host, true);
}
