private void button1_Click(object sender, EventArgs e)
{
if (!server.IsListening)
{
server.Start();
this.button1.Text = "Stop Server";
}
else
{
server.Stop();
this.button1.Text = "Start Server";
}
}
public void runServer(bool state)
{
try
{
if (state)
{
Rest = new RestServer();
Rest.Port = Settings.Default.Port;
Rest.Host = Settings.Default.HostIP;
if (Authentication.Enabled)
{
Rest.Advanced.AuthenticationSchemes = AuthenticationSchemes.Basic;
}
Rest.UseHttps = Settings.Default.HTTPS;
Rest.Start();
setRunningStatus();
}
else
{
Rest.Stop();
Rest.Dispose();
setStoppedStatus();
}
}
catch (Exception error)
{
DialogResult result = MessageBox.Show(error.ToString(), "Unexpected error.", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
if (result == DialogResult.OK)
{
Application.Exit();
}
}
}
static void Main(string[] args)
{
RestServer server = new RestServer(IPAddress.Parse("224.0.0.224"), 53186);
server.RequestReceived += new EventHandler <RequestEventArgs <HttpRequest, HttpResponse> >(server_RequestReceived);
server.HttpRequestReceived += new EventHandler <HttpServerEventArgs>(server_HttpRequestReceived);
server.StartUdp();
Console.WriteLine("Server Started");
//HttpRequest request = new HttpRequest("http://224.0.0.224:53186/Lucene/");
//request.Protocol = TransportProtocol.UDP;
//request.GetResponse(false);
//Thread.Sleep(1000);
//request = new HttpRequest("http://224.0.0.224:53186/Lucene/");
//request.Protocol = TransportProtocol.UDP;
//request.GetResponse(false);
//Thread.Sleep(10000);
//request = new HttpRequest("http://224.0.0.224:53186/Lucene/");
//request.Protocol = TransportProtocol.UDP;
//request.GetResponse(false);
//Thread.Sleep(30000);
//request = new HttpRequest("http://224.0.0.224:53186/Lucene/");
//request.Protocol = TransportProtocol.UDP;
//request.GetResponse(false);
Console.Read();
server.Stop();
Console.WriteLine("Server Stopped");
}
public void AfterStoppingThrowsAggregateException()
{
var listener = Substitute.For <IHttpListener>();
listener.IsListening.Returns(true);
var order = new List <int>();
using (var server = new RestServer(listener))
{
server.BeforeStopping += restServer => { order.Add(1); listener.IsListening.Returns(false); };
server.AfterStopping += restServer => { order.Add(2); throw new Exception("blah"); };
server.AfterStopping += restServer => { order.Add(3); };
try
{
server.Stop();
}
catch (Exception e)
{
e.InnerException.ShouldNotBeNull();
e.InnerException?.GetType().ShouldBe(typeof(AggregateException));
}
listener.IsListening.Returns(false);
}
order.Count.ShouldBe(3);
}
static void Main(string[] args)
{
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
RestServer server = new RestServer();
try
{
server.Start();
}
catch (Exception ex)
{
Console.WriteLine(
"Unable to start REST server.\n" +
"Make sure the application is running with Administrator privilegies." +
"Exception details:\n\n" +
ex.ToString());
}
Console.WriteLine(
"This is an example of using Radish for documenting your REST API methods.\n\n" +
"Open your favorite web browser and type the following\n" +
"in the address bar to see the auto-generated documentation:\n\n" +
"http://localhost:8040/api/help/simple -- simple template set\n" +
"http://localhost:8040/api/help/bootstrap -- Bootstrap-based template set\n");
exitSignal.WaitOne();
server.Stop();
}
static void Main(string[] args)
{
Debug.WriteLine("Started!");
ServerSettings settings = new ServerSettings();
settings.Host = "ec2-35-164-218-97.us-west-2.compute.amazonaws.com"; //93.82.35.63
//settings.Host = "localhost"; //78.104.199.75
settings.Port = "8080";
insertInitialData();
try
{
using (var server = new RestServer(settings))
{
server.LogToConsole().Start();
//New Thread needs to be started, which calculates the market prizes and handles the orders.
Thread myThread = new Thread(new ThreadStart(orderBookOperations));
myThread.Start();
Console.ReadLine();
server.Stop();
}
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex);
Console.ReadLine();
}
}
public static void Main(string[] args)
{
using (var server = new RestServer())
{
server.LogToConsole();
server.PublicFolder = new PublicFolder(@"C:\source\github\gv-gh-pages")
{
Prefix = "Grapevine"
};
server.OnBeforeStart = () => Console.WriteLine("---------------> Starting Server");
server.OnAfterStart = () => Console.WriteLine($"<--------------- Server Started");
server.OnBeforeStop = () => Console.WriteLine("---------------> Stopping Server");
server.OnAfterStop = () =>
{
Console.WriteLine("<--------------- Server Stopped");
Console.ReadLine();
};
server.Start();
Console.ReadLine();
server.Stop();
}
}
public static void StartRestServer(RestServer server)
{
bool inputValid = false;
char input;
while (!inputValid)
{
Console.WriteLine("Release or Debug? (R||D)");
input = Console.ReadKey().KeyChar;
if (input == 'R' || input == 'r')
{
server.Host = "+";
inputValid = true;
Console.WriteLine("");
}
if (input == 'D' || input == 'd')
{
server.Host = "localhost";
inputValid = true;
Console.WriteLine("");
}
}
server.Port = "5000";
server.LogToConsole().Start();
Console.ReadLine();
server.Stop();
}
public void StopServer()
{
LOG.Info("Stopping API server");
_server?.Stop();
ClosePort();
LOG.Info("API server stopped");
}
static void Main(string[] args)
{
IIdService idService = new UniqueIdService();
IDataService inMemoryDataService = new InMemoryDataService(idService);
inMemoryDataService.SetupData(null);
IDataService dataService = new ElasticDataService(inMemoryDataService);
dataService.SetupData(null);
IJsonService jsonService = new NewtonJsonService();
using (var server = new RestServer())
{
var genreRoute = new GenreRoute(dataService, jsonService);
var authorRoute = new AuthorRoute(dataService, jsonService);
var bookRoute = new BookRoute(dataService, jsonService);
server.Host = "127.0.0.1";
server.Port = "8444";
server.Router.Register(genreRoute.Handler, "/genres");
server.Router.Register(authorRoute.Handler, "/authors");
server.Router.Register(bookRoute.Handler, "/books");
server.Start();
Console.ReadLine();
server.Stop();
}
}
public static void Main(string[] args)
{
using (var server = new RestServer())
{
server.LogToConsole().Start();
Console.ReadLine();
server.Stop();
}
}
static void Main(string[] args)
{
{
var v = "v0.1.0.0";
var nameService = "Load Balancer Service";
Console.Title = nameService + " " + v;
Console.WriteLine(" L O A D B A L A N C E R S E R V I C E " + v);
var serverStandar = new RestServer();
var input = "";
while ((input = Console.ReadLine()) != "q")
{
switch (input)
{
case "start":
Console.WriteLine("Starting service...");
serverStandar.Port = "5010";
serverStandar.Host = "*";
serverStandar.Start();
Console.Title = "[ON] " + nameService + " " + v;
break;
case "start --log":
Console.WriteLine("Starting service...");
using (var server = new RestServer())
{
server.Port = "5010";
server.Host = "*";
server.LogToConsole().Start();
Console.Title = "[ON] " + nameService + " " + v;
Console.ReadLine();
server.Stop();
}
break;
case "stop":
Console.WriteLine("Stopping service...");
serverStandar.Stop();
Console.Title = nameService + " " + v;
break;
case "--version":
Console.WriteLine(v);
break;
default:
Console.WriteLine(String.Format("Unknown command: {0}", input));
break;
}
}
}
}
static void Main(string[] args)
{
using (var restServer = new RestServer()) {
restServer.Port = "9090";
restServer.LogToConsole().Start();
Console.ReadLine();
restServer.Stop();
}
}
public void Stop()
{
if (!_isRunning)
{
return;
}
_restServer.Stop();
Logger.Info("REST server stopped");
}
/// <summary>
/// todo; requires some more testing
/// </summary>
public static void StopServer()
{
if (server.IsListening)
{
Trace.Write("Attempting to stop the server .... ");
server.ThreadSafeStop();
server.Stop();
Trace.Write(".. Stopped!");
}
}
public void AbortsWhenAlreadyStopped()
{
var listener = Substitute.For <IHttpListener>();
using (var server = new RestServer(listener))
{
server.Stop();
listener.DidNotReceive().Stop();
}
}
public static void Stop()
{
if (startedRestServer != null)
{
try
{
startedRestServer.Stop();
startedRestServer = null;
}
catch { }
}
}
public static void Stop()
{
// ReSharper disable EmptyGeneralCatchClause
if (startedRestServer != null)
{
try
{
startedRestServer.Stop();
startedRestServer = null;
}
catch { }
}
// ReSharper enable EmptyGeneralCatchClause
}
public void ThrowsExceptionWhenExceptionOccursWhileStopping()
{
var listener = Substitute.For <IHttpListener>();
listener.When(_ => _.Stop()).Do(_ => { throw new Exception(); });
listener.IsListening.Returns(true);
using (var server = new RestServer(listener))
{
Should.Throw <UnableToStopHostException>(() => server.Stop());
server.GetIsStopping().ShouldBeFalse();
listener.IsListening.Returns(false);
}
}
public void ThrowsExceptionWhenStarting()
{
var listener = Substitute.For <IHttpListener>();
listener.IsListening.Returns(true);
using (var server = new RestServer(listener))
{
server.SetIsStarting(true);
Should.Throw <UnableToStopHostException>(() => server.Stop());
listener.IsListening.Returns(false);
server.SetIsStarting(false);
}
}
public void AbortsWhenAlreadyStopping()
{
var listener = Substitute.For <IHttpListener>();
listener.IsListening.Returns(true);
using (var server = new RestServer(listener))
{
server.SetIsStopping(true);
server.Stop();
listener.DidNotReceive().Stop();
listener.IsListening.Returns(false);
}
}
public static void Stop()
{
if (startedRestServer != null)
{
try
{
startedRestServer.Stop();
startedRestServer = null;
}
catch (Exception ex)
{
AdminShellNS.LogInternally.That.SilentlyIgnoredError(ex);
}
}
}
public void OnAfterStopNotExecutedWhenListening()
{
var invoked = false;
var listener = Substitute.For <IHttpListener>();
listener.IsListening.Returns(true);
using (var server = new RestServer(listener)
{
OnAfterStop = () => { invoked = true; }
})
{
server.Stop();
invoked.ShouldBeFalse();
listener.IsListening.Returns(false);
}
}
public void OnAfterStopExecutesWhenNotListening()
{
var invoked = false;
var listener = Substitute.For <IHttpListener>();
listener.IsListening.Returns(true);
listener.When(l => l.Stop()).Do(info => listener.IsListening.Returns(false));
using (var server = new RestServer(listener)
{
OnAfterStop = () => { invoked = true; }
})
{
server.Stop();
invoked.ShouldBeTrue();
}
}
public static void Main(string[] args)
{
using (var server = new RestServer())
{
server.LogToConsole();
server.OnBeforeStart = () => server.Logger.Trace("Starting Server");
server.OnAfterStart = () => server.Logger.Trace("Server Started");
server.OnBeforeStop = () => server.Logger.Trace("Stopping Server");
server.OnAfterStop = () => server.Logger.Trace("Server Stopped");
server.Router.BeforeRouting += ctx => server.Logger.Debug("Before Routing!!");
server.Router.BeforeRouting += ctx => server.Logger.Debug("After Routing!!");
server.Start();
Console.ReadLine();
server.Stop();
}
}
public Program(JObject config)
{
// load information about the local client
Arrowhead.Utils.Settings settings = new Arrowhead.Utils.Settings(config);
// creating the client registers it in the Service Register
this.client = new Arrowhead.Client(settings);
bool useSSL = settings.Interfaces.Any(i => i == "HTTPS-SECURE-JSON");
using (var server = new RestServer())
{
server.UseHttps = useSSL;
server.Host = config.SelectToken("system.ip").ToString();
server.Port = config.SelectToken("system.port").ToString();
server.LogToConsole().Start();
Console.ReadLine();
server.Stop();
}
}
static void RunWebServer(CancellationToken token)
{
if (token.IsCancellationRequested)
{
Console.WriteLine("Web-Server beendet.");
return;
}
using (var server = new RestServer())
{
server.Port = Port;
server.LogToConsole(Grapevine.Interfaces.Shared.LogLevel.Warn).Start();
while (!token.IsCancellationRequested)
{
//nichts unternehmen
}
//server.LogToConsole().Stop();
server.Stop();
}
}
static void Main(string[] args)
{
if (args.Length != 4)
{
Console.WriteLine("Missing parameters ...");
Console.WriteLine("Usage: ProtectedLog.exe activityFile precedenceFile sequenceFile privacyBudget");
Console.WriteLine("Example: ProtectedLog.exe log-activities.csv log-precedence.csv log-sequences.csv 10.0");
Console.ReadKey();
return;
}
var activityFile = args[0];
var precedenceFile = args[1];
var sequenceFile = args[2];
var privacyBudget = Double.Parse(args[3], new CultureInfo("en"));
Agent = new PINQAgentObservableBudget(privacyBudget);
ActToId = cc.Read <ActivityEntry>(activityFile, inputFileDescription).ToDictionary(a => a.Activity, a => a.Id);
IdToAct = cc.Read <ActivityEntry>(activityFile, inputFileDescription).ToDictionary(a => a.Id, a => a.Activity);
var activities = ActToId.Select(a => a.Key).ToArray();
Relations = activities.SelectMany(x => activities.Select(y => x + "," + y)).ToArray();
wrapPrecedenceTable(precedenceFile);
wrapSequenceTable(sequenceFile);
/**** Data is now sealed up. Use from this point on is unrestricted ****/
using (var server = new RestServer())
{
server.LogToConsole().Start();
Console.WriteLine("Type 'exit' to stop server!");
var line = Console.ReadLine();
while (line != "exit")
{
line = Console.ReadLine();
}
server.Stop();
}
}
static void Main(string[] args)
{
if (config.Inventory.LoadNodesOnStartUp)
{
Console.WriteLine("Loading Inventory...");
inventoryClient.LoadInventory();
}
using (var server = new RestServer())
{
server.Host = config.RESTServerConfig.Host;
server.Port = config.RESTServerConfig.Port.ToString();
server.Advanced.AuthenticationSchemes = System.Net.AuthenticationSchemes.Basic;
server.LogToConsole().Start();
if (config.Inventory.LoadNodesOnStartUp)
{
Console.WriteLine("Connecting Inventory...");
inventoryClient.ConnectInventory();
// Inventory Reload
InventoryReloadTimer.Elapsed += (s, ea) => {
inventoryClient.LoadInventory();
inventoryClient.ConnectInventory();
};
InventoryReloadTimer.Enabled = true;
}
Console.ReadLine();
server.Stop();
Console.WriteLine("Disconnecting Inventory...");
InventoryReloadTimer.Enabled = false;
inventoryClient.DisconnectInventory();
}
}
static void Main(string[] args)
{
Metric.Config
.WithHttpEndpoint("http://localhost:8888/")
.WithAllCounters();
Console.CancelKeyPress += (s, ev) => {
Console.WriteLine("[CTRL]+[C] pressed!");
ev.Cancel = true;
};
var host = "+";
var port = "1234";
using (var server = new RestServer())
{
server.Port = port;
server.Host = host;
server.LogToConsole().Start();
Console.ReadLine();
server.Stop();
}
}
