private async Task RefreshImagesList() { ImagesListParameters listParameters = new ImagesListParameters(); listParameters.All = true; IList <ImagesListResponse> responseImages = await client.Images.ListImagesAsync(listParameters); lock (monitor) { HashSet <string> removedImageIds = new HashSet <string>(images.Keys); foreach (ImagesListResponse responseImage in responseImages) { removedImageIds.Remove(responseImage.ID); DockerImage dockerImage; if (!images.TryGetValue(responseImage.ID, out dockerImage)) { dockerImage = new DockerImage(); images.Add(responseImage.ID, dockerImage); } dockerImage.Id = responseImage.ID; dockerImage.Created = responseImage.Created; dockerImage.RepoTags = new List <string>(responseImage.RepoTags ?? Enumerable.Empty <string>()); dockerImage.RepoDigests = new List <string>(responseImage.RepoDigests ?? Enumerable.Empty <string>()); dockerImage.Size = responseImage.Size; dockerImage.VirtualSize = responseImage.VirtualSize; } foreach (string imageId in removedImageIds) { images.Remove(imageId); } } }
private async Task <string> GetImageId() { var parameters = new ImagesListParameters { MatchName = "wpc2018_consumer:latest" }; var images = await client.Images.ListImagesAsync(parameters); var image = images.FirstOrDefault(); return(image?.ID); }
// repotag : "registry:2" public async Task <ImagesListResponse> FindImage(string repoTag) { using (var client = GetClient()) { var p1 = new ImagesListParameters(); p1.All = true; var images = await client.Images.ListImagesAsync(p1); return(images.FirstOrDefault(i => i.RepoTags != null && i.RepoTags.Any(t => t == repoTag))); } }
public async Task <IList <ImagesListResponse> > ListImagesAsync(ImagesListParameters parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } IQueryString queryParameters = new QueryString <ImagesListParameters>(parameters); var response = await this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Get, "images/json", queryParameters).ConfigureAwait(false); return(this._client.JsonSerializer.DeserializeObject <ImagesListResponse[]>(response.Body)); }
private static async Task ListImages(DockerClient client) { var param = new ImagesListParameters(); // auch Zwischenebenen zeigen //param.All = true; // Filtern per Name //param.MatchName = "ubuntu"; foreach (var img in client.Images.ListImagesAsync(param).Result) { Console.WriteLine($"{img.ID} - {img.RepoTags?.FirstOrDefault()}"); } }
/// <summary> /// Outputs container image objects for each image matching the provided parameters. /// </summary> protected override async Task ProcessRecordAsync() { var listParams = new ImagesListParameters() { All = (All || Id != null) }; foreach (var img in await DkrClient.Images.ListImagesAsync(listParams)) { if (Id == null || Id.Any(i => img.RepoTags.Any(r => i.Split('/').Last().Contains(":") ? r == i : r == (i + ":latest"))) || Id.Any(i => img.ID.StartsWith(i) || img.ID.StartsWith("sha256:" + i))) { WriteObject(img); } } }
private async Task RefreshData() { using (var token = gridControlState.StoreViewState(gridViewImageList)) { try { var imagesListParameters = new ImagesListParameters() { All = barButtonItemShowAllImages.Down }; var result = await _dockerClient.Images.ListImagesAsync(imagesListParameters); if (barButtonItemHideNoneImages.Down) { result = result.Where(l => l.RepoTags.FirstOrDefault() != null && l.RepoTags.First().ToLowerInvariant() != "<none>:<none>").ToList(); } _updatingDataSource = true; // Triggers FocusedRowChanged gridImageList.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 async Task DeleteDanglingImages() { using (var client = GetClient()) { var p = new ImagesListParameters(); p.Filters = new Dictionary <string, IDictionary <string, bool> >(); p.Filters.Add("dangling", new Dictionary <string, bool>() { { "true", true } }); var images = await client.Images.ListImagesAsync(p); foreach (var image in images) { var p2 = new ImageDeleteParameters(); p2.Force = false; await client.Images.DeleteImageAsync(image.ID, p2); } } }
public async Task <IEnumerable <ImagesListResponse> > RetrieveAllImagesAsync(int skip = 0, int take = 20) { using var connection = await _dockerClient.ConnectAsync(); var images = connection.Images; try { var parameters = new ImagesListParameters(); var response = await images.ListImagesAsync(parameters); _logger.LogInformation("Successfully retrieved '{Images}' image(s).", response.Count); return(response.Skip(skip).Take(take)); } catch (Exception ex) { _logger.LogWarning(ex, "Could not Retrieve any images."); return(null); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var containers = CheckForRunningContainers().Result; while (!stoppingToken.IsCancellationRequested) { _logger.LogInformation("Checking for new docker image every 5 seconds. Last checked at: {time}", DateTimeOffset.Now); var imageParameters = new ImagesListParameters { MatchName = _defaultContainerName }; var images = await _client.Images.ListImagesAsync(imageParameters); foreach (var image in images.Take(1)) { var repoTag = image.RepoTags[0]; var dockerImage = CreateImageTag(image.ID, repoTag); if (runningContainer != null) { if (runningContainer.ImageName != $"{ dockerImage.Label}:{dockerImage.Tag}") { _logger.LogInformation($"New image found with Label:Tag = {dockerImage.Label}:{dockerImage.Tag}"); await RemoveOldContainer(containers); containers = CreateNewContainer(dockerImage.Label, dockerImage.Tag).Result; } } else { containers = CreateNewContainer(dockerImage.Label, dockerImage.Tag).Result; } } await Task.Delay(5000, stoppingToken); } }
/// <summary> /// Fetches all Docker Images /// </summary> /// <returns></returns> protected override async Task Get() { try { ImagesListParameters imageParams = new ImagesListParameters() { All = true }; IList <ImagesListResponse> dockerImages = await client.Images.ListImagesAsync(imageParams); var imageCollection = new ObservableCollection <ImagesListResponse>(); foreach (var item in dockerImages) { imageCollection.Add(item); } Collection = imageCollection; } catch (Exception ex) { throw ex; } }
/// <summary> /// 查询镜像 /// </summary> /// <param name="revMsg"></param> /// <returns></returns> public async Task <List <ImagesListResponse> > GetImages(ReceviceMessage revMsg) { string data = Encoding.UTF8.GetString(revMsg.payload); ImagesListInputParameters parametersInput = JsonConvert.DeserializeObject <ImagesListInputParameters>(data); ImagesListParameters parameters = new ImagesListParameters(); parameters.All = parametersInput.All; if (parametersInput.Filters != null) { parameters.Filters = parametersInput.Filters; } if (!string.IsNullOrWhiteSpace(parametersInput.MatchName)) { parameters.MatchName = parametersInput.MatchName; } var list = await _client.Images.ListImagesAsync(parameters); return(list.ToList()); }
private async void 本地ImageToolStripMenuItem_Click(object sender, EventArgs e) { ImagesListParameters ilp = new ImagesListParameters { All = true }; if (client == null) { MessageBox.Show("未连接任何机器", "Success", MessageBoxButtons.OK); return; } IList <ImagesListResponse> containers = await client.Images.ListImagesAsync(ilp); Dictionary <string, string> d = new Dictionary <string, string>(); foreach (ImagesListResponse i in containers) { if (i.RepoDigests == null) { continue; } if (i.RepoDigests[0] == "<none>@<none>") { continue; } string[] list = i.RepoDigests[0].Split('@'); if (d.Keys.Contains(list[0])) { continue; } d.Add(list[0], list[1]); } ListForm lf = new ListForm(d); lf.Show(); }
public static IList <ImagesListResponse> ListImages(this IImageOperations operations, ImagesListParameters parameters) { return(operations.ListImagesAsync(parameters).Result); }
/// <summary> /// Called when the <see cref="Client"/> is ready to handle requests. /// </summary> void Ready() { // TODO: Handle termination of underlying Connection actor. Receive <ListImages>(listImages => { var executeCommand = new Connection.ExecuteCommand(listImages, async(dockerClient, cancellationToken) => { var parameters = new ImagesListParameters { MatchName = listImages.MatchName, All = listImages.All, Filters = listImages.Filters.ToMutable() }; IList <ImagesListResponse> images = await dockerClient.Images.ListImagesAsync(parameters); return(new ImageList(listImages.CorrelationId, images)); }); _connection.Tell(executeCommand, Sender); }); Receive <CreateContainer>(createContainer => { var executeCommand = new Connection.ExecuteCommand(createContainer, async(dockerClient, cancellationToken) => { var parameters = new CreateContainerParameters { Image = createContainer.Image, Name = createContainer.Name, AttachStdout = createContainer.AttachStdOut, AttachStderr = createContainer.AttachStdErr, AttachStdin = createContainer.AttachStdIn, Tty = createContainer.TTY, HostConfig = new HostConfig { // Hard-coded for now. LogConfig = new LogConfig { Type = createContainer.LogType } } // TODO: Add other parameters. }; if (createContainer.EnvironmentVariables.Count > 0) { parameters.Env = createContainer.EnvironmentVariables .Select( environmentVariable => $"{environmentVariable.Key}={environmentVariable.Value}" ) .ToList(); } if (createContainer.Binds.Count > 0) { parameters.HostConfig.Binds = createContainer.Binds .Select( bind => $"{bind.Key}:{bind.Value}" ) .ToList(); } if (createContainer.Ports.Count > 0) { parameters.ExposedPorts = createContainer.Ports.ToDictionary( port => port.Key, port => (object)port.Value ); } CreateContainerResponse response = await dockerClient.Containers.CreateContainerAsync(parameters); return(new ContainerCreated(createContainer.CorrelationId, response)); }); _connection.Tell(executeCommand, Sender); }); Receive <StartContainer>(startContainer => { var executeCommand = new Connection.ExecuteCommand(startContainer, async(dockerClient, cancellationToken) => { ContainerStartParameters parameters = new ContainerStartParameters { DetachKeys = startContainer.DetachKeys }; bool containerWasStarted = await dockerClient.Containers.StartContainerAsync(startContainer.ContainerId, parameters); return(new ContainerStarted(startContainer.CorrelationId, startContainer.ContainerId, alreadyStarted: !containerWasStarted )); }); _connection.Tell(executeCommand, Sender); }); Receive <StopContainer>(stopContainer => { var executeCommand = new Connection.ExecuteCommand(stopContainer, async(dockerClient, cancellationToken) => { var parameters = new ContainerStopParameters { WaitBeforeKillSeconds = stopContainer.WaitBeforeKillSeconds }; bool containerWasStopped = await dockerClient.Containers.StopContainerAsync(stopContainer.ContainerId, parameters, cancellationToken); return(new ContainerStopped(stopContainer.CorrelationId, stopContainer.ContainerId, alreadyStopped: !containerWasStopped )); }); _connection.Tell(executeCommand, Sender); }); Receive <RemoveContainer>(removeContainer => { var executeCommand = new Connection.ExecuteCommand(removeContainer, async(dockerClient, cancellationToken) => { await dockerClient.Containers.RemoveContainerAsync(removeContainer.ContainerId, removeContainer.Parameters); return(new ContainerRemoved(removeContainer.CorrelationId, removeContainer.ContainerId )); }); _connection.Tell(executeCommand, Sender); }); Receive <GetContainerLogs>(getContainerLogs => { Log.Debug("Received GetContainerLogs request '{0}' from '{1}'.", getContainerLogs.CorrelationId, Sender); var executeCommand = new Connection.ExecuteCommand(getContainerLogs, async(dockerClient, cancellationToken) => { Stream responseStream = await dockerClient.Containers.GetContainerLogsAsync( getContainerLogs.ContainerId, getContainerLogs.Parameters, cancellationToken ); return(new StreamedResponse(getContainerLogs.CorrelationId, responseStream, format: StreamedResponseFormat.Log)); }); _connection.Tell(executeCommand, Sender); }); Receive <MonitorContainerEvents>(monitorContainerEvents => { Log.Debug("Received MonitorContainerEvents request '{0}' from '{1}'.", monitorContainerEvents.CorrelationId, Sender); var executeCommand = new Connection.ExecuteCommand(monitorContainerEvents, async(dockerClient, cancellationToken) => { Stream responseStream = await dockerClient.Miscellaneous.MonitorEventsAsync(monitorContainerEvents.Parameters, cancellationToken); return(new StreamedResponse(monitorContainerEvents.CorrelationId, responseStream, format: StreamedResponseFormat.Events)); }); _connection.Tell(executeCommand, Sender); }); Receive <CancelRequest>(cancelRequest => { _connection.Forward(cancelRequest); }); Receive <EventBusActor.Subscribe>(subscribeToDockerEvents => { if (_dockerEventBus == null) { _dockerEventBus = Context.ActorOf( DockerEventBus.Create(Self), name: DockerEventBus.ActorName ); } _dockerEventBus.Forward(subscribeToDockerEvents); }); Receive <EventBusActor.Unsubscribe>(unsubscribeFromDockerEvents => { if (_dockerEventBus == null) { return; } _dockerEventBus.Forward(unsubscribeFromDockerEvents); }); }