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);
});
}
