public static ServerParameters CreatePipe(IPortableEndPoint endpoint, PipeArguments arguments) { return(new ServerParameters(ServerMode.Local) { EndPoint = endpoint, Arguments = arguments }); }
public static ServerParameters WaitForConnection(IPortableEndPoint endpoint) { return(new ServerParameters(ServerMode.WaitForConnection) { EndPoint = endpoint }); }
public static ServerParameters IOS(IPortableEndPoint endpoint) { return(new ServerParameters(ServerMode.iOS) { EndPoint = endpoint }); }
public ProxyServer(IPortableEndPoint endpoint, IPortableEndPoint proxyEndpoint, ISslStreamProvider sslStreamProvider = null, ConnectionParameters parameters = null) : base(endpoint, endpoint, ListenerFlags.Proxy, parameters, sslStreamProvider) { this.proxyEndpoint = proxyEndpoint; proxyUri = new Uri(string.Format("http://{0}:{1}/", proxyEndpoint.Address, proxyEndpoint.Port)); }
public static async Task <TestServer> LaunchApplication(TestApp app, IPortableEndPoint address, ApplicationLauncher launcher, LauncherOptions options, CancellationToken cancellationToken) { var support = DependencyInjector.Get <IServerHost> (); var connection = await support.Listen(address, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); var sb = new StringBuilder(); sb.AppendFormat("connect {0}:{1}", address.Address, address.Port); if (options != null) { if (options.Category != null) { sb.AppendFormat(" --category={0}", options.Category); } if (options.Features != null) { sb.AppendFormat(" --features={0}", options.Features); } } launcher.LaunchApplication(sb.ToString()); var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); cts.CancelAfter(90000); bool launcherError = false; var launcherTask = launcher.WaitForExit().ContinueWith(t => { if (t.IsFaulted || t.IsCanceled || !t.Result) { launcherError = true; cts.Cancel(); } }); Stream stream; try { stream = await connection.Open(cts.Token); cts.Token.ThrowIfCancellationRequested(); } catch { if (launcherError || launcherTask.IsCanceled || cts.IsCancellationRequested) { throw new LauncherErrorException("Launcher exited abnormally before establishing connection."); } throw; } var launcherConnection = new LauncherConnection(app, stream, connection, launcher); var client = new Client(app, launcherConnection); await client.Initialize(cancellationToken); cts.Token.ThrowIfCancellationRequested(); return(client); }
public BuiltinProxyServer(HttpServer target, IPortableEndPoint listenAddress, HttpServerFlags flags) : base(listenAddress, flags | HttpServerFlags.Proxy, null, null) { Target = target; Uri = new Uri(string.Format("http://{0}:{1}/", ListenAddress.Address, ListenAddress.Port)); }
public static ServerParameters Android(IPortableEndPoint endpoint) { return(new ServerParameters(ServerMode.Android) { EndPoint = endpoint }); }
public static async Task <TestServer> CreatePipe(TestApp app, IPortableEndPoint endpoint, PipeArguments arguments, CancellationToken cancellationToken) { var support = DependencyInjector.Get <IServerHost> (); var connection = await support.CreatePipe(endpoint, arguments, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)) { EventHandler cancelFunc = delegate { try { cts.Cancel(); } catch { ; } }; connection.ExitedEvent += cancelFunc; if (connection.HasExited) { cancelFunc(null, EventArgs.Empty); } var stream = await connection.Open(cts.Token); cts.Token.ThrowIfCancellationRequested(); var clientConnection = new ClientConnection(app, stream, connection); var client = new Client(app, clientConnection); await client.Initialize(cts.Token); connection.ExitedEvent -= cancelFunc; return(client); } }
public async Task <IServerConnection> Connect(IPortableEndPoint endpoint, CancellationToken cancellationToken) { var networkEndpoint = PortableEndPointSupportImpl.GetEndpoint(endpoint); var client = new TcpClient(); await client.ConnectAsync(networkEndpoint.Address, networkEndpoint.Port); return(new ClientConnection(client)); }
public HttpsTestRunner(IPortableEndPoint endpoint, HttpsTestParameters parameters, ConnectionTestProvider provider, Uri uri, ListenerFlags flags) : base(endpoint, parameters) { Provider = provider; ListenerFlags = flags; Uri = uri; }
public BuiltinProxyServer(HttpServer target, IPortableEndPoint listenAddress, HttpServerFlags flags, AuthenticationType proxyAuth = AuthenticationType.None) : base(listenAddress, GetFlags(flags, target, proxyAuth), null, null) { Target = target; AuthenticationType = proxyAuth; Uri = new Uri(string.Format("http://{0}:{1}/", ListenAddress.Address, ListenAddress.Port)); }
public ProxyListener(HttpListener target, IPortableEndPoint endpoint, AuthenticationType authType) : base(endpoint, ListenerFlags.Proxy) { this.target = target; if (authType != AuthenticationType.None) { authManager = new ProxyAuthManager(authType); } }
static TestProxy() { var support = DependencyInjector.Get <IPortableEndPointSupport> (); address = support.GetEndpoint(0); serverCertificate = ResourceManager.SelfSignedServerCertificate; serverParameters = new ConnectionParameters("proxy", serverCertificate); }
protected AbstractConnection(IPortableEndPoint endpoint, ConnectionParameters parameters) { PortableEndPoint = endpoint; Parameters = parameters; if (PortableEndPoint != null) { EndPoint = new IPEndPoint(IPAddress.Parse(PortableEndPoint.Address), PortableEndPoint.Port); } }
public Task <IServerConnection> Listen(IPortableEndPoint endpoint, CancellationToken cancellationToken) { return(Task.Run <IServerConnection> (() => { var networkEndpoint = PortableEndPointSupportImpl.GetEndpoint(endpoint); var listener = new TcpListener(networkEndpoint); listener.Start(); Debug.WriteLine("Server started: {0}", listener.LocalEndpoint); return new ServerConnection(listener); })); }
public Task <IPipeConnection> CreatePipe(IPortableEndPoint endpoint, PipeArguments arguments, CancellationToken cancellationToken) { #if !__TVOS__ return(Task.Run <IPipeConnection> (() => { var networkEndpoint = PortableEndPointSupportImpl.GetEndpoint(endpoint); var listener = new TcpListener(networkEndpoint); listener.Start(); var monoPath = Path.Combine(arguments.MonoPrefix, "bin", "mono"); var cmd = new StringBuilder(); cmd.Append("--debug "); if (arguments.ConsolePath != null) { cmd.Append(arguments.ConsolePath); } else { cmd.Append(arguments.Assembly); } if (arguments.Dependencies != null) { foreach (var dependency in arguments.Dependencies) { cmd.AppendFormat(" --dependency={0}", dependency); } } cmd.AppendFormat(" --gui={0}:{1}", networkEndpoint.Address, networkEndpoint.Port); if (arguments.ExtraArguments != null) { cmd.AppendFormat(" {0}", arguments.ExtraArguments); } if (arguments.ConsolePath != null) { cmd.Append(" "); cmd.Append(arguments.Assembly); } var psi = new ProcessStartInfo(monoPath, cmd.ToString()); psi.UseShellExecute = false; foreach (var reserved in ReservedNames) { psi.EnvironmentVariables.Remove(reserved); } var process = Process.Start(psi); return new PipeConnection(listener, process); })); #else throw new NotSupportedException(); #endif }
public HttpValidationTestRunner(IPortableEndPoint endpoint, HttpValidationTestParameters parameters, ConnectionTestProvider provider, Uri uri, HttpServerFlags flags) { Parameters = parameters; Provider = provider; ServerFlags = flags; Uri = uri; Server = new BuiltinHttpServer(uri, endpoint, ServerFlags, parameters, null); ME = $"{GetType ().Name}({EffectiveType})"; }
public static async Task <TestServer> ConnectToServer(TestApp app, IPortableEndPoint address, CancellationToken cancellationToken) { var support = DependencyInjector.Get <IServerHost> (); var connection = await support.Connect(address, cancellationToken); var clientConnection = await StartClient(app, connection, cancellationToken); var client = new Client(app, clientConnection); await client.Initialize(cancellationToken); return(client); }
public static async Task <TestServer> StartServer(TestApp app, IPortableEndPoint address, TestFramework framework, CancellationToken cancellationToken) { var support = DependencyInjector.Get <IServerHost> (); var connection = await support.Listen(address, cancellationToken); var serverConnection = await StartServer(app, framework, connection, cancellationToken); var server = new Server(app, framework, serverConnection); await server.Initialize(cancellationToken); return(server); }
public HttpsTestRunner(IPortableEndPoint endpoint, HttpsTestParameters parameters, ConnectionTestProvider provider, Uri uri, HttpServerFlags flags) : base(endpoint, parameters) { Provider = provider; ServerFlags = flags; Uri = uri; Server = new BuiltinHttpServer(uri, endpoint, flags, parameters, null) { Delegate = this }; }
public HttpServer(Uri uri, IPortableEndPoint listenAddress, ListenerFlags flags, ConnectionParameters parameters, ISslStreamProvider sslStreamProvider = null) { this.uri = uri; this.listenAddress = listenAddress; this.flags = flags | ListenerFlags.SSL; this.sslStreamProvider = sslStreamProvider; this.parameters = parameters; if (this.sslStreamProvider == null) { var factory = DependencyInjector.Get <ConnectionProviderFactory> (); this.sslStreamProvider = factory.DefaultSslStreamProvider; } }
public HttpServer(IPortableEndPoint listenAddress, HttpServerFlags flags, ConnectionParameters parameters, ISslStreamProvider sslStreamProvider) { ListenAddress = listenAddress; Flags = flags; Parameters = parameters; SslStreamProvider = sslStreamProvider; if (Parameters != null) { Flags |= HttpServerFlags.SSL; } if ((Flags & HttpServerFlags.NoSSL) != 0) { Flags &= ~HttpServerFlags.SSL; } if ((Flags & HttpServerFlags.SSL) != 0) { if (SslStreamProvider == null) { var factory = DependencyInjector.Get <ConnectionProviderFactory> (); SslStreamProvider = factory.DefaultSslStreamProvider; } } else { SslStreamProvider = null; } var description = FormatFlags(Flags); if (!string.IsNullOrEmpty(description)) { description = ": " + description; } var identifier = parameters?.Identifier; if (identifier != null) { identifier = ": " + identifier; } ME = $"[{GetType ().Name}:{ID}{identifier}{description}]"; }
public static async Task <TestServer> WaitForConnection(TestApp app, IPortableEndPoint address, CancellationToken cancellationToken) { var support = DependencyInjector.Get <IServerHost> (); var connection = await support.Listen(address, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); var stream = await connection.Open(cancellationToken); cancellationToken.ThrowIfCancellationRequested(); var clientConnection = new ClientConnection(app, stream, connection); var client = new Client(app, clientConnection); await client.Initialize(cancellationToken); return(client); }
public Listener(IPortableEndPoint endpoint, ListenerFlags flags) { var ssl = (flags & ListenerFlags.SSL) != 0; if (ssl & (flags & ListenerFlags.Proxy) != 0) { throw new InvalidOperationException(); } var address = IPAddress.Parse(endpoint.Address); var networkEndpoint = new IPEndPoint(address, endpoint.Port); uri = new Uri(string.Format("http{0}://{1}:{2}/", ssl ? "s" : "", endpoint.Address, endpoint.Port)); server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); server.Bind(networkEndpoint); server.Listen(1); }
public HttpServer(IPortableEndPoint listenAddress, HttpServerFlags flags, ConnectionParameters parameters, ISslStreamProvider sslStreamProvider) { ListenAddress = listenAddress; Flags = flags; Parameters = parameters; SslStreamProvider = sslStreamProvider; if (Parameters != null) { Flags |= HttpServerFlags.SSL; } if ((Flags & HttpServerFlags.SSL) != 0) { if (SslStreamProvider == null) { var factory = DependencyInjector.Get <ConnectionProviderFactory> (); SslStreamProvider = factory.DefaultSslStreamProvider; } } }
public HttpServer(IPortableEndPoint clientEndPoint, IPortableEndPoint listenAddress, ListenerFlags flags, ConnectionParameters parameters = null, ISslStreamProvider sslStreamProvider = null) { this.listenAddress = listenAddress; this.flags = flags; this.sslStreamProvider = sslStreamProvider; this.parameters = parameters; if (parameters != null) { flags |= ListenerFlags.SSL; } if ((flags & ListenerFlags.SSL) != 0) { if (this.sslStreamProvider == null) { var factory = DependencyInjector.Get <ConnectionProviderFactory> (); this.sslStreamProvider = factory.DefaultSslStreamProvider; } } uri = new Uri(string.Format("http{0}://{1}:{2}/", UseSSL ? "s" : "", clientEndPoint.Address, clientEndPoint.Port)); }
public BuiltinHttpServer(Uri uri, IPortableEndPoint listenAddress, HttpServerFlags flags, ConnectionParameters parameters, ISslStreamProvider sslStreamProvider) : base(listenAddress, flags | HttpServerFlags.SSL, parameters, sslStreamProvider) { Uri = uri; }
public BuiltinHttpServer(IPortableEndPoint clientEndPoint, IPortableEndPoint listenAddress, HttpServerFlags flags, ConnectionParameters parameters, ISslStreamProvider sslStreamProvider) : base(listenAddress, flags, parameters, sslStreamProvider) { Uri = new Uri(string.Format("http{0}://{1}:{2}/", SslStreamProvider != null ? "s" : "", clientEndPoint.Address, clientEndPoint.Port)); }
public HttpServer CreateServer (IPortableEndPoint endpoint, ListenerFlags flags, ServerParameters parameters = null) { return new HttpServer (this, endpoint, flags, parameters); }
public DummyConnection(ConnectionProvider provider, IPortableEndPoint endpoint, ConnectionParameters parameters) : base(endpoint, parameters) { this.provider = provider; }
public HttpServer CreateServer (IPortableEndPoint clientAndPoint, IPortableEndPoint listenAddress, ListenerFlags flags, ConnectionParameters parameters = null) { return new HttpServer (this, clientAndPoint, listenAddress, flags, parameters); }
protected Connection(IPortableEndPoint endpoint, ConnectionParameters parameters) : base(endpoint, parameters) { }