internal WebServerOnlyRunner(
ILogger logger,
IEventSubscriptionManager eventSubscriptionManager,
IEventPublisher eventPublisher,
IWebServer webServer,
Uri testHtmlPageUrl,
string xapPath)
{
_logger = logger;
_eventSubscriptionManager = eventSubscriptionManager;
_webServer = webServer;
_testHtmlPageUrl = testHtmlPageUrl;
_xapPath = xapPath;
_testResultAggregator = new TestResultAggregator(logger, eventPublisher, _xapPath);
_eventSubscriptionManager.AddListener(_testResultAggregator);
_continuousRunnerThread = new Thread(() =>
{
string line;
do
{
line = Console.ReadLine();
} while (line.ToLower(CultureInfo.CurrentCulture) != "exit");
//string line;
//while ((line = System.Console.ReadLine())
// .ToLower(CultureInfo.CurrentCulture) != "exit")
//{
// ;
//}
});
}
public WelcomePageImpl(ISolutionFolder solutionFolder, IDefaultDocumentPolicy defaultDocumentPolicy, IItemOperations itemOperations, IWebServer server)
{
_solutionFolder = solutionFolder;
_itemOperations = itemOperations;
_defaultDocumentPolicy = defaultDocumentPolicy;
_server = server;
}
public static void Main()
{
var kernel = new StandardKernel(new WebServerModule());
IWebServer webServer = kernel.Get <IWebServer>();
webServer.Start();
}
public LocalUserLogonerForAccessThroughGroup(string username, string password, string groupname, IWebServer webServer)
{
UserName = username;
Password = password;
GroupName = groupname;
WebServer = webServer;
HttpWebClient httpWebClient = new HttpWebClient();
WebServerTestBase.LoginAsRoot(httpWebClient, webServer);
HttpResponseHandler webResponse;
webResponse = httpWebClient.Post("http://localhost:" + WebServer.Port + "/Users/UserDB?Method=CreateUser",
new KeyValuePair<string, string>("username", username),
new KeyValuePair<string, string>("displayName", username),
new KeyValuePair<string, string>("password", password),
new KeyValuePair<string, string>("assignSession", false.ToString()));
Assert.AreEqual(HttpStatusCode.Created, webResponse.StatusCode, "Bad status code");
webResponse = httpWebClient.Post("http://localhost:" + WebServer.Port + "/Users/UserDB?Method=CreateGroup",
new KeyValuePair<string, string>("groupname", groupname),
new KeyValuePair<string, string>("username", "root"));
Assert.AreEqual(HttpStatusCode.Created, webResponse.StatusCode, "Bad status code");
Assert.AreEqual(groupname + " created", webResponse.AsString(), "Unexpected response");
webResponse = httpWebClient.Get("http://localhost:" + WebServer.Port + "/Users/UserDB",
new KeyValuePair<string, string>("Method", "AddUserToGroup"),
new KeyValuePair<string, string>("username", username),
new KeyValuePair<string, string>("groupname", groupname));
Assert.AreEqual(HttpStatusCode.OK, webResponse.StatusCode, "Bad status code");
Assert.AreEqual(username + " added to " + groupname, webResponse.AsString(), "Unexpected response");
}
public NewBuild(IVisualStudio vs, INUnit nunit, IWebServer webServer)
{
Vs = vs;
NUnit = nunit;
NUnit.NUnitConsolePath = @".\References\NUnit\nunit-console.exe";
WebServer = webServer;
}
/// <summary>
/// Load all the WebApi Controllers in an assembly.
/// </summary>
/// <param name="webserver">The webserver instance.</param>
/// <param name="assembly">The assembly to load WebApi Controllers from. Leave null to load from the currently executing assembly.</param>
/// <param name="responseJsonException">if set to <c>true</c> [response json exception].</param>
/// <returns>
/// An instance of webserver.
/// </returns>
/// <exception cref="ArgumentNullException">webserver.</exception>
/// <exception cref="System.ArgumentNullException">webserver.</exception>
public static IWebServer LoadApiControllers(this IWebServer webserver, Assembly assembly = null, bool responseJsonException = false)
{
if (webserver == null)
{
throw new ArgumentNullException(nameof(webserver));
}
var types = (assembly ?? Assembly.GetEntryAssembly()).GetTypes();
var apiControllers = types
.Where(x => x.GetTypeInfo().IsClass &&
!x.GetTypeInfo().IsAbstract &&
x.GetTypeInfo().IsSubclassOf(typeof(WebApiController)))
.ToArray();
foreach (var apiController in apiControllers)
{
if (webserver.Module <WebApiModule>() == null)
{
webserver = webserver.WithWebApi(responseJsonException: responseJsonException);
}
webserver.Module <WebApiModule>().RegisterController(apiController);
$"Registering WebAPI Controller '{apiController.Name}'".Debug(nameof(LoadApiControllers));
}
return(webserver);
}
public NewBuild(IVisualStudio vs, INUnit nunit, IWebServer webServer)
{
Vs = vs;
NUnit = nunit;
NUnit.NUnitConsolePath = @".\References\NUnit\nunit-console.exe";
WebServer = webServer;
}
private void SwitchToConfigurationMode()
{
StopEverything();
var yard = new ConstructionYard(_factory, _rootDir);
_webServer = yard.BuildConfigurationMode(_factory.WebServerPort);
}
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
var handled = false;
var request = args.Request;
var response = args.Response;
if (String.Equals(request.HttpMethod, "OPTIONS", StringComparison.OrdinalIgnoreCase))
{
handled = true;
HandleOptionsRequest(request, response);
}
else
{
if (_CorsEnabled)
{
var origin = request.CorsOrigin;
if (OriginIsAllowed(request, origin))
{
request.IsValidCorsRequest = true;
}
}
}
return(handled);
}
public WebManager(INetworkService networkService, IWebServer webServer, IConsoleWriter consoleWriter, IFileService fileService)
{
_networkService = networkService;
_webServer = webServer;
_consoleWriter = consoleWriter;
_fileService = fileService;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="webServer">Web server</param>
/// <param name="rawArguments">Raw arguments</param>
/// <param name="standardOutput">Standard output</param>
/// <param name="errorOutput">Error output</param>
public CommandContext(IWebServer webServer, string rawArguments, TextWriter standardOutput, TextWriter errorOutput)
{
this.webServer = webServer;
this.rawArguments = rawArguments;
this.standardOutput = standardOutput;
this.errorOutput = errorOutput;
}
public void StartAPIServer()
{
//_webServer = NetworkServices.GetWebServer();
_webServer = SLWIOC.Create <IWebServer>();
_webServer.RegisterAPIHandler(new HandlerOne());
_webServer.StartServer(80);
}
public HttpListenerWebConnection(IWebServer webServer, HttpListenerContext context)
: base(webServer, CallingFrom.Web)
{
Context = context;
Request = Context.Request;
Response = Context.Response;
}
internal ContinuousConsoleRunner(
ILogger logger,
IEventSubscriptionManager eventSubscriptionManager,
IEventPublisher eventPublisher ,
string xapPath,
ClientTestRunConfiguration clientTestRunConfiguration,
IWebServer webServer,
IWebBrowser webBrowser)
{
_xapPath = xapPath;
_webServer = webServer;
_xapFileBuildChangedMonitor = new XapFileBuildChangedMonitor(eventPublisher, _xapPath);
_continuousRunnerThread = new Thread(() =>
{
using (var runner = new ContinuousTestRunner(logger, eventSubscriptionManager, eventPublisher, webBrowser, clientTestRunConfiguration, _xapPath))
{
string line;
while (!(line = System.Console.ReadLine()).Equals("exit", StringComparison.OrdinalIgnoreCase))
{
runner.ForceFilteredTest(line);
}
}
});
}
private async Task InitGenericEndpoints(IWebServer server, string sessionKey, string ip, IEnumerable <FileSendInfo> files, CancellationToken cancellationToken = default(CancellationToken))
{
await InitQueueDataEndpoint(server, sessionKey, ip, files);
InitFinishQueueEndpoint(server, sessionKey);
InitVersionCheckEndpoint(server, sessionKey);
}
public static void Hook()
{
// Prevent the server from starting up again once it is terminated.
if (_stopping) { return; }
lock (_lockObject)
{
if (_webServer == null)
{
try
{
_webServer = new IntegratedWebServer();
_webServer.Start();
GnomanEmpire.Instance.Exiting += OnExiting;
}
catch (Exception ex)
{
LogException(ex);
// It's important that we still throw an exception here.
// Exceptions thrown at this point are undoubtedly on the GnomanEmpire.Instance property.
// So, exit here to avoid the risk of bricking someone's game save.
throw;
}
}
}
}
/// <summary>
/// See base class.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
bool result = false;
if (!args.IsInternetRequest || _InternetClientCanRequestAudio)
{
if (args.PathAndFile.Equals("/Audio", StringComparison.OrdinalIgnoreCase))
{
string command = (string)args.QueryString["cmd"];
if (command != null && command.Equals("say", StringComparison.OrdinalIgnoreCase))
{
var text = args.QueryString["line"];
if (text != null)
{
result = true;
IAudio audio = Factory.Singleton.Resolve <IAudio>();
Responder.SendAudio(args.Response, audio.SpeechToWavBytes(text), MimeType.WaveAudio);
args.Classification = ContentClassification.Audio;
}
}
}
}
return(result);
}
private string SendFinished(IWebServer sender, RequestDetails request)
{
try
{
var query = QueryHelpers.ParseQuery(request.Url.Query);
var success = (query["success"][0].ToLower() == "true");
var message = "";
string[] parts = request.Url.AbsolutePath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
var key = parts[0];
if (success)
{
FileTransferProgressInternal?.Invoke(this, new FileTransferProgressEventArgs {
CurrentPart = keyTable[key].lastSliceId + 1, Total = keyTable[key].lastSliceId + 1, State = FileTransferState.Finished
});
}
else
{
message = query["message"][0];
FileTransferProgressInternal?.Invoke(this, new FileTransferProgressEventArgs {
CurrentPart = keyTable[key].lastSliceId + 1, Total = keyTable[key].lastSliceId + 1, State = FileTransferState.Error, Message = message
});
}
fileSendTcs?.TrySetResult(message);
}
catch (Exception ex)
{
fileSendTcs?.TrySetResult(ex.Message);
}
return("OK");
}
public Initialiser(IDatabaseInitialiser databaseInitialiser, IWebServer webServer, ISmtpServer smtpServer, IEmailRecorder emailRecorder)
{
_databaseInitialiser = databaseInitialiser;
_webServer = webServer;
_smtpServer = smtpServer;
_emailRecorder = emailRecorder;
}
private void Simulate()
{
_logger.Information(string.Format("Start running the simulation for the specified pact on port {0}", _port));
_webServer = new WebServer(_logger);
_webServer.Simulate(PactCallback, _port);
}
internal WebServerOnlyRunner(
ILogger logger,
IEventSubscriptionManager eventSubscriptionManager,
IEventPublisher eventPublisher,
IWebServer webServer,
Uri testHtmlPageUrl,
string xapPath)
{
_logger = logger;
_eventSubscriptionManager = eventSubscriptionManager;
_webServer = webServer;
_testHtmlPageUrl = testHtmlPageUrl;
_xapPath = xapPath;
_testResultAggregator = new TestResultAggregator(logger, eventPublisher, _xapPath);
_eventSubscriptionManager.AddListener(_testResultAggregator);
_continuousRunnerThread = new Thread(() =>
{
string line;
do
{
line = Console.ReadLine();
} while (line.ToLower(CultureInfo.CurrentCulture) != "exit");
//string line;
//while ((line = System.Console.ReadLine())
// .ToLower(CultureInfo.CurrentCulture) != "exit")
//{
// ;
//}
});
}
public override void EstablishContext()
{
WebServer = SubstituteFor <IWebServer>();
WebDriver = SubstituteFor <IWebDriver>();
ContainerDisposal = Substitute.For <IDisposable>();
AutoSubstitute.Container.Disposer.AddInstanceForDisposal(ContainerDisposal);
}
/// <summary>
/// Load an Assembly
/// </summary>
/// <param name="apiPath"></param>
/// <param name="server"></param>
private static void LoadApi(IWebServer server, string apiPath)
{
try
{
var fullPath = Path.GetFullPath(apiPath);
if (Path.GetExtension(apiPath).Equals(".dll"))
{
var assembly = Assembly.LoadFile(fullPath);
server.LoadApiControllers(assembly).LoadWebSockets(assembly);
}
else
{
var files = Directory.GetFiles(fullPath, "*.dll");
foreach (var file in files)
{
var assembly = Assembly.LoadFile(file);
server.LoadApiControllers(assembly).LoadWebSockets(assembly);
}
}
}
catch (FileNotFoundException fileEx)
{
$"Assembly FileNotFoundException {fileEx.Message}".Debug(nameof(Program));
}
catch (Exception ex)
{
$"Assembly Exception {ex.Message}".Debug(nameof(Program));
ex.Log(nameof(Program));
}
}
internal ContinuousConsoleRunner(
ILogger logger,
IEventSubscriptionManager eventSubscriptionManager,
IEventPublisher eventPublisher,
string xapPath,
ClientTestRunConfiguration clientTestRunConfiguration,
IWebServer webServer,
IWebBrowser webBrowser)
{
_xapPath = xapPath;
_webServer = webServer;
_xapFileBuildChangedMonitor = new XapFileBuildChangedMonitor(eventPublisher, _xapPath);
_continuousRunnerThread = new Thread(() =>
{
using (var runner = new ContinuousTestRunner(logger, eventSubscriptionManager, eventPublisher, webBrowser, clientTestRunConfiguration, _xapPath))
{
string line;
while (!(line = System.Console.ReadLine()).Equals("exit", StringComparison.OrdinalIgnoreCase))
{
runner.ForceFilteredTest(line);
}
}
});
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="view"></param>
public void Initialise(IMainView view)
{
if (view == null)
{
throw new ArgumentNullException("view");
}
View = view;
View.CheckForNewVersion += View_CheckForNewVersion;
View.ReconnectToBaseStationClicked += View_ReconnectToBaseStationClicked;
View.ToggleServerStatus += View_ToggleServerStatus;
View.ToggleUPnpStatus += View_ToggleUPnpStatus;
View.LogFileName = Factory.Singleton.Resolve <ILog>().Singleton.FileName;
View.InvalidPluginCount = Factory.Singleton.Resolve <IPluginManager>().Singleton.IgnoredPlugins.Count;
if (_BaseStationAircraftList != null)
{
View.AircraftCount = _BaseStationAircraftList.Count;
}
var heartbeatService = Factory.Singleton.Resolve <IHeartbeatService>().Singleton;
heartbeatService.SlowTick += HeartbeatService_SlowTick;
heartbeatService.FastTick += HeartbeatService_FastTick;
var newVersionChecker = Factory.Singleton.Resolve <INewVersionChecker>().Singleton;
newVersionChecker.NewVersionAvailable += NewVersionChecker_NewVersionAvailable;
_AutoConfigListener = Factory.Singleton.Resolve <IAutoConfigListener>().Singleton;
_AutoConfigListener.Listener.ConnectionStateChanged += BaseStationListener_ConnectionStateChanged;
View.BaseStationTotalMessages = _AutoConfigListener.Listener.TotalMessages;
View.BaseStationConnectionStatus = _AutoConfigListener.Listener.ConnectionStatus;
View.BaseStationTotalBadMessages = _AutoConfigListener.Listener.TotalBadMessages;
_WebServer = Factory.Singleton.Resolve <IAutoConfigWebServer>().Singleton.WebServer;
_WebServer.ExternalAddressChanged += WebServer_ExternalAddressChanged;
_WebServer.OnlineChanged += WebServer_OnlineChanged;
_WebServer.ResponseSent += WebServer_ResponseSent;
View.WebServerIsOnline = _WebServer.Online;
View.WebServerLocalAddress = _WebServer.LocalAddress;
View.WebServerNetworkAddress = _WebServer.NetworkAddress;
View.WebServerExternalAddress = _WebServer.ExternalAddress;
var pluginManager = Factory.Singleton.Resolve <IPluginManager>().Singleton;
foreach (var plugin in pluginManager.LoadedPlugins)
{
plugin.GuiThreadStartup();
}
var rebroadcastServerManager = Factory.Singleton.Resolve <IRebroadcastServerManager>().Singleton;
rebroadcastServerManager.BroadcastSent += RebroadcastServerManager_BroadcastSent;
rebroadcastServerManager.ClientConnected += RebroadcastServerManager_ClientConnected;
rebroadcastServerManager.ClientDisconnected += RebroadcastServerManager_ClientDisconnected;
var configurationStorage = DisplayConfigurationSettings();
configurationStorage.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="server"></param>
public void AttachSiteToServer(IWebServer server)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
if (WebServer != server)
{
if (WebServer != null)
{
throw new InvalidOperationException("The web site can only be attached to one server");
}
_UserManager = Factory.Singleton.Resolve <IUserManager>().Singleton;
var configurationStorage = Factory.Singleton.Resolve <IConfigurationStorage>().Singleton;
configurationStorage.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
WebServer = server;
server.Root = "/VirtualRadar";
var installerSettingsStorage = Factory.Singleton.Resolve <IInstallerSettingsStorage>();
var installerSettings = installerSettingsStorage.Load();
server.Port = installerSettings.WebServerPort;
server.AuthenticationRequired += Server_AuthenticationRequired;
_Bundler = Factory.Singleton.Resolve <IBundler>();
_Bundler.AttachToWebSite(this);
_Minifier = Factory.Singleton.Resolve <IMinifier>();
_Minifier.Initialise();
_Pages.Add(_CorsPreflightPage);
_Pages.Add(_FileSystemPage);
_Pages.Add(new TextPage(this));
_Pages.Add(_AircraftListJsonPage);
_Pages.Add(_ImagePage);
_Pages.Add(new ServerConfigJsonPage(this));
_Pages.Add(new AudioPage(this));
_Pages.Add(new FaviconPage(this));
_Pages.Add(_ReportRowsJsonPage);
_Pages.Add(_ClosestAircraftJsonPage);
_Pages.Add(new AirportDataProxyPage(this));
_Pages.Add(new PolarPlotJsonPage(this));
_Pages.Add(new DirectoryEntryJsonPage(this));
_JavaScriptInjectors.Add(new WebSiteStringsInjector());
foreach (var page in _Pages)
{
page.Provider = Provider;
}
LoadConfiguration();
server.RequestReceived += Server_RequestReceived;
}
}
//TODO: Better Dispose
public void Dispose()
{
if (_webServer != null)
{
_webServer.Dispose();
_webServer = null;
}
}
public WebServer(MhfSetting setting, IWebServer server)
{
_logger = LogProvider.Logger(this);
_server = server;
_router = new WebRouter(setting);
_server.SetHandler(this);
_middlewareStack = new WebMiddlewareStack(_router.Route);
}
public AppServer(IWebServer webServer, IBuildAgent buildAgent)
{
BuildAgent = buildAgent;
Ensure.That(() => webServer).IsNotNull();
Ensure.That(() => buildAgent).IsNotNull();
_webServer = webServer;
}
public void StartModules(IWebServer webServer, CancellationToken ct)
{
foreach (var module in _modules)
{
module.Server = webServer;
module.Start(ct);
}
}
/// <summary>
/// On unload
/// </summary>
/// <param name="webServer">Web server</param>
public void OnUnload(IWebServer webServer)
{
webServer.StandardOutput.WriteLine("");
webServer.StandardOutput.WriteLine("\t=============================");
webServer.StandardOutput.WriteLine("\t= Angasal example unloaded! =");
webServer.StandardOutput.WriteLine("\t=============================");
webServer.StandardOutput.WriteLine("");
}
/// <summary>
/// Create a SelenoApplication
/// </summary>
/// <param name="container">An Autofac container that will be owned by the SelenoApplication and disposed by the SelenoApplication</param>
public SelenoApplication(IContainer container)
{
_container = container;
_webDriver = _container.Resolve <IWebDriver>();
_camera = _container.Resolve <ICamera>();
_logger = _container.Resolve <ILoggerFactory>().Create(GetType());
_webServer = _container.Resolve <IWebServer>();
}
public void Stop()
{
if (webServer != null)
{
(webServer as IDisposable)?.Dispose();
webServer = null;
}
}
private static async Task InitQueueDataEndpoint(IWebServer server, string sessionKey, string ip, IEnumerable <FileSendInfo> files)
{
FileInfoListGenerator generator = new FileInfoListGenerator(files, ip);
var queueData = await generator.GenerateAsync();
server.AddResponseUrl($"/{sessionKey}/", queueData.FileInfoListJsonLegacy);
server.AddResponseUrl($"/{sessionKey}/queueInfo/", queueData.FileInfoListJson);
}
/// <summary>
/// See base class.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
bool result = false;
if(args.PathAndFile.Equals("/AircraftList.json", StringComparison.OrdinalIgnoreCase)) result = HandleAircraftListJson(args, BaseStationAircraftList, false);
else if(args.PathAndFile.Equals("/FlightSimList.json", StringComparison.OrdinalIgnoreCase)) result = HandleAircraftListJson(args, FlightSimulatorAircraftList, true);
return result;
}
public string SetServer(IWebServer server)
{
m_Server = server;
if (m_Server != null)
{
Console.WriteLine("Bind server to network service: " + m_Server.GetProtocol() + " on " + m_Server.GetPort());
}
return("");
}
protected RequestHandlerBase(IWebServer server, Guid handlerID, String name, String author, int priority, String mainPath)
{
_server = server;
_handlerID = handlerID;
_name = name;
_author = author;
_priority = priority;
_mainPath = mainPath;
}
/// <summary>
/// On load
/// </summary>
/// <param name="webServer">Web server</param>
public void OnLoad(IWebServer webServer)
{
this.webServer = webServer;
webServer.StandardOutput.WriteLine("");
webServer.StandardOutput.WriteLine("\t===========================");
webServer.StandardOutput.WriteLine("\t= Angasal example loaded! =");
webServer.StandardOutput.WriteLine("\t===========================");
webServer.StandardOutput.WriteLine("");
}
public void Remote_server_does_nothing()
{
using (IWebServer server = WebServerFactory.CreateWebServer("Remote", "http://www.bing.com/", null, 0))
using (Browser browser = new IE(server.RootUrl))
{
browser.WaitForComplete();
Assert.Equal("Bing", browser.Title);
}
}
public void StartWebServer(int port, string name)
{
_deviceName = name;
_webServer = NetworkServices.GetWebServer();
_webServer.RegisterAPIHandler(new Api.MotionApi(_soccerBot, _logger));
_webServer.DefaultPageHtml = GetDefaultPageHTML("Ready");
_webServer.StartServer(port);
}
protected WebConnectionBase(IWebServer webServer, CallingFrom callingFrom, uint generation)
: this(webServer, callingFrom)
{
// Prevent stack overflow. TODO, make the maximum generation configurable
if (generation > 250)
throw new WebResultsOverrideException(
WebResults.From(Status._500_Internal_Server_Error, "Stack overflow, too many levels of shells"));
_Generation = generation;
}
public static void Main(string[] args)
{
webServer = new WebServer(1337);
webServer.Run();
browser = new ChromiumHeadlessBrowserWithCefSharp("http://127.0.0.1:1337/index.html", 1024, 768);
browser.PageReady += BrowserPageReady;
Console.ReadLine();
}
public AjaxAuthorizationBehavior(
IOutputWriter writer,
IActionBehavior actionBehavior,
ISecureSession<Token> secureSession,
IWebServer webServer)
{
_writer = writer;
_actionBehavior = actionBehavior;
_secureSession = secureSession;
_webServer = webServer;
}
public static void LoginAsRoot(HttpWebClient httpWebClient, IWebServer webServer)
{
// Log in as root
HttpResponseHandler webResponse = httpWebClient.Post(
"http://localhost:" + webServer.Port + "/Users/UserDB?Method=Login",
new KeyValuePair<string, string>("username", "root"),
new KeyValuePair<string, string>("password", "root"));
Assert.AreEqual(HttpStatusCode.Accepted, webResponse.StatusCode, "Bad status code");
Assert.AreEqual("root logged in", webResponse.AsString(), "Unexpected response");
}
public AjaxExceptionHandlerBehavior(
IActionBehavior innerBehavior,
IOutputWriter outputWriter,
ILogger logger,
IWebServer webServer)
{
_innerBehavior = innerBehavior;
_outputWriter = outputWriter;
_logger = logger;
_webServer = webServer;
ReturnError = Assembly.GetExecutingAssembly().IsInDebugMode();
}
/// <summary>
/// See base class.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
bool result = false;
if(args.PathAndFile.Equals("/favicon.ico", StringComparison.OrdinalIgnoreCase)) {
result = true;
Responder.SendBinary(args.Response, _Icon, MimeType.IconImage);
args.Classification = ContentClassification.Other;
}
return result;
}
public BlockingShellWebConnection(
IWebServer webServer,
ISession session,
string url,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom,
WebMethod method)
: base(webServer, session, url, content, contentType, cookiesFromBrowser, callingFrom, method)
{
}
private static void Warmup(IWebServer server)
{
var req = WebRequest.Create("http://localhost:" + server.Port);
req.Timeout = 1000;
try
{
req.GetResponse();
}
catch (WebException ex)
{
// ignore exceptions. An exception can be thrown if a 404 was returned
// which is a possibility if the application doesn't have `~/' endpoint
}
}
internal TeamCityRunner(
ILogger logger,
IEventSubscriptionManager eventSubscriptionManager,
IEventPublisher eventPublisher,
IWebServer webServer,
List<IWebBrowser> webBrowsers,
TeamCityTestResultHandler teamCityTestResultHandler,
string xapPath,
IDialogMonitorRunner dialogMonitorRunner)
: base(logger, eventSubscriptionManager, eventPublisher, webServer, webBrowsers, xapPath, dialogMonitorRunner)
{
_eventSubscriptionManager = eventSubscriptionManager;
_teamCityTestResultHandler = teamCityTestResultHandler;
}
private void StopEverything()
{
if (_controller != null)
{
_controller.Stop();
_controller.Dispose();
_controller = null;
}
if (_webServer != null)
{
_webServer.Stop();
_webServer.Dispose();
_webServer = null;
}
_factory.CreateGarbage().Collect();
}
public static int RunWebServer(IWebServer webServer, Logger log, ManualResetEvent exitLatch)
{
try
{
log.Info("Starting web server instance...");
webServer.Start();
Console.WriteLine("Server Started.... press CTRL + C to stop");
Warmup(webServer);
exitLatch.WaitOne();
Console.WriteLine("Server shutting down, please wait...");
webServer.Stop();
return 0;
}
catch (WebCorePortException)
{
log.Error("Please allow the user to access the port. eg. 'netsh http add urlacl url=http://*:9999/ user={0}'", WindowsIdentity.GetCurrent().Name);
return 1;
}
}
/// <summary>
/// See base class.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
bool result = false;
if(!args.IsInternetRequest || _InternetClientCanRequestAudio) {
if(args.PathAndFile.Equals("/Audio", StringComparison.OrdinalIgnoreCase)) {
string command = (string)args.QueryString["cmd"];
if(command != null && command.Equals("say", StringComparison.OrdinalIgnoreCase)) {
var text = args.QueryString["line"];
if(text != null) {
result = true;
IAudio audio = Factory.Singleton.Resolve<IAudio>();
Responder.SendAudio(args.Response, audio.SpeechToWavBytes(text), MimeType.WaveAudio);
args.Classification = ContentClassification.Audio;
}
}
}
}
return result;
}
public OpenIDLogonerThroughObjectCloud(string name, string password, IWebServer secondWebServer)
{
Name = name;
Password = password;
SecondWebServer = secondWebServer;
HttpWebClient httpWebClient = new HttpWebClient();
WebServerTestBase.LoginAsRoot(httpWebClient, SecondWebServer);
HttpResponseHandler webResponse;
webResponse = httpWebClient.Post("http://localhost:" + SecondWebServer.Port + "/Users/UserDB?Method=CreateUser",
new KeyValuePair<string, string>("username", name),
new KeyValuePair<string, string>("displayName", name),
new KeyValuePair<string, string>("password", password));
Assert.AreEqual(HttpStatusCode.Created, webResponse.StatusCode, "Bad status code");
webResponse = httpWebClient.Get("http://localhost:" + SecondWebServer.Port + "/Users/" + name + ".user");
Assert.AreEqual(HttpStatusCode.OK, webResponse.StatusCode, "Bad status code");
Thread.Sleep(2000);
}
public OpenIDLogonerThroughObjectCloud(string name, string password, IWebServer webServer, IWebServer secondWebServer)
: this(name, password, secondWebServer)
{
HttpWebClient httpWebClient = new HttpWebClient();
WebServerTestBase.LoginAsRoot(httpWebClient, webServer);
HttpResponseHandler webResponse = httpWebClient.Post(
"http://localhost:" + webServer.Port + "/?Method=CreateFile",
new KeyValuePair<string, string>("FileName", name),
new KeyValuePair<string, string>("FileType", "directory"));
Assert.AreEqual(HttpStatusCode.Created, webResponse.StatusCode, "Bad status code");
webResponse = httpWebClient.Post(
"http://localhost:" + webServer.Port + "/?Method=SetFilePermission",
new KeyValuePair<string, string>("FileName", name),
new KeyValuePair<string, string>("UserOrGroup", Name),
new KeyValuePair<string, string>("FilePermission", FilePermissionEnum.Administer.ToString()));
Assert.AreEqual(HttpStatusCode.Accepted, webResponse.StatusCode, "Bad status code");
_WritableDirectory = "/" + _Name + "/";
}
/// <summary>
/// See base class.
/// </summary>
/// <param name="server"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override bool DoHandleRequest(IWebServer server, RequestReceivedEventArgs args)
{
bool result = false;
var key = args.PathAndFile.ToUpper();
if(key == "/") {
switch(args.Request.Url.Scheme) {
case "http":
case "https":
int defaultPort = args.Request.Url.Scheme == "http" ? 80 : 443;
string redirectUrl = String.Format("{0}{1}{2}",
args.Request.Url.AbsoluteUri,
args.Request.Url.AbsoluteUri.EndsWith("/") ? "" : "/",
args.IsAndroid || args.IsIPad || args.IsIPhone || args.IsIPod ? "iPhoneMap.htm" : "GoogleMap.htm");
result = true;
args.Response.Redirect(redirectUrl);
break;
default:
break;
}
} else {
Content content;
result = _PathAndFileToContentMap.TryGetValue(key, out content);
if(result) {
string text = content.Text;
if(key == "/SERVERCONFIG.JS") {
text = text.Replace("__IS_LOCAL_ADDRESS", args.IsInternetRequest ? "false" : "true");
}
Responder.SendText(args.Response, text, Encoding.UTF8, content.MimeType);
args.Classification = ContentClassification.Html;
}
}
return result;
}
public void TestInitialise()
{
_OriginalFactory = Factory.TakeSnapshot();
_WebServer = Factory.Singleton.Resolve<IWebServer>();
_Now = DateTime.UtcNow;
_Provider = new Mock<IWebServerProvider>() { DefaultValue = DefaultValue.Mock }.SetupAllProperties();
_Provider.Setup(m => m.IsListening).Returns(true);
_Provider.Setup(m => m.UtcNow).Returns(() => { return _Now; });
_Provider.Object.AuthenticationSchemes = AuthenticationSchemes.Anonymous;
_WebServer.Provider = _Provider.Object;
_Context = new Mock<IContext>() { DefaultValue = DefaultValue.Mock }.SetupAllProperties();
_Request = new Mock<IRequest>() { DefaultValue = DefaultValue.Mock }.SetupAllProperties();
_Request.Setup(m => m.RemoteEndPoint).Returns(new IPEndPoint(0x0100007fL, 12000));
_Response = new Mock<IResponse>() { DefaultValue = DefaultValue.Mock }.SetupAllProperties();
_OutputStream = new MemoryStream();
_Response.Setup(m => m.OutputStream).Returns(_OutputStream);
_Context.Setup(m => m.Request).Returns(_Request.Object);
_Context.Setup(m => m.Response).Returns(_Response.Object);
_OnlineChangedEvent = new EventRecorder<EventArgs>();
_AuthenticationRequiredEvent = new EventRecorder<AuthenticationRequiredEventArgs>();
_BeforeRequestReceivedEvent = new EventRecorder<RequestReceivedEventArgs>();
_RequestReceivedEvent = new EventRecorder<RequestReceivedEventArgs>();
_AfterRequestReceivedEvent = new EventRecorder<RequestReceivedEventArgs>();
_ResponseSentEvent = new EventRecorder<ResponseSentEventArgs>();
_ExceptionCaughtEvent = new EventRecorder<EventArgs<Exception>>();
_ExternalAddressChangedEvent = new EventRecorder<EventArgs>();
_WebServer.ExceptionCaught += DefaultExceptionCaughtHandler;
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="baseStationAircraftList"></param>
/// <param name="flightSimulatorAircraftList"></param>
/// <param name="webServer"></param>
public void Initialise(IBaseStationAircraftList baseStationAircraftList, ISimpleAircraftList flightSimulatorAircraftList, IWebServer webServer)
{
_BaseStationAircraftList = baseStationAircraftList;
_FlightSimulatorAircraftList = flightSimulatorAircraftList;
_WebServer = webServer;
}
private void ReportWebServerStartupFailure(IWebServer webServer, Exception ex)
{
Factory.Singleton.Resolve<ILog>().Singleton.WriteLine("Caught exception when starting web server: {0}", ex.ToString());
_View.ReportProblem(String.Format(Strings.CannotStartWebServerFull, webServer.Port), Strings.CannotStartWebServerTitle, false);
_View.ReportProblem(Strings.SuggestUseDifferentPortFull, Strings.SuggestUseDifferentPortTitle, false);
}
/// <summary>
/// Constructor for when a web request is generated publicly instead of externally
/// </summary>
/// <param name="webServer"></param>
/// <param name="session"></param>
/// <param name="url"></param>
/// <param name="content"></param>
/// <param name="contentType"></param>
/// <param name="cookiesFromBrowser"></param>
/// <param name="callingFrom"></param>
/// <param name="method"></param>
public ShellWebConnection(
IWebServer webServer,
ISession session,
string url,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom,
WebMethod method)
: base(webServer, callingFrom, 0)
{
_Content = new WebConnectionContent.InMemory(content);
_ContentType = contentType;
_Session = session;
_Method = method;
_CookiesFromBrowser = cookiesFromBrowser;
_CookiesToSet = new List<CookieToSet>();
_HttpVersion = 1;
_RequestedHost = null;
_Headers = new Dictionary<string, string>();
DetermineRequestedFileAndGetParameters(url);
TryDecodePostParameters();
if (null == BaseWebConnection)
BaseWebConnection = this;
}
public JettyWebConnection(IWebServer webServer, String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
: base(webServer, CallingFrom.Web)
{
Response = response;
BaseRequest = baseRequest;
Request = request;
_RequestedFile = target;
org.eclipse.jetty.io.EndPoint jettyEndpoint = baseRequest.getConnection().getEndPoint();
string remoteAddress = jettyEndpoint.getRemoteAddr();
int remotePort = jettyEndpoint.getRemotePort();
_RemoteEndPoint = new IPEndPoint(IPAddress.Parse(remoteAddress), remotePort);
}
