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)
{
}
