示例#1
0
        private void container_down(object sender, RoutedEventArgs e)
        {
            if ((this.selection is null) || (this.selection.is_category) || (!this.state.items.ContainsKey(this.selection.name)))
            {
                return;
            }
            ElementReference <ItemSpec> item_ref = this.state.items[this.selection.name];

            if (item_ref.ref_count > 0)
            {
                return;
            }
            int idx = this.container_list.SelectedIndex;

            if ((idx < 0) || (idx >= this.containers.Count - 1))
            {
                return;
            }
            ContainerSpec container = this.containers[idx];

            this.containers[idx]     = this.containers[idx + 1];
            this.containers[idx + 1] = container;
            ItemSpecContainerRow row = this.container_rows[idx];

            this.container_rows[idx]     = this.container_rows[idx + 1];
            this.container_rows[idx + 1] = row;
            this.container_list.Items.Refresh();
            this.set_dirty();
        }
示例#2
0
        public override Task <Response> HandleAsync()
        {
            return(Task.Run <Response>(async() =>
            {
                var config = new WardenConfig();
                var handle = new ContainerHandle();

                var containerService = new ContainerService(
                    config.ContainerBasePath,
                    config.WardenUsersGroup);

                var containerSpec = new ContainerSpec
                {
                    Handle = handle,
                    BindMounts = GetBindMounts(request).ToArray(),
                };

                var container = containerService.CreateContainer(containerSpec);
                var containerClient = new ContainerClient(containerService, container, new FileSystemManager());
                await containerClient.InitializeAsync(null, null, null);

                containerManager.AddContainer(containerClient);

                return new CreateResponse {
                    Handle = handle
                };
            }));
        }
示例#3
0
        private byte[][] PopulateInitialState()
        {
            if (this.parameters.CurrentAllocations != null && this.parameters.CurrentAllocations.Length != 0)
            {
                ILookup <string, string> allocationByMachine = this.parameters.CurrentAllocations
                                                               .ToLookup(c => c.Machine.Name, d => d.ContainerSpec.Name);

                for (int i = 0; i < this.Rows; i++)
                {
                    string machine = this.parameters.Machines[i].Name;
                    IDictionary <string, string> containersByName = allocationByMachine[machine].ToDictionary(c => c);

                    for (int j = 0; j < this.Columns; j++)
                    {
                        ContainerSpec container = this.parameters.ContainerSpecs[j];

                        if (containersByName.ContainsKey(container.Name))
                        {
                            this.initialState[i][j] = 1;
                        }
                    }
                }
            }

            return(this.initialState);
        }
示例#4
0
 public Properties()
 {
     ContainerSpec = new ContainerSpec
     {
         Handle = Container1Handle,
     };
 }
示例#5
0
 public ImpersonateContainerUser()
 {
     ContainerSpec = new ContainerSpec
     {
         Handle = Container1Handle,
     };
 }
示例#6
0
        private void container_edit(object sender, RoutedEventArgs e)
        {
            if ((this.selection is null) || (this.selection.is_category) || (!this.state.items.ContainsKey(this.selection.name)))
            {
                return;
            }
            ElementReference <ItemSpec> item_ref = this.state.items[this.selection.name];

            if (item_ref.ref_count > 0)
            {
                return;
            }
            int idx = this.container_list.SelectedIndex;

            if ((idx < 0) || (idx >= this.containers.Count))
            {
                return;
            }
            ContainerSpec container = this.containers[idx];

            QueryPrompt[] prompts = new QueryPrompt[] {
                new QueryPrompt("Name:", QueryType.STRING, container.name),
                new QueryPrompt("Weight Factor:", QueryType.FLOAT, (double)(container.weight_factor), step: 0.125),
                new QueryPrompt("Weight Capacity:", QueryType.FLOAT, (double)(container.weight_capacity ?? 0)),
            };
            object[] results = SimpleDialog.askCompound("Edit Container", prompts, this);
            if (results is null)
            {
                return;
            }

            string name = results[0] as string;
            double?weight_factor = results[1] as double?, weight_capacity = results[2] as double?;

            if ((name is null) || (weight_factor is null))
            {
                return;
            }
            if (weight_capacity == 0)
            {
                weight_capacity = null;
            }

            container.name            = name;
            container.weight_factor   = (decimal)weight_factor;
            container.weight_capacity = (decimal?)weight_capacity;
            ItemSpecContainerRow row = this.container_rows[idx];

            row._name            = name;
            row._weight_factor   = container.weight_factor.ToString();
            row._weight_capacity = container.weight_capacity.ToString();
            this.container_list.Items.Refresh();
            this.fix_listview_column_widths(this.container_list);
            this.set_dirty();
        }
            public WithContainer(AcceptanceFixture fixture)
                : base(fixture)
            {
                var spec = new ContainerSpec
                {
                    Handle = Guid.NewGuid().ToString("N"),
                };

                Container = Service.CreateContainer(spec);

                WriteUserFileToContainer("run.bat", RunBatFileContent);
            }
示例#8
0
        public IContainer CreateContainer(string handle)
        {
            var environment = new Dictionary <string, string>
            {
                { "CONTAINER_HANDLE", handle },
                { "CONTAINER_ENV1", "ENV1" }
            };

            var spec = new ContainerSpec
            {
                Environment = environment,
                Handle      = handle
            };

            return(CreateContainer(spec));
        }
        public CreateResponse Create(ContainerSpecApiModel spec)
        {
            if (spec.Env == null)
            {
                spec.Env = new List <string>();
            }

            var containerSpec = new ContainerSpec
            {
                Handle      = spec.Handle,
                Properties  = spec.Properties,
                Environment = ContainerService.EnvsFromList(spec.Env)
            };

            try
            {
                var container = containerService.CreateContainer(containerSpec);
                container.SetActiveProcessLimit(CONTAINER_ACTIVE_PROCESS_LIMIT);
                container.SetPriorityClass(ProcessPriorityClass.BelowNormal);
                if (spec.Limits.MemoryLimits.LimitInBytes != null)
                {
                    container.LimitMemory(spec.Limits.MemoryLimits.LimitInBytes.Value);
                }
                if (spec.Limits.CpuLimits.Weight != null)
                {
                    container.LimitCpu(spec.Limits.CpuLimits.Weight.Value);
                }
                if (spec.Limits.DiskLimits.ByteHard != null)
                {
                    container.LimitDisk(spec.Limits.DiskLimits.ByteHard.Value);
                }

                return(new CreateResponse
                {
                    Handle = container.Handle
                });
            }
            catch (PrincipalExistsException)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.Conflict,
                                                                       string.Format("handle already exists: {0}", spec.Handle)));
            }
            catch (Exception ex)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
        }
        public CreateResponse Create(ContainerSpecApiModel spec)
        {
            if (spec.Env == null)
            {
                spec.Env = new List <string>();
            }

            var containerSpec = new ContainerSpec
            {
                Handle      = spec.Handle,
                Properties  = spec.Properties,
                Environment = ContainerService.EnvsFromList(spec.Env),
                BindMounts  = spec.BindMounts.Select(b => b.ToIronFrame()).ToArray()
            };

            try
            {
                var container = containerService.CreateContainer(containerSpec);
                container.SetActiveProcessLimit(CONTAINER_ACTIVE_PROCESS_LIMIT);
                container.SetPriorityClass(ProcessPriorityClass.BelowNormal);
                container.LimitCpu(CONTAINER_DEFAULT_CPU_WEIGHT);
                if (spec.Limits.MemoryLimits.LimitInBytes != null)
                {
                    container.LimitMemory(spec.Limits.MemoryLimits.LimitInBytes.Value);
                }
                if (spec.Limits.DiskLimits.ByteHard != null)
                {
                    container.LimitDisk(spec.Limits.DiskLimits.ByteHard.Value);
                }
                if (spec.GraceTime.HasValue)
                {
                    container.SetProperty("GraceTime", spec.GraceTime.Value.ToString());
                }

                return(new CreateResponse
                {
                    Handle = container.Handle
                });
            }
            catch (PrincipalExistsException)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.Conflict,
                                                                       string.Format("handle already exists: {0}", spec.Handle)));
            }
        }
示例#11
0
        public ContainerSpec[] BuildMany(int count)
        {
            ContainerSpec[] containers = new ContainerSpec[count];
            int             seed       = Random.Next();

            for (int i = 0; i < count; i++)
            {
                ContainerSpec container = new ContainerSpec
                {
                    Name                 = "Container" + seed + i,
                    ResourceUsages       = this.Resources.ToArray().Copy(),
                    DesiredInstanceCount = this.desiredInstanceCount
                };

                containers[i] = container;
            }

            return(containers);
        }
示例#12
0
        private void container_add(object sender, RoutedEventArgs e)
        {
            if ((this.selection is null) || (this.selection.is_category) || (!this.state.items.ContainsKey(this.selection.name)))
            {
                return;
            }
            ElementReference <ItemSpec> item_ref = this.state.items[this.selection.name];

            if (item_ref.ref_count > 0)
            {
                return;
            }
            QueryPrompt[] prompts = new QueryPrompt[] {
                new QueryPrompt("Name:", QueryType.STRING),
                new QueryPrompt("Weight Factor:", QueryType.FLOAT, 1.0, step: 0.125),
                new QueryPrompt("Weight Capacity:", QueryType.FLOAT),
            };
            object[] results = SimpleDialog.askCompound("Add Container", prompts, this);
            if (results is null)
            {
                return;
            }

            string name = results[0] as string;
            double?weight_factor = results[1] as double?, weight_capacity = results[2] as double?;

            if ((name is null) || (weight_factor is null))
            {
                return;
            }
            if (weight_capacity == 0)
            {
                weight_capacity = null;
            }

            ContainerSpec container = new ContainerSpec(name, (decimal)weight_factor, (decimal?)weight_capacity);

            this.containers.Add(container);
            this.container_rows.Add(new ItemSpecContainerRow(container.name, container.weight_factor.ToString(), container.weight_capacity.ToString()));
            this.container_list.Items.Refresh();
            this.fix_listview_column_widths(this.container_list);
            this.set_dirty();
        }
示例#13
0
        /// <inheritdoc/>
        public void Normalize()
        {
            ContainerSpec = ContainerSpec ?? new ServiceContainerSpec();
            Resources     = Resources ?? new ServiceResources();
            RestartPolicy = RestartPolicy ?? new ServiceRestartPolicy();
            Placement     = Placement ?? new ServicePlacement();
            Networks      = Networks ?? new List <ServiceNetwork>();
            EndpointSpec  = EndpointSpec ?? new ServiceEndpointSpec();

            ContainerSpec?.Normalize();
            Resources?.Normalize();
            RestartPolicy?.Normalize();
            Placement?.Normalize();
            LogDriver?.Normalize();
            EndpointSpec?.Normalize();

            foreach (var item in Networks)
            {
                item?.Normalize();
            }
        }
            public void CanCreateContainer()
            {
                var spec = new ContainerSpec
                {
                    Handle = Guid.NewGuid().ToString("N"),
                };
                IContainer container = null;

                try
                {
                    container = Service.CreateContainer(spec);

                    Assert.NotNull(container);
                }
                finally
                {
                    if (container != null)
                    {
                        Service.DestroyContainer(container.Handle);
                    }
                }
            }
 public ImpersonateContainerUser()
 {
     ContainerSpec = new ContainerSpec
     {
         Handle = Container1Handle,
     };
 }
        public IContainer CreateContainer(ContainerSpec spec)
        {
            var container = ContainerService.CreateContainer(spec);

            return container;
        }
 public Properties()
 {
     ContainerSpec = new ContainerSpec
     {
         Handle = Container1Handle,
     };
 }
        public IContainer CreateContainer(string handle)
        {
            var environment = new Dictionary<string, string>
            {
                {"CONTAINER_HANDLE", handle},
                {"CONTAINER_ENV1", "ENV1"}
            };

            var spec = new ContainerSpec
            {
                Environment = environment,
                Handle = handle
            };

            return CreateContainer(spec);
        }
示例#19
0
        public IContainer CreateContainer(ContainerSpec spec)
        {
            var container = ContainerService.CreateContainer(spec);

            return(container);
        }
示例#20
0
        private void AssignInstancesToMaximizeResourceUtilization()
        {
            Machine[] machinesWithResourceToMaximize = this.parameters.Machines
                                                       .Where(c => c.AvailableResources.Any(x => x.Requires(this.parameters.MaximizeResourceUsageFor.Value)))
                                                       .ToArray();

            ContainerSpec[] containersWithResourceToMaximize = this.parameters.ContainerSpecs
                                                               .Where(c => c.ResourceUsages.Any(x => x.Requires(this.parameters.MaximizeResourceUsageFor.Value)))
                                                               .ToArray();

            int numerator = GetTotalResourceAmount(this.parameters.MaximizeResourceUsageFor.Value, machinesWithResourceToMaximize);

            int denominator0 = GetTotalResourceRequirement(this.parameters.MaximizeResourceUsageFor.Value, containersWithResourceToMaximize);

            if (denominator0 == 0)
            {
                return;
            }

            int approximateInstances = numerator / denominator0;

            Dictionary <string, ContainerSpec> excluded = new Dictionary <string, ContainerSpec>();

            foreach (ContainerSpec container in containersWithResourceToMaximize)
            {
                if (container.DesiredInstanceCount > approximateInstances)
                {
                    excluded.Add(container.Name, container);
                }
            }

            int resourceAmountForAllExcludedContainerInstances = excluded.Sum(c => c.Value.ResourceUsages.Where(ru => ru.Kind == this.parameters.MaximizeResourceUsageFor.Value).Select(ru => ru.Value * c.Value.DesiredInstanceCount).Sum());
            int totalResourceAmount = GetTotalResourceAmount(this.parameters.MaximizeResourceUsageFor.Value, machinesWithResourceToMaximize) - resourceAmountForAllExcludedContainerInstances;

            int resourceAmountForExcludedContainerTypes = excluded.Sum(c => c.Value.ResourceUsages.Where(ru => ru.Kind == this.parameters.MaximizeResourceUsageFor.Value).Select(ru => ru.Value).Sum());
            int denominator = GetTotalResourceRequirement(this.parameters.MaximizeResourceUsageFor.Value, containersWithResourceToMaximize) - resourceAmountForExcludedContainerTypes;

            if (denominator == 0)
            {
                return;
            }

            int instancesPerContainer = totalResourceAmount / denominator;

            int remainingResourceAmount = totalResourceAmount % denominator;

            for (int i = 0; i < this.desiredContainerInstanceCounts.Length; i++)
            {
                ContainerSpec container = this.parameters.ContainerSpecs[i];
                if (container.ResourceUsages.Any(c => c.Requires(this.parameters.MaximizeResourceUsageFor.Value)))
                {
                    if (!excluded.ContainsKey(container.Name))
                    {
                        int instances = instancesPerContainer;

                        int resourcePerContainer = container.ResourceUsages.First(c => c.Requires(this.parameters.MaximizeResourceUsageFor.Value)).Value;

                        if (remainingResourceAmount >= resourcePerContainer)
                        {
                            instances++;
                            remainingResourceAmount -= resourcePerContainer;
                        }

                        this.desiredContainerInstanceCounts[i] = instances;
                    }
                }
            }
        }