Example #1
0
        public override Task <Response> HandleAsync()
        {
            if (request.Handle.IsNullOrWhiteSpace())
            {
                throw new WardenException("Container handle is required.");
            }
            else
            {
                log.Trace("Destroying container with handle: '{0}'", request.Handle);

                return(Task.Run <Response>(() =>
                {
                    Container container = GetContainer();
                    if (container.State != ContainerState.Stopped)
                    {
                        try
                        {
                            var stopRequest = new StopRequest {
                                Handle = request.Handle
                            };
                            var stopRequestHandler = new StopRequestHandler(containerManager, stopRequest);
                            var stopTask = stopRequestHandler.HandleAsync();
                            Response stopResponse = stopTask.Result;
                        }
                        catch (Exception ex)
                        {
                            log.WarnException(ex);
                        }
                    }
                    containerManager.DestroyContainer(container);
                    return new DestroyResponse();
                }));
            }
        }
        public override Task<Response> HandleAsync()
        {
            if (request.Handle.IsNullOrWhiteSpace())
            {
                throw new WardenException("Container handle is required.");
            }
            else
            {
                log.Trace("Destroying container with handle: '{0}'", request.Handle);

                return Task.Run<Response>(() =>
                    {
                        Container container = GetContainer();
                        if (container != null)
                        {
                            if (container.State != ContainerState.Stopped)
                            {
                                try
                                {
                                    var stopRequest = new StopRequest { Handle = request.Handle };
                                    var stopRequestHandler = new StopRequestHandler(containerManager, stopRequest);
                                    var stopTask = stopRequestHandler.HandleAsync();
                                    Response stopResponse = stopTask.Result;
                                }
                                catch (Exception ex)
                                {
                                    log.WarnException(ex);
                                }
                            }
                            containerManager.DestroyContainer(container);
                        }
                        return new DestroyResponse();
                    });
            }
        }
Example #3
0
        public RequestHandler GetHandler()
        {
            RequestHandler handler = null;

            switch (requestType)
            {
            case Message.Type.CopyIn:
                handler = new CopyInRequestHandler(containerManager, request);
                break;

            case Message.Type.CopyOut:
                handler = new CopyOutRequestHandler(containerManager, request);
                break;

            case Message.Type.Create:
                handler = new CreateRequestHandler(containerManager, request);
                break;

            case Message.Type.Destroy:
                handler = new DestroyRequestHandler(containerManager, request);
                break;

            case Message.Type.Echo:
                handler = new EchoRequestHandler(request);
                break;

            case Message.Type.Info:
                handler = new InfoRequestHandler(containerManager, request);
                break;

            case Message.Type.LimitBandwidth:
                handler = new LimitBandwidthRequestHandler(request);
                break;

            case Message.Type.LimitDisk:
                handler = new LimitDiskRequestHandler(request);
                break;

            case Message.Type.LimitMemory:
                handler = new LimitMemoryRequestHandler(request);
                break;

            case Message.Type.Link:
                handler = new LinkRequestHandler(containerManager, jobManager, request);
                break;

            case Message.Type.List:
                handler = new ListRequestHandler(containerManager, request);
                break;

            case Message.Type.NetIn:
                handler = new NetInRequestHandler(containerManager, request);
                break;

            case Message.Type.NetOut:
                handler = new NetOutRequestHandler(request);
                break;

            case Message.Type.Ping:
                handler = new PingRequestHandler(request);
                break;

            case Message.Type.Run:
                handler = new RunRequestHandler(containerManager, request);
                break;

            case Message.Type.Spawn:
                handler = new SpawnRequestHandler(containerManager, jobManager, request);
                break;

            case Message.Type.Stop:
                handler = new StopRequestHandler(containerManager, request);
                break;

            case Message.Type.Stream:
                handler = new StreamRequestHandler(containerManager, jobManager, request);
                break;

            default:
                throw new WardenException("Unknown request type '{0}' passed to handler factory.", requestType);
            }

            return(handler);
        }
        public RequestHandler GetHandler()
        {
            RequestHandler handler = null;

            switch (requestType)
            {
                case Message.Type.CopyIn:
                    handler = new CopyInRequestHandler(containerManager, request);
                    break;
                case Message.Type.CopyOut:
                    handler = new CopyOutRequestHandler(containerManager, request);
                    break;
                case Message.Type.Create:
                    handler = new CreateRequestHandler(containerManager, request);
                    break;
                case Message.Type.Destroy:
                    handler = new DestroyRequestHandler(containerManager, request);
                    break;
                case Message.Type.Echo:
                    handler = new EchoRequestHandler(request);
                    break;
                case Message.Type.Info:
                    handler = new InfoRequestHandler(containerManager, request);
                    break;
                case Message.Type.LimitBandwidth:
                    handler = new LimitBandwidthRequestHandler(request);
                    break;
                case Message.Type.LimitDisk:
                    handler = new LimitDiskRequestHandler(request);
                    break;
                case Message.Type.LimitMemory:
                    handler = new LimitMemoryRequestHandler(request);
                    break;
                case Message.Type.Link:
                    handler = new LinkRequestHandler(containerManager, jobManager, request);
                    break;
                case Message.Type.List:
                    handler = new ListRequestHandler(containerManager, request);
                    break;
                case Message.Type.NetIn:
                    handler = new NetInRequestHandler(containerManager, request);
                    break;
                case Message.Type.NetOut:
                    handler = new NetOutRequestHandler(request);
                    break;
                case Message.Type.Ping:
                    handler = new PingRequestHandler(request);
                    break;
                case Message.Type.Run:
                    handler = new RunRequestHandler(containerManager, request);
                    break;
                case Message.Type.Spawn:
                    handler = new SpawnRequestHandler(containerManager, jobManager, request);
                    break;
                case Message.Type.Stop:
                    handler = new StopRequestHandler(containerManager, request);
                    break;
                case Message.Type.Stream:
                    handler = new StreamRequestHandler(containerManager, jobManager, request);
                    break;
                default:
                    throw new WardenException("Unknown request type '{0}' passed to handler factory.", requestType);
            }

            return handler;
        }