public async Task <IActionResult> Index()
{
Uri dockerUri = new Uri("unix:///var/run/docker.sock");
DockerClient client = new DockerClientConfiguration(dockerUri).CreateClient();
var containersListParameters = new ContainersListParameters()
{
All = true,
};
IList <ContainerListResponse> containers = await client.Containers.ListContainersAsync(containersListParameters);
IEnumerable <Either <string, AutodiscoveryConfigModel> > autodiscovery = containers
.Where(KeepRunningContainersWithAutodiscoveryData)
.Select(GetAutodiscoveryData);
List <AutodiscoveryConfigModel> tools = autodiscovery.Where(tool => tool.IsRight()).Select(tool => tool.right).ToList();
List <string> errorMessages = autodiscovery.Where(tool => !tool.IsRight()).Select(tool => tool.left).ToList();
return(View(model: new HomeModel()
{
Tools = tools,
ContainersCount = containers.Count,
ErrorMessages = errorMessages
}));
}
/// <inheritdoc />
public async Task <IEnumerable <ContainerListResponse> > RetrieveAllContainersAsync(int skip = 0, int take = 20)
{
using var connection = await _dockerClient.ConnectAsync();
var containers = connection.Containers;
try
{
var request = new ContainersListParameters
{
All = true,
Limit = skip + take,
};
var response = await containers.ListContainersAsync(request);
_logger.LogInformation("Successfully retrieved '{Containers}' container(s).", response.Count);
return(response.Skip(skip).Take(take));
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Could not retrieve any containers.");
return(null);
}
}
public static async Task EnsureKilledAndRemoved(string dockerApiUrl, string containerName)
{
using (var client = new DockerClientConfiguration(new Uri(dockerApiUrl)).CreateClient())
{
var containersListParameters = new ContainersListParameters
{
All = true,
Filters = new Dictionary <string, IDictionary <string, bool> > {
{
"name", new Dictionary <string, bool> {
{ "^/" + containerName + "$", true },
}
}
},
};
ContainerListResponse container = (await client.Containers.ListContainersAsync(containersListParameters)).FirstOrDefault();
if (container != null)
{
if (container.State == "running")
{
Logger.Info($"Killing container {container.ID}");
await client.Containers.KillContainerAsync(container.ID, new ContainerKillParameters());
Logger.Info($"Container {container.ID} killed");
}
Logger.Info($"Removing container {container.ID}");
await client.Containers.RemoveContainerAsync(container.ID, new ContainerRemoveParameters());
Logger.Info($"Container {container.ID} removed");
}
}
}
public async Task <IEnumerable <ModuleRuntimeInfo> > GetModules(CancellationToken ctsToken)
{
var parameters = new ContainersListParameters
{
All = true,
Filters = new Dictionary <string, IDictionary <string, bool> >
{
{ "label", Labels }
}
};
IList <ContainerListResponse> containers = await this.client.Containers.ListContainersAsync(parameters, ctsToken);
Option <ContainerInspectResponse>[] containerInspectResponses =
await Task.WhenAll(
containers.Select(
c => this.client.Containers
.InspectContainerAsync(c.ID)
.MayThrow(typeof(DockerContainerNotFoundException)))
.Concat(new[]
{
this.client.Containers
.InspectContainerAsync(CoreConstants.EdgeAgentModuleName)
.MayThrow(EdgeAgentNotFoundAlternative, typeof(DockerContainerNotFoundException))
}));
List <ModuleRuntimeInfo> modules = containerInspectResponses
.FilterMap()
.Select(InspectResponseToModule)
.ToList();
return(modules);
}
/// <summary>
/// Get all deployments.
/// </summary>
/// <returns>
/// A list of deployments.
/// </returns>
public async Task <Deployment[]> GetDeploymentsAsync()
{
List <Deployment> deployments = new List <Deployment>();
Log.LogInformation("Retrieving all deployments...");
// Find all containers that have a "deployment.id" label.
ContainersListParameters listParameters = new ContainersListParameters
{
All = true,
Filters = new FiltersDictionary
{
["label"] = new FilterDictionary
{
["deployment.id"] = true
}
}
};
IList <ContainerListResponse> containerListings = await Client.Containers.ListContainersAsync(listParameters);
deployments.AddRange(containerListings.Select(
containerListing => ToDeploymentModel(containerListing)
));
Log.LogInformation("Retrieved {DeploymentCount} deployments.", deployments.Count);
return(deployments.ToArray());
}
/// <summary>
/// Check if a container is running.
/// </summary>
/// <param name="id">ID of the container to be checked.</param>
private async Task <bool> IsRunning(string id)
{
IDictionary <string, bool> idFilter = new Dictionary <string, bool>()
{
{ id, true }
};
Dictionary <string, IDictionary <string, bool> > filters = new Dictionary <string, IDictionary <string, bool> >()
{
{ "id", idFilter }
};
ContainersListParameters parameters = new ContainersListParameters()
{
All = true,
Filters = filters
};
IList <ContainerListResponse> containers = await client.Containers.ListContainersAsync(parameters);
// If it doesn't exist it's not running.
if (containers.Count < 1)
{
return(false);
}
// todo: could we ever have >1 container matching these filters?
ContainerListResponse response = containers[0];
return(response.State == "running");
}
public ContainerHook(DockerClient client, ContainerHookConfig config)
{
this.client = client;
this.containerListParams = new Docker.DotNet.Models.ContainersListParameters();
containerListParams.Filters = new Dictionary <string, IDictionary <string, bool> > {
{
"name",
new Dictionary <string, bool> {
{ config.SafeName, true }
}
}
};
containerListParams.Limit = 1;
this.validate(config);
this.Name = config.Name;
this.Tag = config.Tag;
this.SafeName = config.SafeName;
this.configSrc = config.ConfigSrc;
this.configVolSrc = config.ConfigVolSrc;
this.configVolDest = config.ConfigVolDest;
this.mounts = config.Mounts;
this.portMappings = config.PortMappings;
this.envVars = config.EnvVariables;
this.networkMode = config.NetworkMode;
this.capabilities = config.Capabilities;
this.memoryReservation = config.MemCap;
this.privileged = config.Privileged;
this.restartPolicy = config.RestartPolicy;
this.authConfig = config.AuthConfig;
this.forceUpgrade = config.ForceUpgrade;
}
/// <summary>
/// 查询容器
/// </summary>
/// <param name="revMsg"></param>
/// <returns></returns>
public async Task <List <ContainerListResponse> > GetContainers(ReceviceMessage revMsg)
{
string data = Encoding.UTF8.GetString(revMsg.payload);
ContainersListParameters parameters = JsonConvert.DeserializeObject <ContainersListParameters>(data);
var list = await _client.Containers.ListContainersAsync(parameters);
return(list.ToList());
}
private async Task <IList <ContainerListResponse> > GetAllContainers()
{
var containerParameters = new ContainersListParameters
{
All = true
};
return(await _client.Containers.ListContainersAsync(containerParameters));
}
private static async Task <IList <ContainerListResponse> > GetAllContainers()
{
var listOption = new ContainersListParameters {
All = true
};
IList <ContainerListResponse> containers =
await _client.Containers.ListContainersAsync(listOption);
return(containers);
}
public async Task <ContainerListResponse> FindContainer(string imageId)
{
using (var client = GetClient())
{
var p1 = new ContainersListParameters();
p1.All = true;
var containers = await client.Containers.ListContainersAsync(p1);
return(containers.FirstOrDefault(i => i.ImageID == imageId));
}
}
public async Task <ContainerListResponse> FindContainerByName(string name)
{
using (var client = GetClient())
{
var p1 = new ContainersListParameters();
p1.All = true;
var containers = await client.Containers.ListContainersAsync(p1);
return(containers.FirstOrDefault(i => i.Names.Contains("/" + name)));
}
}
public async Task <IList <ContainerListResponse> > ListContainersAsync(ContainersListParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
IQueryString queryParameters = new QueryString <ContainersListParameters>(parameters);
var response = await this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Get, "containers/json", queryParameters).ConfigureAwait(false);
return(this._client.JsonSerializer.DeserializeObject <ContainerListResponse[]>(response.Body));
}
private IList <ContainerListResponse> ListContainers()
{
var listParameters = new ContainersListParameters();
listParameters.All = false;
listParameters.Filters = new Dictionary <string, IDictionary <string, bool> >();
listParameters.Filters.Add("name", new Dictionary <string, bool>()
{
{ "nooptime-postgres", true }
});
var list = _dockerClient.Containers.ListContainersAsync(listParameters).Result;
return(list);
}
public async Task <IEnumerable <ExposedService> > GetExposedServices()
{
var searchParameters = new ContainersListParameters {
All = false, Filters = new Dictionary <string, IDictionary <string, bool> >
{
["label"] = new Dictionary <string, bool>
{
[ExposedServiceLabelParser.ExposedServiceLabel] = true
}
}
};
var containers = await _dockerClient.Containers.ListContainersAsync(searchParameters);
return(containers.SelectMany(ExposedServiceLabelParser.GetExposedServicesFromContainer));
}
private void Handle(ListContainers.Request message)
{
var options = new ContainersListParameters {
All = true
};
client.Containers
.ListContainersAsync(options)
.PipeTo(
recipient: Sender,
sender: Self,
success: containers =>
{
var containersId = containers
.Select(x => x.ID)
.ToList();
return(new ListContainers.Response(new ReadOnlyCollection <string>(containersId)));
});
}
private static async Task StopContainer(DockerClient client)
{
var listParam = new ContainersListParameters
{
Filters = new Dictionary <string, IDictionary <string, bool> >
{
{ "name", new Dictionary <string, bool> {
{ "pingtest", true }
} }
}
};
var result = await client.Containers.ListContainersAsync(listParam);
if (result.Any())
{
await client.Containers.StopContainerAsync(result.First().ID, new ContainerStopParameters(),
CancellationToken.None);
}
}
/// <summary>
/// Get a specific deployment by Id.
/// </summary>
/// <param name="deploymentId">
/// The deployment Id.
/// </param>
/// <returns>
/// The deployment, or <c>null</c> if one was not found with the specified Id.
/// </returns>
public async Task <Deployment> GetDeploymentAsync(string deploymentId)
{
if (String.IsNullOrWhiteSpace(deploymentId))
{
throw new ArgumentException("Invalid deployment Id.", nameof(deploymentId));
}
Log.LogInformation("Retrieving deployment '{DeploymentId}'...", deploymentId);
// Find all containers that have a "deployment.id" label.
ContainersListParameters listParameters = new ContainersListParameters
{
All = true,
Filters = new FiltersDictionary
{
["label"] = new FilterDictionary
{
["deployment.id=" + deploymentId] = true
}
}
};
IList <ContainerListResponse> containerListings = await Client.Containers.ListContainersAsync(listParameters);
ContainerListResponse newestMatchingContainer =
containerListings
.OrderByDescending(container => container.Created)
.FirstOrDefault();
if (newestMatchingContainer == null)
{
Log.LogInformation("Deployment '{DeploymentId}' not found.", deploymentId);
return(null);
}
Deployment deployment = ToDeploymentModel(newestMatchingContainer);
Log.LogInformation("Retrieved deployment '{DeploymentId}'.", deploymentId);
return(deployment);
}
public async Task <IEnumerable <ModuleRuntimeInfo> > GetModules(CancellationToken ctsToken)
{
var parameters = new ContainersListParameters
{
All = true,
Filters = new Dictionary <string, IDictionary <string, bool> >
{
{ "label", Labels }
}
};
IList <ContainerListResponse> containers = await this.client.Containers.ListContainersAsync(parameters, ctsToken);
List <ContainerInspectResponse> containerInspectResponses = (await Task.WhenAll(containers.Select(c => this.client.Containers.InspectContainerAsync(c.ID)))).ToList();
Option <ContainerInspectResponse> edgeAgentReponse = await this.GetEdgeAgentContainerAsync();
edgeAgentReponse.ForEach(e => containerInspectResponses.Add(e));
List <ModuleRuntimeInfo> modules = containerInspectResponses.Select(c => InspectResponseToModule(c)).ToList();
return(modules);
}
public ContainersMonitoringService(ILogger logger,
string groupName,
ContainersGroupConfiguration configuration,
DockerClientFactory dockerClientFactory,
GlobalCancellationToken globalCancellation,
CommandsExecutorFactory commandsExecutorFactory,
EventsBus eventsBus)
{
this.logger = logger;
this.groupName = groupName;
this.configuration = configuration;
this.dockerClientFactory = dockerClientFactory;
this.globalCancellation = globalCancellation;
this.commandsExecutorFactory = commandsExecutorFactory;
this.eventsBus = eventsBus;
this.listParameters = new ContainersListParameters()
{
All = true,
Filters = ComposeFilter(configuration)
};
}
public async Task <IList <ContainerListResponse> > ListContainers()
{
IList <ContainerListResponse> nl = new List <ContainerListResponse>();
try
{
var parameters = new ContainersListParameters
{
Filters = new Dictionary <string, IDictionary <string, bool> >
{
{
"status", new Dictionary <string, bool>
{
{ "running", true },
{ "created", true },
{ "dead", true },
{ "exited", true },
}
}
}
};
var containers = await _client.Containers.ListContainersAsync(parameters);
foreach (ContainerListResponse c in containers)
{
foreach (string n in c.Names)
{
if (n.ToString().Contains(Params.ID))
{
nl.Add(c);
}
}
}
// CurrentState.Instance.SetHIEVar(true);
} catch {
CurrentState.Instance.SetHIEVar(false);
}
return(nl);
}
private async Task RefreshContainerList()
{
ContainersListParameters listParameters = new ContainersListParameters();
listParameters.All = true;
IList <ContainerListResponse> responseContainers = await client.Containers.ListContainersAsync(listParameters);
lock (monitor)
{
HashSet <string> removedContainerIds = new HashSet <string>(containers.Keys);
foreach (ContainerListResponse responseContainer in responseContainers)
{
removedContainerIds.Remove(responseContainer.ID);
DockerContainer dockerContainer;
if (!containers.TryGetValue(responseContainer.ID, out dockerContainer))
{
dockerContainer = new DockerContainer();
containers.Add(responseContainer.ID, dockerContainer);
}
dockerContainer.Id = responseContainer.ID;
dockerContainer.Image = responseContainer.Image;
dockerContainer.ImageId = responseContainer.ImageID;
dockerContainer.Created = responseContainer.Created;
dockerContainer.State = responseContainer.State;
dockerContainer.Ports = responseContainer.Ports.Select(p => new DockerContainerPort(p.Type, p.PrivatePort, p.PublicPort)).ToArray();
}
foreach (string containerId in removedContainerIds)
{
containers.Remove(containerId);
DockerLogReader logReader;
if (logReaders.TryGetValue(containerId, out logReader))
{
logReader.Stop();
logReaders.Remove(containerId);
}
}
}
}
public static void DoUpdate()
{
_timer.Stop();
//We want to only find running containers
var containerListParams = new ContainersListParameters()
{
Filters = new Dictionary <string, IDictionary <string, bool> >()
{
{
"status", new Dictionary <string, bool>()
{
{ "running", true }
}
}
}
};
lock (_hostsEntries)
{
_hostsEntries = new Dictionary <string, string>();
}
//Handle already running containers on the network
var containers = _client.Containers.ListContainersAsync(containerListParams).Result;
foreach (var container in containers)
{
if (ShouldProcessContainer(container.ID))
{
AddHost(container.ID);
}
}
WriteHosts();
_timer.Start();
}
private async Task RefreshData()
{
using (var token = gridControlState.StoreViewState(gridViewContainerList))
{
try
{
var listContainerParameters = new ContainersListParameters()
{
All = true
};
var result = await _dockerClient.Containers.ListContainersAsync(listContainerParameters);
_updatingDataSource = true;
// Triggers FocusedRowChanged
gridContainerList.DataSource = result.ToList();
barStaticItemDockerConnectionMissing.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
}
catch (Exception ex)
{
// The async call first throws a DockerApiException and a short while after a TimeoutException is throw as well.
if (ex is DockerApiException || ex is TimeoutException)
{
barStaticItemDockerConnectionMissing.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
}
else
{
throw;
}
}
finally
{
_updatingDataSource = false;
}
}
// Force update details.
UpdateDetails();
}
public ReturnContainersById GetAllById(string userId)
{
List <Server> servers = _serverService.GetAll(userId);
var res = new ReturnContainersById()
{
Servers = new List <Server>(),
Containers = new List <IList <ContainerListResponse> >()
};
foreach (var i in servers)
{
var client = _pools.GetPoolByIp(i.Ip).Get();
ContainersListParameters p = new ContainersListParameters()
{
All = true
};
var containers = client.Containers.ListContainersAsync(p).GetAwaiter().GetResult();
res.Servers.Add(i);
res.Containers.Add(containers);
}
return(res);
}
public IList <ContainerListResponse> GetContainers(bool all = true, string filtersName = null)
{
var filters = new Dictionary <string, IDictionary <string, bool> >
{
{ "name", new Dictionary <string, bool> {
{ filtersName, true }
} }
};
var parameter = new ContainersListParameters()
{
All = all,
Filters = filters
};
var task = _client.Containers
.ListContainersAsync(parameter)
.ContinueWith(x =>
{
return(x.Result);
});
task.Wait();
return(task.Result);
}
public async Task <string> GetContainerIdByName(string name)
{
var listParam = new ContainersListParameters
{
Filters = new Dictionary <string, IDictionary <string, bool> >
{
{ "name", new Dictionary <string, bool> {
{ name, true }
} }
},
All = true
};
var result = await _client.Containers.ListContainersAsync(listParam);
if (!result.Any())
{
return(string.Empty);
}
else
{
return(result.First().ID);
}
}
public async Task EnsureKilledAsync()
{
var containersListParameters = new ContainersListParameters
{
All = true,
Filters = new Dictionary <string, IDictionary <string, bool> > {
{
"id", new Dictionary <string, bool> {
{ ContainerId, true },
}
}
},
};
var container = (await Client.Containers.ListContainersAsync(containersListParameters)).FirstOrDefault();
if (container?.State == "running")
{
Logger.Info($"Killing container {container.ID}");
await Client.Containers.KillContainerAsync(container.ID, new ContainerKillParameters());
Logger.Info($"Container {container.ID} killed");
}
}
public static IList <ContainerListResponse> ListContainers(this IContainerOperations operations, ContainersListParameters parameters)
{
return(operations.ListContainersAsync(parameters).Result);
}
