private async Task OnChanged(DockerGenConfiguration configuration)
 {
     await configuration.NotifyContainers.Keys.ForEachAsync(async containerId =>
     {
         await Client.Containers.KillContainerAsync(containerId, new ContainerKillParameters()
         {
             Signal = configuration.NotifyContainers[containerId].ToString()
         });
     });
 }
        private async Task <IList <ContainerListResponse> > GetContainers(DockerGenConfiguration configuration)
        {
            var all = await Client.Containers.ListContainersAsync(new ContainersListParameters()
            {
                All = configuration.IncludeStopped
            });

            if (configuration.OnlyPublished)
            {
                all = all.Where(c => c.Ports.Any()).ToList();
            }

            return(all);
        }
        protected async void OnTriggered(DockerGenConfiguration configuration)
        {
            var containers = await GetContainers(configuration);

            var writer   = new SimpleWriter();
            var template = _templateFactory.GenerateFromPath(configuration.Template);

            var containerInspections = containers
                                       .Select(c => c.ID)
                                       .Select(containerId => Client.Containers.InspectContainerAsync(containerId).Result)
                                       .ToList();

            await template.Execute(containerInspections, writer);

            var generatedContents = writer.Written;

            var targetFile = configuration.Destination;

            if (!Path.IsPathRooted(targetFile))
            {
                targetFile = Path.Combine(Directory.GetCurrentDirectory(), targetFile);
            }

            var currentFileContents = "";

            if (File.Exists(targetFile))
            {
                currentFileContents = File.ReadAllText(targetFile);
            }

            if (currentFileContents == "" || currentFileContents != generatedContents)
            {
                //Change detected lets write the contents
                File.Delete(targetFile);
                File.Create(targetFile);
                await File.WriteAllTextAsync(targetFile, generatedContents);

                await OnChanged(configuration);
            }
        }
示例#4
0
        private static void ConfigureDockerGenConfigurations(IServiceCollection services)
        {
            services.AddSingleton<IEnumerable<DockerGenConfiguration>>(provider =>
            {
                var configuration = provider.GetRequiredService<IConfiguration>();
                var configurationsSection = configuration.GetSection("configuration");

                var dockerGenConfigurations = new List<DockerGenConfiguration>();
                foreach (var configurationSection in configurationsSection.GetChildren())
                {
                    var dockerGenConfiguration = new DockerGenConfiguration();
                    configurationSection.Bind(dockerGenConfiguration);
                    dockerGenConfigurations.Add(dockerGenConfiguration);
                }

                if (dockerGenConfigurations.Any()) return dockerGenConfigurations;
                
                var localConfiguration = new DockerGenConfiguration();
                configuration.Bind(localConfiguration);
                dockerGenConfigurations.Add(localConfiguration);

                return dockerGenConfigurations;
            });
        }