Пример #1
0
 public static ServerParameters CreatePipe(IPortableEndPoint endpoint, PipeArguments arguments)
 {
     return(new ServerParameters(ServerMode.Local)
     {
         EndPoint = endpoint, Arguments = arguments
     });
 }
Пример #2
0
        ServerParameters GetLocalParameters()
        {
            var pipeArgs = new PipeArguments();

            pipeArgs.MonoPrefix = Settings.MonoRuntime;
            if (string.IsNullOrEmpty(pipeArgs.MonoPrefix))
            {
                throw new AlertException("Must set Mono Runtime in Settings Dialog.");
            }

            var monoPath = Path.Combine(pipeArgs.MonoPrefix, "bin", "mono");

            if (!File.Exists(monoPath))
            {
                throw new AlertException("Invalid runtime prefix: {0}", pipeArgs.MonoPrefix);
            }

            var launcherPath = Settings.LauncherPath;

            if (!string.IsNullOrEmpty(launcherPath))
            {
                pipeArgs.ConsolePath = FindFile(launcherPath);
            }

            var assembly = Settings.TestSuite;

            if (string.IsNullOrEmpty(assembly))
            {
                throw new AlertException("Must set Test Suite in Settings Dialog.");
            }
            pipeArgs.Assembly       = FindFile(assembly);
            pipeArgs.ExtraArguments = Settings.Arguments;

            var address = Settings.ListenAddress;

            if (string.IsNullOrEmpty(address))
            {
                throw new AlertException("Must set Listen Address in Settings Dialog.");
            }

            var endpoint = ParseEndPoint(address);

            return(ServerParameters.CreatePipe(endpoint, pipeArgs));
        }
Пример #3
0
        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);
            }
        }