public async Task <IActionResult> Edit(int id, [Bind("HostServerID,Name,Address,SshUserName")] HostServer hostServer)
{
if (id != hostServer.HostServerID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(hostServer);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HostServerExists(hostServer.HostServerID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(hostServer));
}
private static int Execute(ServerParameters arg) {
var config = arg.BuildServerConfig();
EnsureRequiredApplications(arg,config);
config.DllFolder = EnvironmentInfo.ResolvePath("@repos@/.build/bin/all");
var command = arg.Get("command", "");
if (string.IsNullOrWhiteSpace(command)) {
Console.WriteLine("LOGLEVEL " + config.LogLevel);
}
var hostServer = new HostServer(config);
hostServer.Initialize();
var consoleContext = new ConsoleContext
{
Container = hostServer.Container,
Parameters = arg
};
var listener = new ConsoleListener(consoleContext);
if (!string.IsNullOrWhiteSpace(command)) {
var task = listener.Call(command);
task.Wait();
}
else {
LogHostInfo(arg, config);
hostServer.Start();
Console.WriteLine("LOGLEVEL " + config.LogLevel);
listener.Log = hostServer.Container.Get<ILoggyManager>().Get("console");
listener.Run();
hostServer.Stop();
}
return 0;
}
public void HighLoad()
{
var hs = new HostServer(14910);
hs.Initialize();
var mvc = (MvcFactory)hs.Container.Get <IMvcFactory>();
mvc.Register(typeof(TestAction).Assembly);
var tasks = new List <Task>();
for (var i = 0; i < 20; i++)
{
for (var j = 0; j < 4; j++)
{
tasks.Add(Task.Run(() => {
hs.Call("/test/best");
}));
}
Console.WriteLine(i);
Thread.Sleep(200);
}
Task.WaitAll(tasks.ToArray());
Console.WriteLine(mvc.GetMetric("action.pool.count"));
Console.WriteLine(TestAction.creates);
Assert.Greater(10, mvc.GetMetric("action.pool.count").ToInt());
Assert.Greater(10, TestAction.creates);
}
public void CanUseCacheOnResolutionIntegration()
{
var xml = BSharpCompiler.Compile(ProductionCode)["tiles"].Compiled;
var conf = new HostConfig(xml);
var qh = new HostServer(conf);
qh.Start();
try
{
var response = new HttpClient().Call("http://127.0.0.1:14990/map/8/173/76.png");
Assert.AreEqual(200, response.State);
Assert.AreEqual("image/png; charset=utf-8", response.ContentType);
var png = (Bitmap)Image.FromStream(new MemoryStream(response.Data));
Assert.AreEqual(ImageFormat.Png, png.RawFormat);
var pixel = png.GetPixel(70, 40);
Assert.AreEqual(174, pixel.R);
Assert.AreEqual(209, pixel.G);
Assert.AreEqual(160, pixel.B);
response = new HttpClient().Call("http://127.0.0.1:14990/map/6/11/26.png");
Assert.AreEqual(200, response.State);
Assert.AreEqual("image/png; charset=utf-8", response.ContentType);
png = (Bitmap)Image.FromStream(new MemoryStream(response.Data));
Assert.AreEqual(ImageFormat.Png, png.RawFormat);
pixel = png.GetPixel(54, 18);
Assert.AreEqual(181, pixel.R);
Assert.AreEqual(171, pixel.G);
Assert.AreEqual(201, pixel.B);
}
finally
{
qh.Stop();
}
}
public void CanProxiseByAppid()
{
var aconfig1 = new HostConfig();
aconfig1.AddQorpentBinding(98);
var aconfig2 = new HostConfig();
aconfig2.AddQorpentBinding(99);
aconfig2.Proxize["/call1"] = "appid=98";
var h1 = new HostServer(aconfig1);
var h2 = new HostServer(aconfig2);
h1.On("/call1", "hello!");
var result = "";
try
{
h1.Start();
h2.Start();
Thread.Sleep(100);
result = new HttpClient().GetString("http://127.0.0.1:14990/call1");
}
finally
{
h1.Stop();
h2.Stop();
}
Assert.AreEqual("hello!", result);
}
public void CanProxiseByAppid()
{
var aconfig1 = new HostConfig();
aconfig1.AddQorpentBinding(98);
var aconfig2 = new HostConfig();
aconfig2.AddQorpentBinding(99);
aconfig2.Proxize["/call1"] = "appid=98";
var h1 = new HostServer(aconfig1);
var h2 = new HostServer(aconfig2);
h1.On("/call1", "hello!");
var result = "";
try
{
h1.Start();
h2.Start();
Thread.Sleep(100);
result = new HttpClient().GetString("http://127.0.0.1:14990/call1");
}
finally
{
h1.Stop();
h2.Stop();
}
Assert.AreEqual("hello!", result);
}
/*Quand on clique sur server, un serveur est créé et le constructeur correspondant
* est appelé dans MainPage*/
private async void ServerButton_Clicked(object sender, EventArgs e)
{
HostServer server = new HostServer(Width, Height);
Thread sThread = new Thread(server.StartListening);
sThread.Start();
await Navigation.PushAsync(new MainPage(server, "127.0.0.1"));
}
public void UpdateConnection(HostServer host)
{
if (!_hostConnections.TryGetValue(host.Host.HostId, out var runner))
{
return;
}
runner.EndpointProvider.HostUri = new Uri(host.Host.Endpoint);
}
private string GetPassword(HostServer server)
{
var servers = _config.GetSection("Servers");
var entry = servers.GetSection(server.Address);
if (entry == null)
{
throw new ArgumentOutOfRangeException();
}
return(entry.Value);
}
public async Task <IActionResult> Create([Bind("HostServerID,Name,Address,SshUserName")] HostServer hostServer)
{
if (ModelState.IsValid)
{
_context.Add(hostServer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(hostServer));
}
//Constructeur appelé quand on demande à être hôte
public MainPage(HostServer server, string ip)
{
hostServer = server;
BindingContext = this;
IpAddress = new WebClient().DownloadString("http://icanhazip.com");
IpAddress = String.Format("Whiteboard IP: {0}", IpAddress);
InitializeComponent();
UpdateUIEventHandler.OnUpdateUI += UpdateUi;
asyncClient = new AsyncClient(ip);
asyncClient.StartClient();
}
public void Setup()
{
host = new HostServer(14910);
host.Initialize();
host.Container.Get <IMvcFactory>().Register(typeof(ApiExecuteAction));
host.Container.Register(host.Container.NewComponent <IApi, Api>(Lifestyle.Pooled));
host.Factory.Register("/apir/execute", new ApiRequestHandler());
host.Start();
Thread.Sleep(100);
cli = new HttpClient();
}
public void CreateConnection(HostServer host)
{
_hostConnections.Add(
host.Host.HostId,
new EndpointConnectionRunner(
host,
host.ConnectionManager,
_logger,
_eventBus,
_loggerFactory));
}
protected override void Dispose(bool disposing)
{
lock (_connectionsSync)
{
if (HostServer != null)
{
HostServer.Dispose();
HostServer = null;
}
}
base.Dispose(disposing);
}
public void ZeroDataHttpClientFail_BUG_Q540()
{
var h = new HostServer(8091);
h.Factory.Register("/test", new zero_data());
try {
h.Start();
Assert.AreEqual("", new HttpClient().GetString("http://127.0.0.1:8091/test"));
}
finally {
h.Stop();
}
}
public EndpointConnectionRunner(
HostServer host,
EndpointConnectionManager connectionManager,
ILogger <ConnectionManager> logger,
EventBus eventBus,
ILoggerFactory loggerFactory)
{
HostServer = host;
_connectionManager = connectionManager;
_logger = logger;
_eventBus = eventBus;
_loggerFactory = loggerFactory;
EndpointProvider = new HostServerEndpointProvider(new Uri(Host.Endpoint));
}
private static List <ProcessInfo> GetRunningProcesses(SshClient client, HostServer server)
{
var top = client.RunCommand("/usr/bin/top -n 1 -b -w 200");
return(top.Result.Split("\n").Skip(7).Select(l => Space.Split(l.Trim())).Where(items => items.Length == 12).Select(items => new ProcessInfo()
{
Pid = int.Parse(items[0], CultureInfo.InvariantCulture),
User = items[1],
Cpu = decimal.Parse(items[8], CultureInfo.InvariantCulture),
Mem = decimal.Parse(items[9], CultureInfo.InvariantCulture),
Cmd = items[11],
Server = server
}).ToList());
}
protected override async ValueTask DisposeAsync(bool disposing)
{
await ConnectionsLock.TryLockAsync(
async() =>
{
if (HostServer != null)
{
await HostServer.DisposeAsync();
HostServer = null;
}
},
5000,
true);
await base.DisposeAsync(disposing);
}
public void FixtureSetup()
{
var hostConfig = new HostConfig();
hostConfig.Bindings.Add(new HostBinding {
Port = 50651, Schema = HostSchema.Http, Interface = "127.0.0.1"
});
hostConfig.Bindings.Add(new HostBinding {
Port = 50652, Schema = HostSchema.Https, Interface = "127.0.0.1"
});
host = new HostServer(hostConfig);
host.On("/x.html", _html, "text/hmtl");
host.On("/x2.html", _html2, "text/hmtl");
host.Start();
httpend = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 50651);
httpsend = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 50652);
}
public void CanRunSingle()
{
var hs = new HostServer(14910);
hs.Initialize();
var mvc = (MvcFactory)hs.Container.Get <IMvcFactory>();
mvc.Register(typeof(TestAction).Assembly);
var result = hs.Call("/test/best");
Console.WriteLine(result);
Assert.AreEqual("0", result);
Assert.AreEqual(1, mvc.GetMetric("action.pool.count"));
result = hs.Call("/test/best");
Assert.AreEqual("1", result);
Assert.AreEqual(1, TestAction.creates);
Assert.AreEqual(1, mvc.GetMetric("action.pool.count"));
}
public void Setup() {
this.host = new HostServer(14990);
host.OnBeforeInitializeServices += c => {
c.Register(c.NewComponent<IHostLogon,TestHostLogon>());
};
host.Initialize();
auth = host.Auth as DefaultHostAuthenticationProvider;
Assert.NotNull(auth);
Assert.NotNull(auth.HostLogonProvider);
lp = auth.HostLogonProvider as DefaultHostLogonProvider;
ls = auth.LoginSourceProvider as DefaultLoginSourceProvider;
ls.Sources = new[] {new TestLoginSource()};
Assert.True(lp.HostLogons.OfType<TestHostLogon>().Any()); //this code is just tests that Auth uses logons from IoC
lp.HostLogons = new[] {new TestHostLogon()}; //we require just one logon extension
this.cl = new HttpClient();
host.Start();
Thread.Sleep(200);
}
public Server(HostEndPoint endPoint)
{
// TODO: remove this from here.
FloodNetwork.NetworkInitialize();
var server = new HostServer();
host = server;
var details = new HostConnectionDetails()
{
Address = endPoint.Address,
Port = endPoint.Port,
ChannelCount = ChannelCount
};
server.SessionPacket += OnPacket;
server.CreateSocket(details);
}
public void CanProxisePost()
{
var aconfig1 = new HostConfig();
aconfig1.AddQorpentBinding(98);
var aconfig2 = new HostConfig();
aconfig2.AddQorpentBinding(99);
aconfig2.Proxize["/call1"] = "appid=98";
var h1 = new HostServer(aconfig1);
var h2 = new HostServer(aconfig2);
h1.OnContext("/call1", _ => {
if (_.Method == "POST")
{
_.Finish(new StreamReader(_.Request.Stream).ReadToEnd());
}
else
{
_.Finish("hello!");
}
});
var result = "";
var resultDirect = "";
try
{
h1.Start();
h2.Start();
Thread.Sleep(1000);
resultDirect = new HttpClient().GetString("http://127.0.0.1:14980/call1", "hello2");
result = new HttpClient().GetString("http://127.0.0.1:14990/call1", "hello2");
}
finally
{
h1.Stop();
h2.Stop();
}
Console.WriteLine(result);
Assert.AreEqual("hello2", resultDirect);
Assert.AreEqual("hello2", result);
}
public void Setup()
{
this.host = new HostServer(14990);
host.OnBeforeInitializeServices += c => {
c.Register(c.NewComponent <IHostLogon, TestHostLogon>());
};
host.Initialize();
auth = host.Auth as DefaultHostAuthenticationProvider;
Assert.NotNull(auth);
Assert.NotNull(auth.HostLogonProvider);
lp = auth.HostLogonProvider as DefaultHostLogonProvider;
ls = auth.LoginSourceProvider as DefaultLoginSourceProvider;
ls.Sources = new[] { new TestLoginSource() };
Assert.True(lp.HostLogons.OfType <TestHostLogon>().Any()); //this code is just tests that Auth uses logons from IoC
lp.HostLogons = new[] { new TestHostLogon() }; //we require just one logon extension
this.cl = new HttpClient();
host.Start();
Thread.Sleep(200);
}
public static void Start()
{
RuntimeTypeModel.Default.Add(typeof(Msg), false).SetSurrogate(typeof(MsgSurrogate));
Application.EnableVisualStyles();
noti_Init();
log = new Log();
host = new HostServer(log);
host.OnClient += (even, client_id, msg_id) =>
{
switch (even)
{
case MsgConnectEvent.MESSAGE_BINARY:
//Msg m = msg.Get(msg_id);
break;
}
};
log.OnChange += (system, type, text) => fm_log.ShowLog(system, type, text);
//////////////////////////////////////////////
icon_tray = new SystemTray("Host");
fm_noti = new FormNotification();
fm_log = new FormLogger();
//fm_demo = new FormDemo(host);
host.Start();
fm_log.Show();
//fm_demo.Show();
log.Write(LogSystem.HOST_SYSTEM, LogType.NONE, string.Format("Host port public: {0}", host.Port));
log.Write(LogSystem.HOST_SYSTEM, LogType.NONE, string.Format("Host port HTTP: {0}", host.PortHTTP));
log.Write(LogSystem.HOST_SYSTEM, LogType.NONE, string.Format("Host port Websocket: {0}", host.PortWebSocket));
Application.Run(icon_tray);
}
public Server(RemotingManager remotingManager, HostEndPoint endPoint)
: base(remotingManager)
{
// TODO: remove this from here
//Flood.Network.NetworkInitialize();
var server = new HostServer();
host = server;
var details = new HostConnectionDetails()
{
Address = endPoint.Address,
Port = endPoint.Port,
ChannelCount = ChannelCount
};
server.SessionPacket += OnPacket;
server.CreateSocket(details);
}
public async Task <bool> Login(string code, string sessionState)
{
if (Identity != null)
{
return(false);
}
IdentityData id = await HostServer.Login(http, code);
if (id == null)
{
return(false);
}
else
{
Identity = id;
Identity.State = sessionState;
base.NotifyAuthenticationStateChanged(GetAuthenticationStateAsync());
return(true);
}
}
internal List <ProcessInfo> GetRunningProcesses(HostServer server)
{
List <ProcessInfo> processes;
try
{
using (var client = GetClient(server))
{
client.ConnectionInfo.Timeout = TimeSpan.FromMilliseconds(1000);
client.Connect();
processes = GetRunningProcesses(client, server);
client.Disconnect();
}
}
catch (SshOperationTimeoutException)
{
processes = new List <ProcessInfo>();
}
return(processes);
}
public void CanProxisePost()
{
var aconfig1 = new HostConfig();
aconfig1.AddQorpentBinding(98);
var aconfig2 = new HostConfig();
aconfig2.AddQorpentBinding(99);
aconfig2.Proxize["/call1"] = "appid=98";
var h1 = new HostServer(aconfig1);
var h2 = new HostServer(aconfig2);
h1.OnContext("/call1", _ => {
if (_.Method == "POST") {
_.Finish(new StreamReader(_.Request.Stream).ReadToEnd());
}
else {
_.Finish("hello!");
}
});
var result = "";
var resultDirect = "";
try
{
h1.Start();
h2.Start();
Thread.Sleep(1000);
resultDirect = new HttpClient().GetString("http://127.0.0.1:14980/call1", "hello2");
result = new HttpClient().GetString("http://127.0.0.1:14990/call1", "hello2");
}
finally
{
h1.Stop();
h2.Stop();
}
Console.WriteLine(result);
Assert.AreEqual("hello2", resultDirect);
Assert.AreEqual("hello2", result);
}
private static int Execute(ServerParameters arg)
{
var config = arg.BuildServerConfig();
EnsureRequiredApplications(arg, config);
config.DllFolder = EnvironmentInfo.ResolvePath("@repos@/.build/bin/all");
var command = arg.Get("command", "");
if (string.IsNullOrWhiteSpace(command))
{
Console.WriteLine("LOGLEVEL " + config.LogLevel);
}
var hostServer = new HostServer(config);
hostServer.Initialize();
var consoleContext = new ConsoleContext
{
Container = hostServer.Container,
Parameters = arg
};
var listener = new ConsoleListener(consoleContext);
if (!string.IsNullOrWhiteSpace(command))
{
var task = listener.Call(command);
task.Wait();
}
else
{
LogHostInfo(arg, config);
hostServer.Start();
Console.WriteLine("LOGLEVEL " + config.LogLevel);
listener.Log = hostServer.Container.Get <ILoggyManager>().Get("console");
listener.Run();
hostServer.Stop();
}
return(0);
}
public void HttpCacheTest()
{
var conf = new HostConfig();
conf.AddQorpentBinding(99);
conf.StaticContentMap["/files/"] = new StaticFolderDescriptor {
Path = web
};
var qh = new HostServer(conf);
qh.Start();
try {
Thread.Sleep(200);
Assert.AreEqual("41", new HttpClient().GetString("http://127.0.0.1:14990/files/a.txt"));
cache.Sources.Add(new FileCacheSource("http://127.0.0.1:14990/files/"));
CheckFile("b/e/j.txt", 48);
Assert.Null(cache.Resolve("b/e/k.txt")); //check that 404 doesn't cause error
}
finally {
qh.Stop();
}
}
public void Head_Method_Support_BUG_Q541()
{
var h = new HostServer(8091);
h.Factory.Register("/test", new no_zero_data());
try
{
h.Start();
var req = new HttpRequest
{
Uri = new Uri("http://127.0.0.1:8091/test"),
Method = "GET"
};
Assert.AreEqual("It's not zero", new HttpClient().Call(req).StringData);
req.Method = "HEAD";
Assert.AreEqual("", new HttpClient().Call(req).StringData);
}
finally
{
h.Stop();
}
}
public void CanReadCacheConfigFromBSharp()
{
var xml = BSharpCompiler.Compile(ProductionCode)["tiles"].Compiled;
var conf = new HostConfig(xml);
Assert.AreEqual(1, conf.StaticContentCacheMap.Count);
var qh = new HostServer(conf);
Assert.NotNull(qh.Factory);//force initialize (HACK)
var stats = (HostServerStaticResolver)qh.Static;
Assert.AreEqual(1, stats.Caches.Count);
var resolver = stats.Caches["/map/"];
Assert.NotNull(resolver);
Assert.AreEqual(EnvironmentInfo.ResolvePath(" %TEMP%/HostIntegrationTest"), resolver.Root);
Assert.AreEqual(3, resolver.Sources.Count);
var src = resolver.Sources[0];
Assert.True(src.IsMaster);
Assert.AreEqual("http://144.76.82.130:14060/map/", src.Root);
Assert.AreEqual("notfound.png", resolver.Fallback);
}
internal SftpClient GetSftpClient(HostServer server)
{
return(new SftpClient(server.Address, server.SshUserName, GetPassword(server)));
}
public void FixtureSetUp()
{
this.srv = new HostServer(8094);
srv.Start();
}
public void FixtureSetUp()
{
this.srv = new HostServer(8094);
srv.Start();
}
public void TestPeerConnection()
{
Flood.Network.NetworkInitialize();
var conn = new HostConnectionDetails {Address = "", Port = 13131};
var hostServer = new HostServer();
var hostClient = new HostClient();
hostServer.CreateSocket(conn);
hostClient.Connect(conn);
//Test Connections
{
//bool clientConnected = false;
//bool serverConnected = false;
//hostClient.PeerConnect += peer => clientConnected = true;
//hostServer.PeerConnect += peer => serverConnected = true;
var watch = Stopwatch.StartNew();
while (watch.ElapsedMilliseconds < 20)
{
hostClient.ProcessEvents(1);
hostServer.ProcessEvents(1);
}
//Assert.IsTrue(clientConnected);
//Assert.IsTrue(serverConnected);
}
//Test QueuePacket
{
const ushort packetId = 13;
const string packetString = "message";
var packetReceived = false;
var packetReceivedId = -1;
var packetReceiveString = "";
hostServer.SessionPacket += (session, packet, channel) =>
{
packetReceived = true;
packetReceivedId = packet.Id;
var bytes = packet.Read();
packetReceiveString = Encoding.UTF8.GetString(bytes.ToArray(),0,bytes.Count);
};
var p = new Packet(packetId);
p.Write(new List<byte>(Encoding.ASCII.GetBytes(packetString)));
hostClient.Peer.QueuePacket(p, 0);
var watch = Stopwatch.StartNew();
while (watch.ElapsedMilliseconds < 20)
{
hostClient.ProcessEvents(1);
hostServer.ProcessEvents(1);
}
Assert.IsTrue(packetReceived);
Assert.AreEqual(packetId,packetReceivedId);
Assert.AreEqual(packetString,packetReceiveString);
}
//Test Encrypted Packet
{
const ushort packetId = 13;
const string packetString = "message";
var packetReceived = false;
var packetReceivedId = -1;
var packetReceiveString = "";
hostServer.SessionPacket += (session, packet, channel) =>
{
packetReceived = true;
packetReceivedId = packet.Id;
var bytes = packet.Read();
packetReceiveString = Encoding.UTF8.GetString(bytes.ToArray(),0,bytes.Count);
};
var p = new Packet(packetId) {Flags = PacketFlags.Encrypted};
p.Write(new List<byte>(Encoding.ASCII.GetBytes(packetString)));
hostClient.Peer.QueuePacket(p, 0);
var watch = Stopwatch.StartNew();
while (watch.ElapsedMilliseconds < 20)
{
hostClient.ProcessEvents(1);
hostServer.ProcessEvents(1);
}
Assert.IsTrue(packetReceived);
Assert.AreEqual(packetId,packetReceivedId);
Assert.AreEqual(packetString,packetReceiveString);
}
}
