path: root/src/org.gluster.storage.management.console/src/org/gluster/storage/management/console/views/VolumeSummaryView.java

/*******************************************************************************
 * Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com>
 * This file is part of Gluster Management Console.
 *
 * Gluster Management Console is free software; you can redistribute
 * it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * Gluster Management Console is distributed in the hope that it
 * will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see
 * <http://www.gnu.org/licenses/>.
 *******************************************************************************/
package org.gluster.storage.management.console.views;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.fieldassist.ControlDecoration;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.widgets.FormText;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Hyperlink;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.part.ViewPart;
import org.gluster.storage.management.client.VolumesClient;
import org.gluster.storage.management.console.GlusterDataModelManager;
import org.gluster.storage.management.console.IImageKeys;
import org.gluster.storage.management.console.toolbar.GlusterToolbarManager;
import org.gluster.storage.management.console.utils.GUIHelper;
import org.gluster.storage.management.core.constants.CoreConstants;
import org.gluster.storage.management.core.constants.GlusterConstants;
import org.gluster.storage.management.core.model.Alert;
import org.gluster.storage.management.core.model.Brick;
import org.gluster.storage.management.core.model.Cluster;
import org.gluster.storage.management.core.model.DefaultClusterListener;
import org.gluster.storage.management.core.model.Device;
import org.gluster.storage.management.core.model.Disk;
import org.gluster.storage.management.core.model.Event;
import org.gluster.storage.management.core.model.GlusterServer;
import org.gluster.storage.management.core.model.Partition;
import org.gluster.storage.management.core.model.Volume;
import org.gluster.storage.management.core.model.Server.SERVER_STATUS;
import org.gluster.storage.management.core.model.Volume.VOLUME_TYPE;
import org.gluster.storage.management.core.utils.NumberUtil;
import org.gluster.storage.management.core.utils.StringUtil;
import org.gluster.storage.management.core.utils.ValidationUtil;


public class VolumeSummaryView extends ViewPart {
	public static final String ID = VolumeSummaryView.class.getName();
	private static final GUIHelper guiHelper = GUIHelper.getInstance();

	private final FormToolkit toolkit = new FormToolkit(Display.getCurrent());
	private ScrolledForm form;
	private Volume volume;
	private Label volumeType;
	private CLabel lblStatusValue;
	private DefaultClusterListener volumeChangedListener;
	private Hyperlink changeLink;
	private Hyperlink cifsChangeLink;
	private Text accessControlText;
	private Text cifsUsersText;
	private ControlDecoration errDecoration;
	private ControlDecoration errCifsDecoration;
	private Composite parent;
	private static final String COURIER_FONT = "Courier";
	private GlusterDataModelManager modelManager = GlusterDataModelManager.getInstance();
	private Cluster cluster = modelManager.getModel().getCluster();
	private Button nfsCheckBox;
	private FormText glusterNfsMountText;
	private String nfsMountInfo;
	private Label nfsLabel;
	private String nfs;

	private Label numberOfBricks;
	private Label totalDiskSpace;
	private Composite alertsSection;
	private Button cifsCheckbox;
	private Label cifsLabel;
	private Composite cifsUpdateLinkComposite;

	@Override
	public void createPartControl(Composite parent) {
		if (volume == null) {
			volume = guiHelper.getSelectedEntity(getSite(), Volume.class);
		}

		this.parent = parent;
		setPartName("Summary");
		createSections();

		final GlusterToolbarManager toolbarManager = new GlusterToolbarManager(getSite().getWorkbenchWindow());
		// Refresh the navigation tree whenever there is a change to the data model
		volumeChangedListener = new DefaultClusterListener() {
			@Override
			public void volumeChanged(Volume volume, Event event) {
				updateVolumeStatusLabel();
				populateAccessControlText();
				changeNFSStatus(volume.isNfsEnabled());
				updateBrickChanges(volume);
				toolbarManager.updateToolbar(volume);
				cifsCheckbox.setSelection(volume.isCifsEnable());
				populateCifsUsersText();
				renderVolumeTypeField();
			}

			@Override
			public void alertsGenerated() {
				super.alertsGenerated();
				guiHelper.clearSection(alertsSection);
				populateAlertSection();
				alertsSection.layout();
			}
		};
		modelManager.addClusterListener(volumeChangedListener);
	}

	@Override
	public void dispose() {
		super.dispose();
		modelManager.removeClusterListener(volumeChangedListener);
	}

	private void createSections() {
		form = guiHelper.setupForm(parent, toolkit, "Volume Properties [" + volume.getName() + "]");

		createVolumePropertiesSection();
		createVolumeMountingInfoSection();
		createVolumeAlertsSection();

		parent.layout(); // IMP: lays out the form properly
	}

	private void createVolumeAlertsSection() {
		alertsSection = guiHelper.createSection(form, toolkit, "Alerts", null, 1, false);
		populateAlertSection();
	}

	private void populateAlertSection() {
		List<Alert> alerts = cluster.getAlerts();

		for (int i = 0; i < alerts.size(); i++) {
			if (alerts.get(i).getType() == Alert.ALERT_TYPES.OFFLINE_VOLUME_BRICKS_ALERT
					&& alerts.get(i).getReference().split(":")[0].trim().equals(volume.getName())) {
				addAlertLabel(alertsSection, alerts.get(i));
			}
		}
	}

	private void addAlertLabel(Composite section, Alert alert) {
		CLabel lblAlert = new CLabel(section, SWT.NONE);
		lblAlert.setImage(guiHelper.getImage(IImageKeys.BRICK_OFFLINE_22x22));
		lblAlert.setText(alert.getMessage());
		lblAlert.redraw();
	}

	private FormText setFormTextStyle(FormText formText, String fontName, int size, int style) {
		Font font = new Font(Display.getCurrent(), new FontData(fontName, size, style));
		formText.setFont(font);
		return formText;
	}

	private void createVolumeMountingInfoSection() {
		String glusterFs = "Gluster:";
		nfs = "NFS:";
		String onlineServers = getOnlineServers(10); // Limited to 10 servers
		String firstOnlineServer = onlineServers.split(",")[0].trim();
		String glusterFsMountInfo = "mount -t glusterfs " + firstOnlineServer + ":/" + volume.getName()
				+ " <mount-point>";
		nfsMountInfo = "mount -t nfs " + firstOnlineServer + ":/" + volume.getName() + " <mount-point>";
		// TODO: if more than 10 servers...
		String info = "Server can be any server name in the storage cloud eg. <" + onlineServers + ">";

		Composite section = guiHelper.createSection(form, toolkit, "Mounting Information", null, 3, false);

		toolkit.createLabel(section, glusterFs, SWT.NORMAL);
		FormText glusterfsMountText = setFormTextStyle(toolkit.createFormText(section, true), COURIER_FONT, 10,
				SWT.NONE);
		glusterfsMountText.setText(glusterFsMountInfo, false, false);
		glusterfsMountText.setLayoutData(new GridData(GridData.BEGINNING, GridData.VERTICAL_ALIGN_CENTER, false, false,
				2, 0)); // Label spanned two column

		nfsLabel = toolkit.createLabel(section, nfs, SWT.NONE);
		GridData data = new GridData();
		data.horizontalAlignment = SWT.FILL;
		nfsLabel.setLayoutData(data);

		glusterNfsMountText = setFormTextStyle(toolkit.createFormText(section, true), COURIER_FONT, 10, SWT.NONE);
		glusterNfsMountText.setText(nfsMountInfo, false, false);
		glusterNfsMountText.setLayoutData(new GridData(GridData.BEGINNING, GridData.VERTICAL_ALIGN_CENTER, false,
				false, 2, 0));

		changeNFSStatus(nfsCheckBox.getSelection());

		toolkit.createLabel(section, "");
		Label infoLabel = toolkit.createLabel(section, info, SWT.NONE);
		infoLabel.setLayoutData(new GridData(GridData.BEGINNING, GridData.VERTICAL_ALIGN_CENTER, false, false, 2, 0));

		// TODO: implement a logic to identify the corresponding glusterfs client download link
		String message = "You can download GlusterFS client from";
		String glusterFSDownloadlinkText = "here.";
		final String glusterFSDownloadlink = "http://download.gluster.com/pub/gluster/glusterfs/";

		toolkit.createLabel(section, "");
		toolkit.createLabel(section, message);
		Hyperlink link = toolkit.createHyperlink(section, glusterFSDownloadlinkText, SWT.NORMAL);
		link.addHyperlinkListener(new HyperlinkAdapter() {
			public void linkActivated(HyperlinkEvent e) {
				try {
					System.out.println(e.getLabel() + " [" + e.getHref() + "]");
					PlatformUI.getWorkbench().getBrowserSupport().getExternalBrowser()
							.openURL(new URL(glusterFSDownloadlink));
				} catch (PartInitException e1) {
					e1.printStackTrace();
				} catch (MalformedURLException e1) {
					e1.printStackTrace();
				}
			}
		});
	}

	private String getOnlineServers(int maxServers) {
		List<String> OnlineServers = new ArrayList<String>();
		for (GlusterServer server : cluster.getServers()) {
			if (server.getStatus() == SERVER_STATUS.ONLINE) {
				OnlineServers.add(server.getName());
				if (OnlineServers.size() >= maxServers) {
					break;
				}
			}
		}
		return StringUtil.collectionToString(OnlineServers, ", ") + ((OnlineServers.size() > maxServers) ? "..." : "");
	}

	/**
	 * 
	 */
	private void createVolumePropertiesSection() {
		Composite section = guiHelper.createSection(form, toolkit, "Properties", null, 3, false);

		createVolumeTypeField(section);

		VOLUME_TYPE volumeType = volume.getVolumeType();
		if (volumeType == VOLUME_TYPE.DISTRIBUTED_REPLICATE) {
			createReplicaCountField(section);
		}

		if (volumeType == VOLUME_TYPE.DISTRIBUTED_STRIPE) {
			createStripeCountField(section);
		}

		createNumOfBricksField(section);
		createDiskSpaceField(section);
		// createTransportTypeField(section);
		createNASProtocolField(section);
		createCifsField(section);
		createAccessControlField(section);
		createStatusField(section);
	}

	private GridData createDefaultLayoutData() {
		GridData layoutData = new GridData();
		layoutData.minimumWidth = 300;
		layoutData.widthHint = 300;
		return layoutData;
	}

	private void createCifsField(Composite section) {
		cifsLabel = toolkit.createLabel(section, "CIFS: ", SWT.NONE);
		cifsUsersText = toolkit.createText(section, volume.getAccessControlList(), SWT.BORDER);
		populateCifsUsersText();
		addKeyListenerForCifsUser();

		cifsUpdateLinkComposite = toolkit.createComposite(section, SWT.NONE);
		cifsUpdateLinkComposite.setLayout(new FillLayout());
		cifsUpdateLinkComposite.setVisible(volume.isCifsEnable());

		createChangeLinkForCifs(cifsUpdateLinkComposite);
		renderCifsUsers(cifsCheckbox.getSelection());
		errCifsDecoration = guiHelper.createErrorDecoration(cifsUsersText);
		errCifsDecoration.hide();
	}

	private void createAccessControlField(Composite section) {
		toolkit.createLabel(section, "Allow Access From: ", SWT.NONE);
		accessControlText = toolkit.createText(section, volume.getAccessControlList(), SWT.BORDER);

		populateAccessControlText();
		addKeyListenerForAccessControl();
		accessControlText.setLayoutData(createDefaultLayoutData());
		accessControlText.setEnabled(false);
		createChangeLinkForAccessControl(section);

		// error decoration used while validating the access control text
		errDecoration = guiHelper.createErrorDecoration(accessControlText);
		errDecoration.hide();
		createAccessControlInfoLabel(section); // info text
	}

	private void createAccessControlInfoLabel(Composite section) {
		toolkit.createLabel(section, "", SWT.NONE);
		Label accessControlInfoLabel = toolkit.createLabel(section, "(Comma separated list of IP addresses/hostnames)");
		GridData data = new GridData(SWT.LEFT, SWT.CENTER, true, false);
		data.horizontalSpan = 2;
		accessControlInfoLabel.setLayoutData(data);
	}

	private void createChangeLinkForAccessControl(Composite section) {
		changeLink = toolkit.createHyperlink(section, "change", SWT.NONE);
		changeLink.addHyperlinkListener(new HyperlinkAdapter() {

			private void finishEdit() {
				saveAccessControlList();
			}

			private void startEdit() {
				accessControlText.setEnabled(true);
				accessControlText.setFocus();
				accessControlText.selectAll();
				changeLink.setText("update");
			}

			@Override
			public void linkActivated(HyperlinkEvent e) {
				if (accessControlText.isEnabled()) {
					// we were already in edit mode.
					finishEdit();
				} else {
					// Get in to edit mode
					startEdit();
				}
			}
		});
	}

	private void saveAccessControlList() {
		final String newACL = accessControlText.getText();

		guiHelper.setStatusMessage("Setting access control list to [" + newACL + "]...");
		parent.update();

		if (newACL.equals(volume.getAccessControlList())) {
			accessControlText.setEnabled(false);
			changeLink.setText("change");
		} else if (ValidationUtil.isValidAccessControl(newACL)) {
			BusyIndicator.showWhile(Display.getDefault(), new Runnable() {
				@Override
				public void run() {
					try {
						new VolumesClient().setVolumeOption(volume.getName(), Volume.OPTION_AUTH_ALLOW, newACL);
						accessControlText.setEnabled(false);
						changeLink.setText("change");

						modelManager.setAccessControlList(volume, newACL);
					} catch (Exception e) {
						MessageDialog.openError(Display.getDefault().getActiveShell(), "Access control", e.getMessage());
					}
				}
			});
		} else {
			MessageDialog.openError(Display.getDefault().getActiveShell(), "Access control", "Invalid IP / Host name ");
		}
		guiHelper.clearStatusMessage();
		parent.update();
	}

	private void createChangeLinkForCifs(Composite section) {
		cifsChangeLink = toolkit.createHyperlink(section, "change", SWT.NONE);
		cifsChangeLink.addHyperlinkListener(new HyperlinkAdapter() {

			private void finishEdit() {
				saveCifsConfiguration();
			}

			private void startEdit() {
				if (cifsCheckbox.getSelection()) {
					enableCifsUsersControls(true);
					cifsUsersText.selectAll();
				}
			}

			@Override
			public void linkActivated(HyperlinkEvent e) {
				if (cifsUsersText.isEnabled()) {
					// we were already in edit mode.
					finishEdit();
				} else {
					// Get in to edit mode
					startEdit();
				}
			}
		});
	}

	private void saveCifsConfiguration() {
		guiHelper.setStatusMessage("Setting Cifs Configuration...");
		parent.update();

		// To check if no changes in the users list
		if (!isvalidCifsUser()) {
			MessageDialog.openError(Display.getDefault().getActiveShell(), "Cifs Configuration",
					"Please enter cifs users name");
			enableCifsUsersControls(true);
			validateCifsUsers();
			// } else if (cifsUsers.equals(configuredUsers)) { // Nothing to do.
			// enableCifsUsersControls(false);
		} else {
			BusyIndicator.showWhile(Display.getDefault(), new Runnable() {
				@Override
				public void run() {
					VolumesClient vc = new VolumesClient();
					Volume newVolume = new Volume();
					Integer userAction = 1;
					String cifsUsers = cifsUsersText.getText().trim();
					List<String> servers = GlusterDataModelManager.getInstance().getOfflineServers();
					// One or more servers are offline, Show warning if cifs is enabled
					if (servers != null && servers.size() > 0) {
						userAction = new MessageDialog(parent.getShell(), "CIFS configuration", GUIHelper
								.getInstance().getImage(IImageKeys.VOLUME_16x16),
								"Performing CIFS updates when one or more servers are offline can trigger "
										+ "inconsistent behavior for CIFS accesses in the cluster."
										+ CoreConstants.NEWLINE + CoreConstants.NEWLINE
										+ "Are you sure you want to continue?", MessageDialog.QUESTION, new String[] {
										"No", "Yes" }, -1).open();
					}
					
					// If no cifs users and removing cifs config, nothing to do
					if (!(!cifsCheckbox.getSelection() && volume.getCifsUsers().toString().equals("[]") && (cifsUsers
							.isEmpty() || cifsUsers.equals(""))) && userAction == 1) {
						try {
							vc.setCifsConfig(volume.getName(), cifsCheckbox.getSelection(), cifsUsers);
							enableCifsUsersControls(false);
							newVolume = vc.getVolume(volume.getName());
							modelManager.volumeChanged(volume, newVolume);
							showCifsUsersControls(volume.isCifsEnable());
						} catch (Exception e) {
							MessageDialog.openError(Display.getDefault().getActiveShell(), "Cifs Configuration",
									e.getMessage());
							cifsCheckbox.setSelection(volume.isCifsEnable());
							enableCifsUsersControls(cifsCheckbox.getSelection());
							populateCifsUsersText();
						}
					} else {
						newVolume = vc.getVolume(volume.getName());
						modelManager.volumeChanged(volume, newVolume);
						showCifsUsersControls(volume.isCifsEnable());
					}
				}
			});
		}
		guiHelper.clearStatusMessage();
		parent.update();
	}

	private void saveNFSOption() {
		guiHelper.setStatusMessage("Setting NFS option...");
		parent.update();

		BusyIndicator.showWhile(Display.getDefault(), new Runnable() {
			@Override
			public void run() {
				try {
					boolean enableNfs = nfsCheckBox.getSelection();
					new VolumesClient().setVolumeOption(volume.getName(), Volume.OPTION_NFS_DISABLE,
							(enableNfs) ? GlusterConstants.OFF : GlusterConstants.ON);
					modelManager.setNfsEnabled(volume, enableNfs);
				} catch (Exception e) {
					MessageDialog.openError(Display.getDefault().getActiveShell(), "NFS Option", e.getMessage());
				}
			}
		});
		guiHelper.clearStatusMessage();
		parent.update();
	}

	private void addKeyListenerForAccessControl() {
		accessControlText.addKeyListener(new KeyAdapter() {
			public void keyReleased(KeyEvent key) {
				switch (key.keyCode) {
				case SWT.ESC:
					// Reset to default
					populateAccessControlText();
					changeLink.setText("change");
					accessControlText.setEnabled(false);
					break;
				case 13:
					// User has pressed enter. Save the new value
					saveAccessControlList();
					break;
				}

				validateAccessControlList();
			}
		});
	}

	private void populateAccessControlText() {
		String accessControlList = volume.getAccessControlList();
		if (accessControlList == null) {
			// if not set, show default value
			accessControlList = modelManager.getVolumeOptionDefaultValue(Volume.OPTION_AUTH_ALLOW);
		}
		accessControlText.setText(accessControlList);
	}

	private void addKeyListenerForCifsUser() {
		cifsUsersText.addKeyListener(new KeyAdapter() {
			public void keyReleased(KeyEvent key) {
				switch (key.keyCode) {
				case SWT.ESC:
					// Reset to default
					populateCifsUsersText();
					enableCifsUsersControls(false);
					if (cifsUsersText.getText().trim().length() == 0) { // Disable CIFS as well
						cifsCheckbox.setSelection(false);
					}
					form.reflow(true);
					break;
				case 13:
					// User has pressed enter. Save the new value
					saveCifsConfiguration();
					break;
				}
				validateCifsUsers();
			}
		});
	}

	private void populateCifsUsersText() {
		List<String> userList = volume.getCifsUsers();
		if (volume.isCifsEnable() && userList != null) {
			cifsUsersText.setText(StringUtil.collectionToString(userList, ","));
		} else {
			cifsUsersText.setText("");
		}
	}

	private void createNASProtocolField(final Composite section) {
		toolkit.createLabel(section, "Access Protocols: ", SWT.NONE);

		Composite nasProtocolsComposite = toolkit.createComposite(section);
		nasProtocolsComposite.setLayout(new FillLayout());

		createCheckbox(nasProtocolsComposite, "Gluster", true, false);

		nfsCheckBox = createCheckbox(nasProtocolsComposite, "NFS", volume.isNfsEnabled(), true);

		nfsCheckBox.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				if (!nfsCheckBox.getSelection()) {
					Integer userAction = new MessageDialog(parent.getShell(), "NFS Re-export", GUIHelper.getInstance()
							.getImage(IImageKeys.VOLUME_16x16),
							"Are you sure you want to stop the NFS Re-export for volume [" + volume.getName() + "]?",
							MessageDialog.QUESTION, new String[] { "No", "Yes" }, -1).open();
					if (userAction <= 0) { // user select cancel or pressed escape key
						nfsCheckBox.setSelection(true);
						return;
					}
				}
				saveNFSOption();
			}
		});

		// CIFS checkbox
		cifsCheckbox = createCheckbox(nasProtocolsComposite, "CIFS", volume.isCifsEnable(), true);
		createCifsCheckboxListner(cifsCheckbox);

		toolkit.createLabel(section, "", SWT.NONE); // dummy
	}

	private void createCifsCheckboxListner(final Button cifsCheckbox) {
		cifsCheckbox.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				if (cifsCheckbox.getSelection()) {
					// need to enable cifs
					// TODO: Open the text box (empty and enabled),
					// the hyperlink next to the textbox should have label "update"
					// when user clicks on that hyperlink,
					// saveCifsConfiguration should be called
					// Also, if user presses the "ESC" key,
					// return to the previous state of checkbox and hide the textbox + hyperlink
					showCifsUsersControls(true);
					enableCifsUsersControls(true);
					// saveCifsConfiguration();
				} else {
					// need to disable cifs
					// TODO: hide the textbox and the link AFTER disabling cifs
					if ((volume.getCifsUsers() == null || volume.getCifsUsers().toString().equals("[]"))
							&& cifsUsersText.getText().trim().equals("")) {
						showCifsUsersControls(false);
						enableCifsUsersControls(false);
					} else {

						Integer userAction = new MessageDialog(parent.getShell(), "CIFS Re-export", GUIHelper
								.getInstance().getImage(IImageKeys.VOLUME_16x16),
								"Are you sure you want to stop the CIFS re-export for volume [" + volume.getName()
										+ "]?", MessageDialog.QUESTION, new String[] { "No", "Yes" }, -1).open();
						if (userAction <= 0) { // user select cancel or pressed escape key
							cifsCheckbox.setSelection(true); // back to previous state.
						} else {
							showCifsUsersControls(false);
							enableCifsUsersControls(false);
							saveCifsConfiguration();
						}
					}
				}
				populateCifsUsersText();
				form.reflow(true);
			}
		});
	}

	private void renderCifsUsers(Boolean cifsSelection) {
		if (cifsSelection) {
			enableCifsUsersControls(false);
			showCifsUsersControls(true);
		} else {
			showCifsUsersControls(false);
		}
	}

	private void showCifsUsersControls(Boolean visible) {
		if (visible) {
			GridData data = new GridData();
			data.heightHint = 20;
			data.widthHint = 100;
			cifsLabel.setLayoutData(data);

			GridData data1 = new GridData();
			data1.heightHint = 20;
			data1.widthHint = 300;

			cifsUsersText.setLayoutData(data1);

			GridData data2 = new GridData();
			data2.heightHint = 25;
			data2.widthHint = 75;
			cifsUpdateLinkComposite.setLayoutData(data2);
		} else {
			GridData data = new GridData();
			data.heightHint = 0;

			cifsLabel.setLayoutData(data);
			cifsUsersText.setLayoutData(data);
			cifsUpdateLinkComposite.setLayoutData(data);
		}

		cifsLabel.setVisible(visible);
		cifsUsersText.setVisible(visible);
		cifsUpdateLinkComposite.setVisible(visible);
		form.reflow(true);
	}

	private void enableCifsUsersControls(Boolean enable) {
		cifsUsersText.setEnabled(enable);
		cifsChangeLink.setText((enable) ? "update" : "change");
		if (enable) {
			cifsUsersText.setFocus();
			validateCifsUsers();
		} else {
			if (errCifsDecoration != null) {
				errCifsDecoration.hide();
			}
		}
	}

	private Button createCheckbox(Composite parent, String label, boolean checked, boolean enabled) {
		final Button checkBox = toolkit.createButton(parent, label, SWT.CHECK);
		checkBox.setSelection(checked);
		checkBox.setEnabled(enabled);
		return checkBox;
	}

	private void changeNFSStatus(Boolean isNFSExported) {
		glusterNfsMountText.setVisible(isNFSExported);
		nfsLabel.setVisible(isNFSExported);
		nfsCheckBox.setSelection(isNFSExported);
	}

	private void updateBrickChanges(Volume volume) {
		numberOfBricks.setText("" + volume.getNumOfBricks());
		totalDiskSpace.setText("" + NumberUtil.formatNumber(getTotalDiskSpace() / 1024));
	}

	private double getDiskSize(String serverName, String deviceName) {
		double diskSize = 0;
		GlusterServer server = cluster.getServer(serverName);
		if (server.getStatus() == SERVER_STATUS.ONLINE) {
			for (Disk disk : server.getDisks()) {
				if (disk.getName().equals(deviceName)) {
					diskSize = disk.getSpace();
					break;
				}

				if (disk.hasPartitions()) {
					for (Partition partition : disk.getPartitions()) {
						if (partition.getName().equals(deviceName)) {
							diskSize = partition.getSpace();
							break;
						}
					}
				}
			}
		}
		return diskSize;
	}

	private double getTotalDiskSpace() {
		List<Double> diskSizes = getVolumeDiskSizes();
		VOLUME_TYPE volumeType = volume.getVolumeType();
		double diskSize = 0d;
		if (volumeType == VOLUME_TYPE.DISTRIBUTE || volumeType == VOLUME_TYPE.STRIPE
				|| volumeType == VOLUME_TYPE.DISTRIBUTED_STRIPE) {
			for (Double size : diskSizes) {
				diskSize += size;
			}
		} else { // Replicate or distributed replicate
			int replicaCount = volume.getReplicaCount();
			if (replicaCount == 0) {
				replicaCount = Volume.DEFAULT_REPLICA_COUNT;
			}
			int startIndex = 0;
			for (int i = 0; i < (diskSizes.size() / replicaCount); i++) {
				startIndex = i * replicaCount;
				diskSize += Collections.min(diskSizes.subList(startIndex, startIndex + replicaCount));
			}
		}
		return diskSize;
	}
	
	private List<Double> getVolumeDiskSizes() {
		List<Double> diskSizes = new ArrayList<Double>();
		Device device;
		for (Brick brick : volume.getBricks()) {
			device = modelManager.getDeviceForBrickDir(brick);
			diskSizes.add( (device == null) ? 0d : getDiskSize(brick.getServerName(), device.getName()) );
		}
		return diskSizes;
	}
	
	

	private void createDiskSpaceField(Composite section) {
		Label diskSpaceLabel = toolkit.createLabel(section, "Total Disk Space (GB): ", SWT.NONE);
		diskSpaceLabel.setToolTipText("<b>bold</b>normal");
		totalDiskSpace = toolkit.createLabel(section,
				"" + NumberUtil.formatNumber(getTotalDiskSpace() / 1024), SWT.NONE);
		toolkit.createLabel(section, "", SWT.NONE); // dummy
	}

	private void createStatusField(Composite section) {
		toolkit.createLabel(section, "Status: ", SWT.NONE);

		lblStatusValue = new CLabel(section, SWT.NONE);
		updateVolumeStatusLabel();

		toolkit.createLabel(section, "", SWT.NONE); // dummy
	}

	private void updateVolumeStatusLabel() {
		lblStatusValue.setText(volume.getStatusStr());
		lblStatusValue.setImage((volume.getStatus() == Volume.VOLUME_STATUS.ONLINE) ? guiHelper
				.getImage(IImageKeys.STATUS_ONLINE_16x16) : guiHelper.getImage(IImageKeys.STATUS_OFFLINE_16x16));
		GridData data = new GridData();
		data.horizontalAlignment = SWT.FILL;
		lblStatusValue.setLayoutData(data);
		lblStatusValue.redraw();
	}

	private void createNumOfBricksField(Composite section) {
		toolkit.createLabel(section, "Number of Bricks: ", SWT.NONE);
		numberOfBricks = toolkit.createLabel(section, "" + volume.getNumOfBricks(), SWT.NONE);
		toolkit.createLabel(section, "", SWT.NONE); // dummy
	}

	private void createStripeCountField(Composite section) {
		toolkit.createLabel(section, "Stripe Count: ", SWT.NONE);
		toolkit.createLabel(section, "" + volume.getStripeCount(), SWT.NONE);
		toolkit.createLabel(section, "", SWT.NONE); // dummy
	}

	private void createReplicaCountField(Composite section) {
		toolkit.createLabel(section, "Replica Count: ", SWT.NONE);
		toolkit.createLabel(section, "" + volume.getReplicaCount(), SWT.NONE);
		toolkit.createLabel(section, "", SWT.NONE); // dummy
	}

	private void createVolumeTypeField(Composite section) {
		toolkit.createLabel(section, "Volume Type: ", SWT.NONE);
		volumeType = toolkit.createLabel(section, volume.getVolumeTypeStr(), SWT.NONE);
		toolkit.createLabel(section, "", SWT.NONE);
	}
	
	private void renderVolumeTypeField() {
		volumeType.setText(volume.getVolumeTypeStr());
	}

	@Override
	public void setFocus() {
		form.setFocus();
	}

	private void validateAccessControlList() {
		errDecoration.hide();

		if (accessControlText.getText().length() == 0) {
			errDecoration.setDescriptionText("Access control list cannot be empty!");
			errDecoration.show();
			return;
		}

		if (!ValidationUtil.isValidAccessControl(accessControlText.getText())) {
			errDecoration.setDescriptionText("Invalid IP address/Host name ["
					+ ValidationUtil.getInvalidIpOrHostname(accessControlText.getText())
					+ "]. Please enter a valid value!");
			errDecoration.show();
		}
	}

	private void validateCifsUsers() {
		errCifsDecoration.hide();
		if (cifsCheckbox.getSelection()) {
			String cifsUserList = cifsUsersText.getText().trim();
			if (cifsUserList.length() == 0) {
				errCifsDecoration.setDescriptionText("Please enter cifs user name");
				errCifsDecoration.show();
			}
		}
	}

	private boolean isvalidCifsUser() {
		if (cifsCheckbox.getSelection()) {
			String cifsUserList = cifsUsersText.getText().trim();
			return (cifsUserList.length() != 0);
		}
		validateCifsUsers();
		return true;
	}

}