Examples with IDockerContainer org.eclipse.linuxtools.docker.core.IDockerContainer used on opensource projects

Example 16 with IDockerContainer

use of org.eclipse.linuxtools.docker.core.IDockerContainer in project linuxtools by eclipse.

the class DockerConnectionTest method shouldLoadContainers.

@Test
public void shouldLoadContainers() throws DockerException {
    // given
    final Container fooContainer = MockContainerFactory.id("foo").build();
    final Container barContainer = MockContainerFactory.id("bar").build();
    final DockerClient client = MockDockerClientFactory.container(fooContainer).container(barContainer).build();
    final DockerConnection dockerConnection = MockDockerConnectionFactory.from("Test", client).withDefaultTCPConnectionSettings();
    dockerConnection.open(false);
    // when
    final List<IDockerContainer> containers = dockerConnection.getContainers();
    // then
    assertThat(containers).hasSize(2);
}

Example 17 with IDockerContainer

use of org.eclipse.linuxtools.docker.core.IDockerContainer in project linuxtools by eclipse.

the class DockerConnection method listContainers.

private List<IDockerContainer> listContainers() throws DockerException {
    final Map<String, IDockerContainer> updatedContainersById = new HashMap<>();
    List<IDockerContainer> sortedContainers;
    synchronized (containerLock) {
        try {
            final List<Container> nativeContainers = new ArrayList<>();
            synchronized (clientLock) {
                // containers list left in the queue
                if (client == null) {
                    // there's no client.
                    return Collections.emptyList();
                }
                nativeContainers.addAll(client.listContainers(DockerClient.ListContainersParam.allContainers()));
            }
            // in the future.
            for (Container nativeContainer : nativeContainers) {
                // them with a logging thread.
                if (nativeContainer.status() != null && nativeContainer.status().startsWith(Messages.Exited_specifier)) {
                    synchronized (loggingThreads) {
                        if (loggingThreads.containsKey(nativeContainer.id())) {
                            loggingThreads.get(nativeContainer.id()).requestStop();
                            loggingThreads.remove(nativeContainer.id());
                        }
                    }
                }
                // skip containers that are being removed
                if (nativeContainer.status() != null && nativeContainer.status().equals(Messages.Removal_In_Progress_specifier)) {
                    continue;
                }
                // re-use info from existing container with same id
                if (this.containers != null && this.containersById.containsKey(nativeContainer.id())) {
                    final IDockerContainer container = this.containersById.get(nativeContainer.id());
                    updatedContainersById.put(nativeContainer.id(), new DockerContainer(this, nativeContainer, container.info()));
                } else {
                    updatedContainersById.put(nativeContainer.id(), new DockerContainer(this, nativeContainer));
                }
            }
        } catch (DockerTimeoutException e) {
            if (isOpen()) {
                Activator.log(new Status(IStatus.WARNING, Activator.PLUGIN_ID, Messages.Docker_Connection_Timeout, e));
                close();
            }
        } catch (com.spotify.docker.client.exceptions.DockerException | InterruptedException e) {
            if (isOpen() && e.getCause() != null && e.getCause().getCause() != null && e.getCause().getCause() instanceof ProcessingException) {
                close();
            } else {
                throw new DockerException(e.getMessage());
            }
        } finally {
            this.containersById = updatedContainersById;
            sortedContainers = sort(updatedContainersById.values(), (container, otherContainer) -> container.name().compareTo(otherContainer.name()));
            this.containers = sortedContainers;
        }
    }
    // perform notification outside of containerLock so we don't have a View
    // causing a deadlock
    // TODO: we should probably notify the listeners only if the containers
    // list changed.
    notifyContainerListeners(sortedContainers);
    return sortedContainers;
}

Example 18 with IDockerContainer

use of org.eclipse.linuxtools.docker.core.IDockerContainer in project linuxtools by eclipse.

the class DockerContainersView method setConnection.

/**
 * Sets the active connection
 *
 * @param connection
 *            the active connection
 */
public void setConnection(final IDockerConnection connection) {
    if (connection != null && connection.equals(this.connection)) {
        return;
    }
    // remove 'this' as listener on the previous connection (if applicable)
    if (this.connection != null) {
        this.connection.removeContainerListener(this);
    }
    this.connection = connection;
    if (this.viewer != null && this.connection != null) {
        final Job refreshJob = new Job(DVMessages.getString("ContainersRefresh.msg")) {

            @Override
            protected IStatus run(IProgressMonitor monitor) {
                connection.getContainers(true);
                setLabelFilterIds();
                connection.addContainerListener(DockerContainersView.this);
                Display.getDefault().asyncExec(() -> {
                    viewer.setInput(connection);
                    refreshViewTitle();
                });
                return Status.OK_STATUS;
            }
        };
        refreshJob.schedule();
    } else if (this.viewer != null) {
        viewer.setInput(new IDockerContainer[0]);
        form.setText(DVMessages.getString(NoConnectionSelected));
    }
}

Example 19 with IDockerContainer

use of org.eclipse.linuxtools.docker.core.IDockerContainer in project linuxtools by eclipse.

the class DockerExplorerContentProvider method loadContainerInfo.

/**
 * Call the {@link IDockerConnection#getContainers(boolean)} in a background
 * job to avoid blocking the UI.
 *
 * @param container
 *            the selected {@link DockerContainersCategory}
 */
private void loadContainerInfo(final IDockerContainer container) {
    final Job loadContainersJob = new LoadingJob(// $NON-NLS-1$
    DVMessages.getString("ContainerInfoLoadJob.msg"), // $NON-NLS-1$
    container) {

        @Override
        protected IStatus run(final IProgressMonitor monitor) {
            ((DockerContainer) container).info(true);
            return Status.OK_STATUS;
        }
    };
    loadContainersJob.schedule();
}

Example 20 with IDockerContainer

use of org.eclipse.linuxtools.docker.core.IDockerContainer in project linuxtools by eclipse.

the class DockerExplorerContentProvider method getChildren.

@Override
public Object[] getChildren(final Object parentElement) {
    if (parentElement instanceof IDockerConnection) {
        // check the connection availability before returning the
        // 'containers' and 'images' child nodes.
        final IDockerConnection connection = (IDockerConnection) parentElement;
        if (connection.isOpen()) {
            return new Object[] { new DockerImagesCategory(connection), new DockerContainersCategory(connection) };
        } else if (connection.getState() == EnumDockerConnectionState.UNKNOWN) {
            open(connection);
            return new Object[] { new LoadingStub(connection) };
        } else if (connection.getState() == EnumDockerConnectionState.CLOSED) {
            synchronized (openRetryJobs) {
                Job job = openRetryJobs.get(connection);
                if (job == null) {
                    openRetry(connection);
                }
            }
            return new Object[] { new LoadingStub(connection) };
        }
        return new Object[0];
    } else if (parentElement instanceof DockerContainersCategory) {
        final DockerContainersCategory containersCategory = (DockerContainersCategory) parentElement;
        final IDockerConnection connection = containersCategory.getConnection();
        if (connection.isContainersLoaded()) {
            return connection.getContainers().toArray();
        }
        loadContainers(containersCategory);
        return new Object[] { new LoadingStub(containersCategory) };
    } else if (parentElement instanceof DockerImagesCategory) {
        final DockerImagesCategory imagesCategory = (DockerImagesCategory) parentElement;
        final IDockerConnection connection = imagesCategory.getConnection();
        if (connection.isImagesLoaded()) {
            // here we duplicate the images to show one org/repo with all
            // its tags per node in the tree
            final List<IDockerImage> allImages = connection.getImages();
            final List<IDockerImage> explorerImages = splitImageTagsByRepo(allImages);
            return explorerImages.toArray();
        }
        loadImages(imagesCategory);
        return new Object[] { new LoadingStub(imagesCategory) };
    } else if (parentElement instanceof IDockerContainer) {
        final DockerContainer container = (DockerContainer) parentElement;
        if (container.isInfoLoaded()) {
            final IDockerContainerInfo info = container.info();
            final IDockerNetworkSettings networkSettings = (info != null) ? info.networkSettings() : null;
            final IDockerHostConfig hostConfig = (info != null) ? info.hostConfig() : null;
            return new Object[] { new DockerContainerPortMappingsCategory(container, (networkSettings != null) ? networkSettings.ports() : Collections.<String, List<IDockerPortBinding>>emptyMap()), new DockerContainerVolumesCategory(container, (hostConfig != null) ? hostConfig.binds() : Collections.<String>emptyList()), new DockerContainerLinksCategory(container, (hostConfig != null) ? hostConfig.links() : Collections.<String>emptyList()) };
        }
        loadContainerInfo(container);
        return new Object[] { new LoadingStub(container) };
    } else if (parentElement instanceof DockerContainerLinksCategory) {
        final DockerContainerLinksCategory linksCategory = (DockerContainerLinksCategory) parentElement;
        return linksCategory.getLinks().toArray();
    } else if (parentElement instanceof DockerContainerPortMappingsCategory) {
        final DockerContainerPortMappingsCategory portMappingsCategory = (DockerContainerPortMappingsCategory) parentElement;
        return portMappingsCategory.getPortMappings().toArray();
    } else if (parentElement instanceof DockerContainerVolumesCategory) {
        final DockerContainerVolumesCategory volumesCategory = (DockerContainerVolumesCategory) parentElement;
        return volumesCategory.getVolumes().toArray();
    }
    return EMPTY;
}