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

Example 6 with IDockerImageInfo

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

the class ImageInspectPropertySection method getImageInfo.

/**
 * @return the {@link IDockerImageInfo} for the given
 *         {@link IDockerConnection} and {@link IDockerImage}, or
 *         <code>null</code> if none was found or if an underlying problem
 *         occurred.
 * @param connection
 *            the current {@link IDockerConnection}.
 * @param image
 *            the {@link IDockerImage} to inspect.
 */
private IDockerImageInfo getImageInfo(final IDockerConnection connection, final IDockerImage image) {
    final BlockingQueue<IDockerImageInfo> result = new ArrayBlockingQueue<>(1);
    final Job loadConnectionInfoJob = new Job(DVMessages.getString(PropertiesLoadingImageInfo)) {

        @Override
        protected IStatus run(final IProgressMonitor monitor) {
            monitor.beginTask(DVMessages.getString(PropertiesLoadingImageInfo), 1);
            final IDockerImageInfo imageInfo = connection.getImageInfo(image.id());
            if (imageInfo != null) {
                result.add(imageInfo);
            }
            monitor.done();
            return Status.OK_STATUS;
        }
    };
    loadConnectionInfoJob.schedule();
    try {
        return result.poll(2, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
        Activator.log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, DVMessages.getFormattedString(PropertiesInfoError, connection.getName()), e));
        return null;
    }
}

Example 7 with IDockerImageInfo

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

the class ImageRunResourceVolumesVariablesPage method setDefaultValues.

private void setDefaultValues() {
    try {
        // skip if a previous launch configuration was provided
        final IDockerImage selectedImage = model.getSelectedImage();
        if (selectedImage == null) {
            return;
        }
        final IDockerImageInfo selectedImageInfo = findImageInfo(selectedImage);
        // using a map filled with entries (key==value) from default volumes
        // that can be overridden by values from last launch config
        final Map<String, DataVolumeModel> volumes = new HashMap<>();
        final Set<DataVolumeModel> selectedVolumes = new HashSet<>();
        if (selectedImageInfo != null && selectedImageInfo.config() != null) {
            for (String volume : selectedImageInfo.config().volumes().keySet()) {
                volumes.put(volume, new DataVolumeModel(volume));
            }
        }
        if (lastLaunchConfiguration != null) {
            // volumes:
            final List<String> launchConfigVolumes = lastLaunchConfiguration.getAttribute(DATA_VOLUMES, Collections.<String>emptyList());
            for (String containerVolume : launchConfigVolumes) {
                final DataVolumeModel volume = DataVolumeModel.parseString(containerVolume);
                if (volume != null) {
                    volumes.put(volume.getContainerPath(), volume);
                    selectedVolumes.add(volume);
                }
            }
            // environment variables
            model.setEnvironmentVariables(lastLaunchConfiguration.getAttribute(ENV_VARIABLES, Collections.<String>emptyList()));
            // labels
            Map<String, String> labels = lastLaunchConfiguration.getAttribute(LABELS, (Map<String, String>) null);
            if (labels != null) {
                model.setLabelVariables(labels);
            }
            // resource limitations
            model.setEnableResourceLimitations(lastLaunchConfiguration.getAttribute(ENABLE_LIMITS, false));
            // CPU shares
            model.setCpuShareWeight(Long.parseLong(lastLaunchConfiguration.getAttribute(CPU_PRIORITY, Long.toString(ImageRunResourceVolumesVariablesModel.CPU_MEDIUM))));
            // retrieve memory limit stored in MB
            final long memoryLimit = Long.parseLong(lastLaunchConfiguration.getAttribute(MEMORY_LIMIT, Long.toString(ImageRunResourceVolumesVariablesModel.DEFAULT_MEMORY)));
            // make sure memory limit is not higher than maxMemory
            model.setMemoryLimit(Math.min(model.getTotalMemory(), memoryLimit));
        }
        model.setDataVolumes(volumes.values());
        model.setSelectedDataVolumes(selectedVolumes);
    } catch (CoreException | InvocationTargetException | InterruptedException e) {
        Activator.log(e);
    }
}

Example 8 with IDockerImageInfo

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

the class ImageRunSelectionPage method getImageInfo.

/**
 * @param selectedImage
 * @return the corresponding {@link IDockerImageInfo} or <code>null</code>
 *         if something went wrong.
 */
private IDockerImageInfo getImageInfo(final IDockerImage selectedImage) {
    try {
        final FindImageInfoRunnable findImageInfoRunnable = new FindImageInfoRunnable(selectedImage);
        getContainer().run(true, true, findImageInfoRunnable);
        final IDockerImageInfo selectedImageInfo = findImageInfoRunnable.getResult();
        return selectedImageInfo;
    } catch (InvocationTargetException | InterruptedException e) {
        Activator.log(e);
    }
    return null;
}

Example 9 with IDockerImageInfo

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

the class ContainerLauncher method runCommand.

/**
 * Create a Process to run an arbitrary command in a Container with uid of
 * caller so any files created are accessible to user.
 *
 * @param connectionName
 *            - uri of connection to use
 * @param imageName
 *            - name of image to use
 * @param project
 *            - Eclipse project
 * @param errMsgHolder
 *            - holder for any error messages
 * @param cmdList
 *            - command to run as list of String
 * @param workingDir
 *            - where to run command
 * @param additionalDirs
 *            - additional directories to mount
 * @param origEnv
 *            - original environment if we are appending to existing
 * @param envMap
 *            - new environment
 * @param supportStdin
 *            - support using stdin
 * @param privilegedMode
 *            - run in privileged mode
 * @param labels
 *            - labels to apply to Container
 * @param keepContainer
 *            - boolean whether to keep Container when done
 * @return Process that can be used to check for completion and for routing
 *         stdout/stderr
 *
 * @since 4.0
 */
public Process runCommand(String connectionName, String imageName, IProject project, IErrorMessageHolder errMsgHolder, List<String> cmdList, String workingDir, List<String> additionalDirs, Map<String, String> origEnv, Properties envMap, boolean supportStdin, boolean privilegedMode, HashMap<String, String> labels, boolean keepContainer) {
    Integer uid = null;
    Integer gid = null;
    // For Unix, make sure that the user id is passed with the run
    // so any output files are accessible by this end-user
    // $NON-NLS-1$
    String os = System.getProperty("os.name");
    if (os.indexOf("nux") > 0) {
        // $NON-NLS-1$
        // first try and see if we have already run a command on this
        // project
        ID ugid = fidMap.get(project);
        if (ugid == null) {
            try {
                uid = (Integer) Files.getAttribute(project.getLocation().toFile().toPath(), // $NON-NLS-1$
                "unix:uid");
                gid = (Integer) Files.getAttribute(project.getLocation().toFile().toPath(), // $NON-NLS-1$
                "unix:gid");
                ugid = new ID(uid, gid);
                // store the uid for possible later usage
                fidMap.put(project, ugid);
            } catch (IOException e) {
            // do nothing...leave as null
            }
        // $NON-NLS-1$
        } else {
            uid = ugid.getuid();
            gid = ugid.getgid();
        }
    }
    final List<String> env = new ArrayList<>();
    env.addAll(toList(origEnv));
    env.addAll(toList(envMap));
    final Map<String, List<IDockerPortBinding>> portBindingsMap = new HashMap<>();
    IDockerConnection[] connections = DockerConnectionManager.getInstance().getConnections();
    if (connections == null || connections.length == 0) {
        errMsgHolder.setErrorMessage(// $NON-NLS-1$
        Messages.getString("ContainerLaunch.noConnections.error"));
        return null;
    }
    IDockerConnection connection = null;
    for (IDockerConnection c : connections) {
        if (c.getUri().equals(connectionName)) {
            connection = c;
            break;
        }
    }
    if (connection == null) {
        errMsgHolder.setErrorMessage(Messages.getFormattedString(// $NON-NLS-1$
        "ContainerLaunch.connectionNotFound.error", connectionName));
        return null;
    }
    List<IDockerImage> images = connection.getImages();
    if (images.isEmpty()) {
        errMsgHolder.setErrorMessage(// $NON-NLS-1$
        Messages.getString("ContainerLaunch.noImages.error"));
        return null;
    }
    IDockerImageInfo info = connection.getImageInfo(imageName);
    if (info == null) {
        errMsgHolder.setErrorMessage(Messages.getFormattedString("ContainerLaunch.imageNotFound.error", // $NON-NLS-1$
        imageName));
        return null;
    }
    DockerContainerConfig.Builder builder = new DockerContainerConfig.Builder().openStdin(supportStdin).cmd(cmdList).image(imageName).workingDir(workingDir);
    // switch to user id for Linux so output is accessible
    if (uid != null) {
        builder = builder.user(uid.toString());
    }
    // add any labels if specified
    if (labels != null)
        builder = builder.labels(labels);
    DockerHostConfig.Builder hostBuilder = new DockerHostConfig.Builder().privileged(privilegedMode);
    // Note we only pass volumes to the config if we have a
    // remote daemon. Local mounted volumes are passed
    // via the HostConfig binds setting
    @SuppressWarnings("rawtypes") final Map<String, Map> remoteVolumes = new HashMap<>();
    final Map<String, String> remoteDataVolumes = new HashMap<>();
    final Set<String> readOnlyVolumes = new TreeSet<>();
    if (!((DockerConnection) connection).isLocal()) {
        // the host data over before starting.
        if (additionalDirs != null) {
            for (String dir : additionalDirs) {
                IPath p = new Path(dir).removeTrailingSeparator();
                remoteVolumes.put(p.toPortableString(), new HashMap<>());
                remoteDataVolumes.put(p.toPortableString(), p.toPortableString());
                if (dir.contains(":")) {
                    // $NON-NLS-1$
                    DataVolumeModel dvm = DataVolumeModel.parseString(dir);
                    switch(dvm.getMountType()) {
                        case HOST_FILE_SYSTEM:
                            dir = dvm.getHostPathMount();
                            remoteDataVolumes.put(dir, dvm.getContainerMount());
                            // back after command completion
                            if (dvm.isReadOnly()) {
                                readOnlyVolumes.add(dir);
                            }
                            break;
                        default:
                            continue;
                    }
                }
            }
        }
        if (workingDir != null) {
            IPath p = new Path(workingDir).removeTrailingSeparator();
            remoteVolumes.put(p.toPortableString(), new HashMap<>());
            remoteDataVolumes.put(p.toPortableString(), p.toPortableString());
        }
        builder = builder.volumes(remoteVolumes);
    } else {
        // Running daemon on local host.
        // Add mounts for any directories we need to run the executable.
        // When we add mount points, we need entries of the form:
        // hostname:mountname:Z.
        // In our case, we want all directories mounted as-is so the
        // executable will run as the user expects.
        final Set<String> volumes = new TreeSet<>();
        final List<String> volumesFrom = new ArrayList<>();
        if (additionalDirs != null) {
            for (String dir : additionalDirs) {
                IPath p = new Path(dir).removeTrailingSeparator();
                if (dir.contains(":")) {
                    // $NON-NLS-1$
                    DataVolumeModel dvm = DataVolumeModel.parseString(dir);
                    switch(dvm.getMountType()) {
                        case HOST_FILE_SYSTEM:
                            String bind = LaunchConfigurationUtils.convertToUnixPath(dvm.getHostPathMount()) + ':' + dvm.getContainerPath() + // $NON-NLS-1$ //$NON-NLS-2$
                            ":Z";
                            if (dvm.isReadOnly()) {
                                // $NON-NLS-1$
                                bind += ",ro";
                            }
                            volumes.add(bind);
                            break;
                        case CONTAINER:
                            volumesFrom.add(dvm.getContainerMount());
                            break;
                        default:
                            break;
                    }
                } else {
                    volumes.add(// $NON-NLS-1$
                    p.toPortableString() + ":" + p.toPortableString() + // $NON-NLS-1$
                    ":Z");
                }
            }
        }
        if (workingDir != null) {
            IPath p = new Path(workingDir).removeTrailingSeparator();
            volumes.add(// $NON-NLS-1$
            p.toPortableString() + ":" + p.toPortableString() + // $NON-NLS-1$
            ":Z");
        }
        List<String> volumeList = new ArrayList<>(volumes);
        hostBuilder = hostBuilder.binds(volumeList);
        if (!volumesFrom.isEmpty()) {
            hostBuilder = hostBuilder.volumesFrom(volumesFrom);
        }
    }
    final DockerContainerConfig config = builder.build();
    // add any port bindings if specified
    if (portBindingsMap.size() > 0)
        hostBuilder = hostBuilder.portBindings(portBindingsMap);
    final IDockerHostConfig hostConfig = hostBuilder.build();
    // create the container
    String containerId = null;
    try {
        containerId = ((DockerConnection) connection).createContainer(config, hostConfig, null);
    } catch (DockerException | InterruptedException e) {
        errMsgHolder.setErrorMessage(e.getMessage());
        return null;
    }
    final String id = containerId;
    final IDockerConnection conn = connection;
    if (!((DockerConnection) conn).isLocal()) {
        // data over from the host.
        if (!remoteVolumes.isEmpty()) {
            CopyVolumesJob job = new CopyVolumesJob(remoteDataVolumes, conn, id);
            job.schedule();
            try {
                job.join();
            } catch (InterruptedException e) {
            // ignore
            }
        }
    }
    // volumes so they won't be copied back on command completion
    for (String readonly : readOnlyVolumes) {
        remoteDataVolumes.remove(readonly);
    }
    return new ContainerCommandProcess(connection, imageName, containerId, remoteDataVolumes, keepContainer);
}