/*******************************************************************************
* Copyright (c) 2015, 2016 Red Hat Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Red Hat - Initial Contribution
*******************************************************************************/
package org.eclipse.linuxtools.internal.docker.ui.launch;
import static org.eclipse.linuxtools.internal.docker.ui.launch.IRunDockerImageLaunchConfigurationConstants.MEMORY_LIMIT;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.beans.BeanProperties;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
import org.eclipse.jface.databinding.swt.WidgetProperties;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.linuxtools.docker.ui.Activator;
import org.eclipse.linuxtools.internal.docker.ui.SWTImagesFactory;
import org.eclipse.linuxtools.internal.docker.ui.wizards.ImageRunResourceVolumesVariablesModel;
import org.eclipse.linuxtools.internal.docker.ui.wizards.WizardMessages;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Scale;
import org.eclipse.swt.widgets.Text;
public class RunImageResourcesTab extends AbstractLaunchConfigurationTab {
private static final String TAB_NAME = "RunResourcesTab.name"; //$NON-NLS-1$
private static final int COLUMNS = 2;
private final DataBindingContext dbc = new DataBindingContext();
private ImageRunResourceVolumesVariablesModel model = null;
private Composite container;
public RunImageResourcesTab(ImageRunResourceVolumesVariablesModel model) {
this.model = model;
}
@Override
public void createControl(Composite parent) {
final Composite container = new Composite(parent, SWT.NONE);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).span(1, 1)
.grab(true, false).applyTo(container);
GridLayoutFactory.fillDefaults().numColumns(COLUMNS).margins(6, 6)
.applyTo(container);
if (model == null) {
setErrorMessage(LaunchMessages.getString("NoConnectionError.msg"));
} else {
setErrorMessage(null);
createResourceSettingsContainer(container);
}
setControl(container);
}
private void createResourceSettingsContainer(final Composite parent) {
final Composite container = new Composite(parent, SWT.NONE);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL)
.span(COLUMNS, 1).grab(true, false).applyTo(container);
GridLayoutFactory.fillDefaults().spacing(10, 2).applyTo(container);
final Button enableResourceLimitationButton = new Button(container,
SWT.CHECK);
enableResourceLimitationButton.setText(WizardMessages.getString(
"ImageRunResourceVolVarPage.enableLimitationButton")); //$NON-NLS-1$
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.applyTo(enableResourceLimitationButton);
dbc.bindValue(
WidgetProperties.selection()
.observe(enableResourceLimitationButton),
BeanProperties
.value(ImageRunResourceVolumesVariablesModel.class,
ImageRunResourceVolumesVariablesModel.ENABLE_RESOURCE_LIMITATIONS)
.observe(model));
final int COLUMNS = 5;
final int INDENT = 20;
final Composite subContainer = new Composite(container, SWT.NONE);
setContainer(subContainer);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL)
.indent(INDENT, 0).span(COLUMNS, 1).grab(true, false)
.applyTo(subContainer);
GridLayoutFactory.fillDefaults().numColumns(COLUMNS).margins(6, 6)
.spacing(10, 2).applyTo(subContainer);
// specify CPU limitation
final Label cpuPriorityLabel = new Label(subContainer, SWT.NONE);
cpuPriorityLabel.setText(WizardMessages
.getString("ImageRunResourceVolVarPage.cpuPriorityLabel")); //$NON-NLS-1$
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.grab(false, false).applyTo(cpuPriorityLabel);
final Button lowCPULimitationButton = new Button(subContainer,
SWT.RADIO);
lowCPULimitationButton.setText(WizardMessages
.getString("ImageRunResourceVolVarPage.lowButton")); //$NON-NLS-1$
bindButton(lowCPULimitationButton,
ImageRunResourceVolumesVariablesModel.CPU_LOW);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.applyTo(lowCPULimitationButton);
final Button mediumCPULimitationButton = new Button(subContainer,
SWT.RADIO);
mediumCPULimitationButton.setText(WizardMessages
.getString("ImageRunResourceVolVarPage.mediumButton")); //$NON-NLS-1$
bindButton(mediumCPULimitationButton,
ImageRunResourceVolumesVariablesModel.CPU_MEDIUM);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.applyTo(mediumCPULimitationButton);
final Button highCPULimitationButton = new Button(subContainer,
SWT.RADIO);
highCPULimitationButton.setText(WizardMessages
.getString("ImageRunResourceVolVarPage.highButton")); //$NON-NLS-1$
bindButton(highCPULimitationButton,
ImageRunResourceVolumesVariablesModel.CPU_HIGH);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).span(2, 1)
.applyTo(highCPULimitationButton);
// Memory limitation
final Label memoryLimitLabel = new Label(subContainer, SWT.NONE);
memoryLimitLabel.setText(WizardMessages
.getString("ImageRunResourceVolVarPage.memoryLimit")); //$NON-NLS-1$
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.grab(false, false).applyTo(memoryLimitLabel);
final Scale memoryLimitSpinner = new Scale(subContainer, SWT.NONE);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.grab(false, false).span(2, 1).applyTo(memoryLimitSpinner);
memoryLimitSpinner.setBackground(
Display.getDefault().getSystemColor(SWT.COLOR_TRANSPARENT));
memoryLimitSpinner.setMinimum(0);
memoryLimitSpinner.setMaximum(this.model.getTotalMemory());
memoryLimitSpinner.setPageIncrement(64);
dbc.bindValue(WidgetProperties.selection().observe(memoryLimitSpinner),
BeanProperties
.value(ImageRunResourceVolumesVariablesModel.class,
ImageRunResourceVolumesVariablesModel.MEMORY_LIMIT)
.observe(model));
final Text memoryLimitValueText = new Text(subContainer, SWT.BORDER);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.grab(false, false).hint(50, SWT.DEFAULT)
.applyTo(memoryLimitValueText);
dbc.bindValue(
WidgetProperties.text(SWT.Modify).observe(memoryLimitValueText),
BeanProperties
.value(ImageRunResourceVolumesVariablesModel.class,
ImageRunResourceVolumesVariablesModel.MEMORY_LIMIT)
.observe(model));
dbc.bindValue(WidgetProperties.selection().observe(memoryLimitSpinner),
BeanProperties
.value(ImageRunResourceVolumesVariablesModel.class,
ImageRunResourceVolumesVariablesModel.MEMORY_LIMIT)
.observe(model));
final Label memoryLimitValueLabel = new Label(subContainer, SWT.NONE);
memoryLimitValueLabel.setText("MB"); //$NON-NLS-1$
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)
.grab(false, false).applyTo(memoryLimitValueLabel);
// enable/disable controls
final IObservableValue enableResourceLimitationsObservable = BeanProperties
.value(ImageRunResourceVolumesVariablesModel.class,
ImageRunResourceVolumesVariablesModel.ENABLE_RESOURCE_LIMITATIONS)
.observe(model);
dbc.bindValue(
WidgetProperties.selection()
.observe(enableResourceLimitationButton),
enableResourceLimitationsObservable);
enableResourceLimitationsObservable
.addChangeListener(onEnableResourceLimitation(subContainer));
toggleResourceLimitationControls(subContainer);
}
private void setContainer(final Composite container) {
this.container = container;
}
private Composite getContainer() {
return container;
}
/**
* Binds the given <code>cpuShares</code> value to the given {@link Button}
* when it is selected.
*
* @param button
* the {@link Button} to bind
* @param cpuShares
* the <code>cpuShares</code> to bind to the {@link Button}
* @return
*/
private Binding bindButton(final Button button, final long cpuShares) {
return dbc.bindValue(WidgetProperties.selection().observe(button),
BeanProperties
.value(ImageRunResourceVolumesVariablesModel.class,
ImageRunResourceVolumesVariablesModel.CPU_SHARE_WEIGHT)
.observe(model),
new UpdateValueStrategy() {
@Override
public Object convert(Object value) {
if (value.equals(Boolean.TRUE)) {
return cpuShares;
}
return 0l;
}
}, new UpdateValueStrategy() {
@Override
public Object convert(final Object value) {
return value.equals(cpuShares);
}
});
}
private IChangeListener onEnableResourceLimitation(
final Composite container) {
return event -> toggleResourceLimitationControls(container);
}
private void toggleResourceLimitationControls(Composite container) {
for (Control childControl : container.getChildren()) {
if (model.isEnableResourceLimitations()) {
childControl.setEnabled(true);
} else {
childControl.setEnabled(false);
}
updateLaunchConfigurationDialog();
}
}
@Override
public Image getImage() {
return SWTImagesFactory.get(SWTImagesFactory.IMG_RESOURCE);
}
@Override
public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
// TODO Auto-generated method stub
}
@Override
public void initializeFrom(ILaunchConfiguration configuration) {
if (model == null)
return;
try {
boolean enableLimits = configuration.getAttribute(
IRunDockerImageLaunchConfigurationConstants.ENABLE_LIMITS,
false);
model.setEnableResourceLimitations(enableLimits);
long cpuShareWeight = Long.parseLong(configuration.getAttribute(
IRunDockerImageLaunchConfigurationConstants.CPU_PRIORITY,
Long.toString(
ImageRunResourceVolumesVariablesModel.CPU_MEDIUM)));
model.setCpuShareWeight(cpuShareWeight);
int maxMemory = this.model.getTotalMemory();
// retrieve memory limit stored in MB
final long memoryLimit = Long
.parseLong(configuration.getAttribute(MEMORY_LIMIT,
Long.toString(
ImageRunResourceVolumesVariablesModel.DEFAULT_MEMORY)));
// make sure memory limit is not higher than maxMemory
model.setMemoryLimit(Math.min(maxMemory, memoryLimit));
toggleResourceLimitationControls(getContainer());
} catch (CoreException e) {
Activator.logErrorMessage(
LaunchMessages.getString(
"RunDockerImageLaunchConfiguration.load.failure"), //$NON-NLS-1$
e);
}
model.addPropertyChangeListener(
new LaunchConfigurationChangeListener());
}
@Override
public void performApply(ILaunchConfigurationWorkingCopy configuration) {
if (model == null)
return;
configuration.setAttribute(
IRunDockerImageLaunchConfigurationConstants.ENABLE_LIMITS,
model.isEnableResourceLimitations());
configuration.setAttribute(
IRunDockerImageLaunchConfigurationConstants.MEMORY_LIMIT,
Long.toString(model.getMemoryLimit()));
configuration.setAttribute(
IRunDockerImageLaunchConfigurationConstants.CPU_PRIORITY,
Long.toString(model.getCpuShareWeight()));
}
@Override
public String getName() {
return LaunchMessages.getString(TAB_NAME);
}
private class LaunchConfigurationChangeListener
implements PropertyChangeListener {
@Override
public void propertyChange(final PropertyChangeEvent evt) {
updateLaunchConfigurationDialog();
}
}
}