Centre Blaise Pascal » gZFS

package gZFS;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.List;

public class zvol {

        public Hashtable<String,zProperties> zProperties = new Hashtable<String, zProperties>();

        //private zProperties zProperty = new zProperties();

        zvol(){

                Hashtable<Object,Object> permitValueNameVolFS = new Hashtable<Object,Object>();

                permitValueNameVolFS.clear();

                zProperties zPropertyNameVolFS = new zProperties();

                zPropertyNameVolFS.setNameProperty("name");

                zPropertyNameVolFS.setLabelProperty("Name");

                zPropertyNameVolFS.setType("noupdateable");

                zPropertyNameVolFS.setValue("");

                zPropertyNameVolFS.setPermitValue(null);

                zPropertyNameVolFS.setPropertyOf("volandfs");

                zProperties.put("name", zPropertyNameVolFS);

                Hashtable<Object,Object> permitValueType = new Hashtable<Object,Object>();

                permitValueType.clear();

                zProperties zPropertyType = new zProperties();

                zPropertyType.setNameProperty("type");

                zPropertyType.setLabelProperty("Type");

                zPropertyType.setType("noupdateable");

                zPropertyType.setValue("");

                permitValueType.put("volume","volume");

                permitValueType.put("filesystem","filesystem");

                zPropertyType.setPermitValue(permitValueType);

                zPropertyType.setPropertyOf("volandfs");

                zProperties.put("type", zPropertyType);

                Hashtable<Object,Object> permitValueDate = new Hashtable<Object,Object>();

                zProperties zPropertyDate = new zProperties();

                permitValueDate.clear();

                zPropertyDate.setNameProperty("creation");

                zPropertyDate.setLabelProperty("Creation Date");

                zPropertyDate.setType("noupdateable");

                zPropertyDate.setValue("");

                zPropertyDate.setPermitValue(null);

                zPropertyDate.setPropertyOf("volandfs");

                zProperties.put("creation", zPropertyDate);

                Hashtable<Object,Object> permitValueUsed = new Hashtable<Object,Object>();

                zProperties zPropertyUsed = new zProperties();

                permitValueUsed.clear();

                zPropertyUsed.setNameProperty("used");

                zPropertyUsed.setLabelProperty("Used");

                zPropertyUsed.setType("noupdateable");

                zPropertyUsed.setValue("");

                zPropertyUsed.setPermitValue(null);

                zPropertyUsed.setPropertyOf("volandfs");

                zProperties.put("used", zPropertyUsed);

                Hashtable<Object,Object> permitValueAvailable = new Hashtable<Object,Object>();

                zProperties zPropertyAvailable = new zProperties();

                permitValueAvailable.clear();

                zPropertyAvailable.setNameProperty("available");

                zPropertyAvailable.setLabelProperty("Available");

                zPropertyAvailable.setType("noupdateable");

                zPropertyAvailable.setValue("");

                zPropertyAvailable.setPermitValue(null);

                zPropertyAvailable.setPropertyOf("fs");

                zProperties.put("available", zPropertyAvailable);

                Hashtable<Object,Object> permitValueCompressRatio = new Hashtable<Object,Object>();

                zProperties zPropertyCompressRatio = new zProperties();

                permitValueCompressRatio.clear();

                zPropertyCompressRatio.setNameProperty("compressratio");

                zPropertyCompressRatio.setLabelProperty("Compression Ratio");

                zPropertyCompressRatio.setType("noupdateable");

                zPropertyCompressRatio.setValue("");

                zPropertyCompressRatio.setPermitValue(null);

                zPropertyCompressRatio.setPropertyOf("volandfs");

                zProperties.put("compressratio", zPropertyCompressRatio);

                Hashtable<Object,Object> permitValueSize = new Hashtable<Object,Object>();

                zProperties zPropertySize = new zProperties();

                permitValueSize.clear();

                zPropertySize.setNameProperty("volsize");

                zPropertySize.setLabelProperty("Volume Size");

                zPropertySize.setType("freeentry");

                zPropertySize.setValue("");

                zPropertySize.setPermitValue(null);

                zPropertySize.setPropertyOf("volume");

                zProperties.put("volsize", zPropertySize);

                Hashtable<Object,Object> permitValueSizeVolBlockSize = new Hashtable<Object,Object>();

                zProperties zPropertySizeVolBlockSize = new zProperties();

                permitValueSizeVolBlockSize.clear();

                zPropertySizeVolBlockSize.setNameProperty("volblocksize");

                zPropertySizeVolBlockSize.setLabelProperty("Volume Block Size");

                zPropertySizeVolBlockSize.setType("noupdateable");

                zPropertySizeVolBlockSize.setValue("");

                zPropertySizeVolBlockSize.setPermitValue(null);

                zPropertySizeVolBlockSize.setPropertyOf("volume");

                zProperties.put("volblocksize", zPropertySizeVolBlockSize);

                Hashtable<Object,Object> permitValueCompress = new Hashtable<Object,Object>();

                zProperties zPropertyCompress = new zProperties();

                permitValueCompress.clear();

                zPropertyCompress.setNameProperty("compression");

                zPropertyCompress.setLabelProperty("Compression");

                zPropertyCompress.setType("nofreeentry");

                zPropertyCompress.setValue("off");

                permitValueCompress.put("off","off");

                permitValueCompress.put("on","on");

                zPropertyCompress.setPermitValue(permitValueCompress);

                zPropertyCompress.setPropertyOf("volandfs");

                zProperties.put("compression", zPropertyCompress);

                Hashtable<Object,Object> permitValueReadOnly = new Hashtable<Object,Object>();

                zProperties zPropertyReadOnly = new zProperties();

                permitValueReadOnly.clear();

                zPropertyReadOnly.setNameProperty("readonly");

                zPropertyReadOnly.setLabelProperty("Read Only");

                zPropertyReadOnly.setType("nofreeentry");

                zPropertyReadOnly.setValue("off");

                permitValueReadOnly.put("off","off");

                permitValueReadOnly.put("on","on");

                zPropertyReadOnly.setPermitValue(permitValueReadOnly);

                zPropertyReadOnly.setPropertyOf("volandfs");

                zProperties.put("readonly", zPropertyReadOnly);

                Hashtable<Object,Object> permitValueDedup = new Hashtable<Object,Object>();

                zProperties zPropertyDedup = new zProperties();

                permitValueDedup.clear();

                zPropertyDedup.setNameProperty("dedup");

                zPropertyDedup.setLabelProperty("Deduplication");

                zPropertyDedup.setType("nofreeentry");

                zPropertyDedup.setValue("off");

                permitValueDedup.put("off","off");

                permitValueDedup.put("on","on");

                zPropertyDedup.setPermitValue(permitValueDedup);

                zPropertyDedup.setPropertyOf("volandfs");

                zProperties.put("dedup", zPropertyDedup);

                Hashtable<Object,Object> permitValueCopies = new Hashtable<Object,Object>();

                zProperties zPropertyCopies = new zProperties();

                permitValueCopies.clear();

                zPropertyCopies.setNameProperty("copies");

                zPropertyCopies.setLabelProperty("Copies");

                zPropertyCopies.setType("freeentry");

                zPropertyCopies.setValue("1");

                zPropertyCopies.setPermitValue(null);

                zPropertyCopies.setPropertyOf("volandfs");

                zProperties.put("copies", zPropertyCopies);

                Hashtable<Object,Object> permitValueUsedbysnapshots = new Hashtable<Object,Object>();

                zProperties zPropertyUsedbysnapshots = new zProperties();

                permitValueUsedbysnapshots.clear();

                zPropertyUsedbysnapshots.setNameProperty("usedbysnapshots");

                zPropertyUsedbysnapshots.setLabelProperty("Used By Snapshots");

                zPropertyUsedbysnapshots.setType("noupdateable");

                zPropertyUsedbysnapshots.setValue("");

                zPropertyUsedbysnapshots.setPropertyOf("volandfs");

                zPropertyUsedbysnapshots.setPermitValue(null);

                zProperties.put("usedbysnapshots", zPropertyUsedbysnapshots);

                Hashtable<Object,Object> permitValueUsedbydataset = new Hashtable<Object,Object>();

                zProperties zPropertyUsedbydataset = new zProperties();

                permitValueUsedbydataset.clear();

                zPropertyUsedbydataset.setNameProperty("usedbydataset");

                zPropertyUsedbydataset.setLabelProperty("Used By Dataset");

                zPropertyUsedbydataset.setType("noupdateable");

                zPropertyUsedbydataset.setValue("");

                zPropertyUsedbydataset.setPermitValue(null);

                zPropertyUsedbydataset.setPropertyOf("volandfs");

                zProperties.put("usedbydataset", zPropertyUsedbydataset);

                Hashtable<Object,Object> permitValueSync = new Hashtable<Object,Object>();

                zProperties zPropertySync = new zProperties();

                permitValueSync.clear();

                zPropertySync.setNameProperty("sync");

                zPropertySync.setLabelProperty("sync");

                zPropertySync.setType("nofreeentry");

                zPropertySync.setValue("standard");

                permitValueSync.put("standard","standard");

                permitValueSync.put("always","always");

                permitValueSync.put("disabled","disabled");

                zPropertySync.setPermitValue(permitValueSync);

                zPropertySync.setPropertyOf("volandfs");

                zProperties.put("sync", zPropertySync);

                Hashtable<Object,Object> permitValueSnapdev = new Hashtable<Object,Object>();

                zProperties zPropertySnapdev = new zProperties();

                permitValueSnapdev.clear();

                zPropertySnapdev.setNameProperty("snapdev");

                zPropertySnapdev.setLabelProperty("Snapshot Device");

                zPropertySnapdev.setType("nofreeentry");

                zPropertySnapdev.setValue("visible");

                permitValueSnapdev.put("visible","visible");

                permitValueSnapdev.put("hidden","hidden");

                zPropertySnapdev.setPermitValue(permitValueSnapdev);

                zPropertySnapdev.setPropertyOf("volandfs");

                zProperties.put("snapdev", zPropertySnapdev);

                Hashtable<Object,Object> permitValueMounted = new Hashtable<Object,Object>();

                zProperties zPropertyMounted = new zProperties();

                permitValueMounted.clear();

                zPropertyMounted.setNameProperty("mounted");

                zPropertyMounted.setLabelProperty("Mounted");

                zPropertyMounted.setType("noupdateable");

                zPropertyMounted.setValue("");

                zPropertyMounted.setPermitValue(permitValueMounted);

                zPropertyMounted.setPropertyOf("fs");

                zProperties.put("mounted", zPropertyMounted);

                Hashtable<Object,Object> permitValueQuota = new Hashtable<Object,Object>();

                zProperties zPropertyQuota = new zProperties();

                permitValueQuota.clear();

                zPropertyQuota.setNameProperty("quota");

                zPropertyQuota.setLabelProperty("Quota");

                zPropertyQuota.setType("freeentry");

                zPropertyQuota.setValue("");

                zPropertyQuota.setPermitValue(permitValueQuota);

                zPropertyQuota.setPropertyOf("fs");

                zProperties.put("quota", zPropertyQuota);

                Hashtable<Object,Object> permitValueReservation = new Hashtable<Object,Object>();

                zProperties zPropertyReservation = new zProperties();

                permitValueReservation.clear();

                zPropertyReservation.setNameProperty("reservation");

                zPropertyReservation.setLabelProperty("Reservation");

                zPropertyReservation.setType("freeentry");

                zPropertyReservation.setValue("");

                zPropertyReservation.setPermitValue(permitValueReservation);

                zPropertyReservation.setPropertyOf("fs");

                zProperties.put("reservation", zPropertyReservation);

                Hashtable<Object,Object> permitValueRecordsize = new Hashtable<Object,Object>();

                zProperties zPropertyRecordsize = new zProperties();

                permitValueRecordsize.clear();

                zPropertyRecordsize.setNameProperty("recordsize");

                zPropertyRecordsize.setLabelProperty("Record Size");

                zPropertyRecordsize.setType("noupdateable");

                zPropertyRecordsize.setValue("");

                zPropertyRecordsize.setPermitValue(permitValueRecordsize);

                zPropertyRecordsize.setPropertyOf("fs");

                zProperties.put("recordsize", zPropertyRecordsize);

                Hashtable<Object,Object> permitValueMountpoint = new Hashtable<Object,Object>();

                zProperties zPropertyMountpoint = new zProperties();

                permitValueMountpoint.clear();

                zPropertyMountpoint.setNameProperty("mountpoint");

                zPropertyMountpoint.setLabelProperty("Mount Point");

                zPropertyMountpoint.setType("noupdateable");

                zPropertyMountpoint.setValue("");

                zPropertyMountpoint.setPermitValue(null);

                zPropertyMountpoint.setPropertyOf("fs");

                zProperties.put("mountpoint", zPropertyMountpoint);

                Hashtable<Object,Object> permitValueSharenfs = new Hashtable<Object,Object>();

                zProperties zPropertySharenfs = new zProperties();

                permitValueSharenfs.clear();

                zPropertySharenfs.setNameProperty("sharenfs");

                zPropertySharenfs.setLabelProperty("Share NFS");

                zPropertySharenfs.setType("nofreeentry");

                zPropertySharenfs.setValue("off");

                permitValueSharenfs.put("off","off");

                permitValueSharenfs.put("on","on");

                zPropertySharenfs.setPermitValue(permitValueSharenfs);

                zPropertySharenfs.setPropertyOf("fs");

                zProperties.put("sharenfs", zPropertySharenfs);

                Hashtable<Object,Object> permitValueAtime = new Hashtable<Object,Object>();

                zProperties zPropertyAtime = new zProperties();

                permitValueAtime.clear();

                zPropertyAtime.setNameProperty("atime");

                zPropertyAtime.setLabelProperty("Atime");

                zPropertyAtime.setType("nofreeentry");

                zPropertyAtime.setValue("on");

                permitValueAtime.put("on","on");

                permitValueAtime.put("off","off");

                zPropertyAtime.setPermitValue(permitValueAtime);

                zPropertyAtime.setPropertyOf("fs");

                zProperties.put("atime", zPropertyAtime);

                Hashtable<Object,Object> permitValueDevices = new Hashtable<Object,Object>();

                zProperties zPropertyDevices = new zProperties();

                permitValueDevices.clear();

                zPropertyDevices.setNameProperty("devices");

                zPropertyDevices.setLabelProperty("Devices");

                zPropertyDevices.setType("nofreeentry");

                zPropertyDevices.setValue("on");

                permitValueDevices.put("on","on");

                permitValueDevices.put("off","off");

                zPropertyDevices.setPropertyOf("fs");

                zPropertyDevices.setPermitValue(permitValueDevices);

                zProperties.put("devices", zPropertyDevices);

                Hashtable<Object,Object> permitValueExec = new Hashtable<Object,Object>();

                zProperties zPropertyExec = new zProperties();

                permitValueExec.clear();

                zPropertyExec.setNameProperty("exec");

                zPropertyExec.setLabelProperty("Exec");

                zPropertyExec.setType("nofreeentry");

                zPropertyExec.setValue("on");

                permitValueExec.put("on","on");

                permitValueExec.put("off","off");

                zPropertyExec.setPermitValue(permitValueExec);

                zPropertyExec.setPropertyOf("fs");

                zProperties.put("exec", zPropertyExec);

                Hashtable<Object,Object> permitValueSetuid = new Hashtable<Object,Object>();

                zProperties zPropertySetuid = new zProperties();

                permitValueSetuid.clear();

                zPropertySetuid.setNameProperty("setuid");

                zPropertySetuid.setLabelProperty("Setuid");

                zPropertySetuid.setType("nofreeentry");

                zPropertySetuid.setValue("on");

                permitValueSetuid.put("on","on");

                permitValueSetuid.put("off","off");

                zPropertySetuid.setPermitValue(permitValueSetuid);

                zPropertySetuid.setPropertyOf("fs");

                zProperties.put("setuid", zPropertySetuid);

                Hashtable<Object,Object> permitValueZoned = new Hashtable<Object,Object>();

                zProperties zPropertyZoned = new zProperties();

                permitValueZoned.clear();

                zPropertyZoned.setNameProperty("zoned");

                zPropertyZoned.setLabelProperty("Zoned");

                zPropertyZoned.setType("nofreeentry");

                zPropertyZoned.setValue("off");

                permitValueZoned.put("off","off");

                permitValueZoned.put("on","on");

                zPropertyZoned.setPermitValue(permitValueZoned);

                zPropertyZoned.setPropertyOf("fs");

                zProperties.put("zoned", zPropertyZoned);

                Hashtable<Object,Object> permitValueSnapdir = new Hashtable<Object,Object>();

                zProperties zPropertySnapdir = new zProperties();

                permitValueSnapdir.clear();

                zPropertySnapdir.setNameProperty("snapdir");

                zPropertySnapdir.setLabelProperty("Snapdir");

                zPropertySnapdir.setType("nofreeentry");

                zPropertySnapdir.setValue("visible");

                permitValueSnapdir.put("visible","visible");

                permitValueSnapdir.put("hidden","hidden");

                zPropertySnapdir.setPermitValue(permitValueSnapdir);

                zPropertySnapdir.setPropertyOf("fs");

                zProperties.put("snapdir", zPropertySnapdir);

                Hashtable<Object,Object> permitValueAclinherit = new Hashtable<Object,Object>();

                zProperties zPropertyAclinherit = new zProperties();

                permitValueAclinherit.clear();

                zPropertyAclinherit.setNameProperty("aclinherit");

                zPropertyAclinherit.setLabelProperty("Aclinherit");

                zPropertyAclinherit.setType("nofreeentry");

                zPropertyAclinherit.setValue("restricted");

                permitValueAclinherit.put("restricted","restricted");

                permitValueAclinherit.put("discard","discard");

                permitValueAclinherit.put("noallow","noallow");

                permitValueAclinherit.put("passthrough","passthrough");

                permitValueAclinherit.put("passthrough-x","passthrough-x");

                zPropertyAclinherit.setPermitValue(permitValueAclinherit);

                zPropertyAclinherit.setPropertyOf("fs");

                zProperties.put("aclinherit", zPropertyAclinherit);

                Hashtable<Object,Object> permitValueCanmount = new Hashtable<Object,Object>();

                zProperties zPropertyCanmount = new zProperties();

                permitValueCanmount.clear();

                zPropertyCanmount.setNameProperty("canmount");

                zPropertyCanmount.setLabelProperty("Can Mount");

                zPropertyCanmount.setType("nofreeentry");

                zPropertyCanmount.setValue("on");

                permitValueCanmount.put("on","on");

                permitValueCanmount.put("off","off");

                zPropertyCanmount.setPermitValue(permitValueCanmount);

                zPropertyCanmount.setPropertyOf("fs");

                zProperties.put("canmount", zPropertyCanmount);

                Hashtable<Object,Object> permitValueXattr = new Hashtable<Object,Object>();

                zProperties zPropertyXattr = new zProperties();

                permitValueXattr.clear();

                zPropertyXattr.setNameProperty("xattr");

                zPropertyXattr.setLabelProperty("Xattr");

                zPropertyXattr.setType("nofreeentry");

                zPropertyXattr.setValue("on");

                permitValueXattr.put("on","on");

                permitValueXattr.put("off","off");

                zPropertyXattr.setPermitValue(permitValueXattr);

                zPropertyXattr.setPropertyOf("fs");

                zProperties.put("xattr", zPropertyXattr);

                Hashtable<Object,Object> permitValueUtf8only = new Hashtable<Object,Object>();

                zProperties zPropertyUtf8only = new zProperties();

                permitValueUtf8only.clear();

                zPropertyUtf8only.setNameProperty("utf8only");

                zPropertyUtf8only.setLabelProperty("Utf8only");

                zPropertyUtf8only.setType("nofreeentry");

                zPropertyUtf8only.setValue("off");

                permitValueUtf8only.put("off","off");

                permitValueUtf8only.put("on","on");

                zPropertyUtf8only.setPermitValue(permitValueUtf8only);

                zPropertyUtf8only.setPropertyOf("fs");

                zProperties.put("utf8only", zPropertyUtf8only);

                Hashtable<Object,Object> permitValueNormalization = new Hashtable<Object,Object>();

                zProperties zPropertyNormalization = new zProperties();

                permitValueNormalization.clear();

                zPropertyNormalization.setNameProperty("normalization");

                zPropertyNormalization.setLabelProperty("Normalization");

                zPropertyNormalization.setType("nofreeentry");

                zPropertyNormalization.setValue("none");

                permitValueNormalization.put("none","none");

                permitValueNormalization.put("formC","formC");

                permitValueNormalization.put("formD","formD");

                permitValueNormalization.put("formKC","formKC");

                permitValueNormalization.put("formKD","formKD");

                zPropertyNormalization.setPermitValue(permitValueNormalization);

                zPropertyNormalization.setPropertyOf("fs");

                zProperties.put("normalization", zPropertyNormalization);

                Hashtable<Object,Object> permitValueCasesensitive = new Hashtable<Object,Object>();

                zProperties zPropertyCasesensitive = new zProperties();

                permitValueCasesensitive.clear();

                zPropertyCasesensitive.setNameProperty("casesensitivity");

                zPropertyCasesensitive.setLabelProperty("Case Sensitivity");

                zPropertyCasesensitive.setType("nofreeentry");

                zPropertyCasesensitive.setValue("sensitive");

                permitValueCasesensitive.put("sensitive","sensitive");

                permitValueCasesensitive.put("insensitive","insensitive");

                permitValueCasesensitive.put("mixed","mixed");

                zPropertyCasesensitive.setPermitValue(permitValueCasesensitive);

                zPropertyCasesensitive.setPropertyOf("fs");

                zProperties.put("casesensitivity", zPropertyCasesensitive);

                Hashtable<Object,Object> permitValueVscan = new Hashtable<Object,Object>();

                zProperties zPropertyVscan = new zProperties();

                permitValueVscan.clear();

                zPropertyVscan.setNameProperty("vscan");

                zPropertyVscan.setLabelProperty("Vscan");

                zPropertyVscan.setType("nofreeentry");

                zPropertyVscan.setValue("off");

                permitValueVscan.put("off","off");

                permitValueVscan.put("on","on");

                zPropertyVscan.setPermitValue(permitValueVscan);

                zPropertyVscan.setPropertyOf("fs");

                zProperties.put("vscan", zPropertyVscan);

                Hashtable<Object,Object> permitValueNbmand = new Hashtable<Object,Object>();

                zProperties zPropertyNbmand = new zProperties();

                permitValueNbmand.clear();

                zPropertyNbmand.setNameProperty("nbmand");

                zPropertyNbmand.setLabelProperty("Non Blocking mandatory locks");

                zPropertyNbmand.setType("nofreeentry");

                zPropertyNbmand.setValue("off");

                permitValueNbmand.put("off","off");

                permitValueNbmand.put("on","on");

                zPropertyNbmand.setPermitValue(permitValueNbmand);

                zPropertyNbmand.setPropertyOf("fs");

                zProperties.put("nbmand", zPropertyNbmand);

                Hashtable<Object,Object> permitValueSharesmb = new Hashtable<Object,Object>();

                zProperties zPropertySharesmb = new zProperties();

                permitValueSharesmb.clear();

                zPropertySharesmb.setNameProperty("sharesmb");

                zPropertySharesmb.setLabelProperty("Share SMB");

                zPropertySharesmb.setType("nofreeentry");

                zPropertySharesmb.setValue("off");

                permitValueSharesmb.put("off","off");

                permitValueSharesmb.put("on","on");

                zPropertySharesmb.setPermitValue(permitValueSharesmb);

                zPropertySharesmb.setPropertyOf("fs");

                zProperties.put("sharesmb", zPropertySharesmb);

                Hashtable<Object,Object> permitValueOrigin = new Hashtable<Object,Object>();

                zProperties zPropertyOrigin = new zProperties();

                permitValueOrigin.clear();

                zPropertyOrigin.setNameProperty("origin");

                zPropertyOrigin.setLabelProperty("Clone Origin");

                zPropertyOrigin.setType("noupdateable");

                zPropertyOrigin.setValue("");

                zPropertyOrigin.setPermitValue(null);

                zPropertyOrigin.setPropertyOf("volandfs");

                zProperties.put("origin", zPropertyOrigin);

                Hashtable<Object,Object> permitValueClone = new Hashtable<Object,Object>();

                zProperties zPropertyClone = new zProperties();

                permitValueClone.clear();

                zPropertyClone.setNameProperty("clone");

                zPropertyClone.setLabelProperty("Clone");

                zPropertyClone.setType("noupdateable");

                zPropertyClone.setValue("");

                zPropertyClone.setPermitValue(null);

                zPropertyClone.setPropertyOf("volandfs");

                zProperties.put("clone", zPropertyClone);

        }

}