plugins/storage/volume/nexenta/src/org/apache/cloudstack/storage/datastore/util/NexentaUtil.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.cloudstack.storage.datastore.util;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.StringTokenizer;

import com.cloud.storage.Storage;

public class NexentaUtil {
    public static final String PROVIDER_NAME = "Nexenta";

    public static final String NMS_URL = "nmsUrl";
    public static final String VOLUME = "volume";

    public static final String STORAGE_HOST = "storageHost";
    public static final String STORAGE_PORT = "storagePort";
    public static final String STORAGE_TYPE = "storageType";
    public static final String STORAGE_PATH = "storagePath";

    public static final String DEFAULT_NMS_USER = "admin";
    public static final String DEFAULT_NMS_PASSWORD = "nexenta";

    public static final String SPARSE_VOLUMES = "sparseVolumes";
    public static final String VOLUME_BLOCK_SIZE = "volumeBlockSize";

    public static final int DEFAULT_NMS_PORT = 2000;
    public static final int DEFAULT_ISCSI_TARGET_PORTAL_PORT = 3260;
    public static final int DEFAULT_NFS_PORT = 2049;

    public static final String ISCSI_TARGET_NAME_PREFIX = "iqn.1986-03.com.sun:02:cloudstack-";
    public static final String ISCSI_TARGET_GROUP_PREFIX = "cloudstack/";

    /**
     * Parse NMS url into normalized parts like scheme, user, host and others.
     *
     * Example NMS URL:
     *    auto://admin:nexenta@192.168.1.1:2000/
     *
     * NMS URL parts:
     *    auto                true if url starts with auto://, protocol will be automatically switched to https if http not supported;
     *    scheme (auto)       connection protocol (http or https);
     *    user (admin)        NMS user;
     *    password (nexenta)  NMS password;
     *    host (192.168.1.1)  NMS host;
     *    port (2000)         NMS port.
     *
     * @param nmsUrl url string to parse
     * @return instance of NexentaConnection class
     */
    public static NexentaNmsUrl parseNmsUrl(String nmsUrl) {
        URI uri;

        try {
            uri = new URI(nmsUrl);
        } catch (URISyntaxException e) {
            throw new IllegalArgumentException("Invalid URI: " + nmsUrl);
        }

        boolean isAuto = false;
        String schema = uri.getScheme();
        if (schema == null || schema.isEmpty() || "auto".equalsIgnoreCase(schema)) {
            schema = "http";
            isAuto = true;
        }

        String username, password, userInfo = uri.getUserInfo();
        if (userInfo == null) {
            username = DEFAULT_NMS_USER;
            password = DEFAULT_NMS_PASSWORD;
        } else {
            if (userInfo.indexOf(':') < 0) {
                username = userInfo;
                password = DEFAULT_NMS_PASSWORD;
            } else {
                String[] parts = userInfo.split(":", 2);
                username = parts[0];
                password = parts[1];
            }
        }

        String host = uri.getHost();
        if (host == null) {
            throw new IllegalArgumentException(String.format("NMS host required: %s.", nmsUrl));
        }

        int port = uri.getPort();
        if (port == -1) {
            port = DEFAULT_NMS_PORT;
        }

        return new NexentaNmsUrl(isAuto, schema, username, password, host, port);
    }

    public static Storage.StoragePoolType getStorageType(String v) {
        if ("iSCSI".equalsIgnoreCase(v)) {
            return Storage.StoragePoolType.Iscsi;
        } else if ("NFS".equalsIgnoreCase(v)) {
            return Storage.StoragePoolType.NetworkFilesystem;
        }
        return Storage.StoragePoolType.Iscsi;
    }

    public static class NexentaPluginParameters {
        protected NexentaNmsUrl nmsUrl;
        protected String volume;
        protected Storage.StoragePoolType storageType = Storage.StoragePoolType.Iscsi;
        protected String storageHost;
        protected Integer storagePort;
        protected String storagePath;
        protected Boolean sparseVolumes = false;
        protected String volumeBlockSize = "8K";

        public void setNmsUrl(String url) {
            this.nmsUrl = NexentaUtil.parseNmsUrl(url);
        }

        public NexentaNmsUrl getNmsUrl() {
            return nmsUrl;
        }

        public void setVolume(String volume) {
            if (volume.endsWith("/")) {
                this.volume = volume.substring(0, volume.length() - 1);
            } else {
                this.volume = volume;
            }
        }

        public String getVolume() {
            return volume;
        }

        public void setStorageType(String storageType) {
            this.storageType = NexentaUtil.getStorageType(storageType);
        }

        public Storage.StoragePoolType getStorageType() {
            return storageType;
        }

        public void setStorageHost(String host) {
            this.storageHost = host;
        }

        public String getStorageHost() {
            if (storageHost == null && nmsUrl != null) {
                return nmsUrl.getHost();
            }
            return storageHost;
        }

        public void setStoragePort(String port) {
            this.storagePort = Integer.parseInt(port);
        }

        public Integer getStoragePort() {
            if (storagePort == null && storageType != null) {
                if (storageType == Storage.StoragePoolType.Iscsi) {
                    return DEFAULT_ISCSI_TARGET_PORTAL_PORT;
                } else {
                    return DEFAULT_NFS_PORT;
                }
            }
            return storagePort;
        }

        public void setStoragePath(String path) {
            this.storagePath = path;
        }

        public String getStoragePath() {
            return storagePath;
        }

        public void setSparseVolumes(String sparseVolumes) {
            this.sparseVolumes = Boolean.TRUE.toString().equalsIgnoreCase(sparseVolumes);
        }

        public Boolean getSparseVolumes() {
            return sparseVolumes;
        }

        public void setVolumeBlockSize(String volumeBlockSize) {
            this.volumeBlockSize = volumeBlockSize;
        }

        public String getVolumeBlockSize() {
            return volumeBlockSize;
        }
    }

    public static NexentaPluginParameters parseNexentaPluginUrl(String url) {
        final String delimiter1 = ";";
        final String delimiter2 = "=";
        StringTokenizer st = new StringTokenizer(url, delimiter1);
        NexentaPluginParameters params = new NexentaPluginParameters();
        while (st.hasMoreElements()) {
            String token = st.nextElement().toString();
            int idx = token.indexOf(delimiter2);
            if (idx == -1) {
                throw new RuntimeException("Invalid URL format");
            }
            String[] urlKeyAndValue = token.split(delimiter2, 2);
            if (NMS_URL.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setNmsUrl(urlKeyAndValue[1]);
            } else if (VOLUME.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setVolume(urlKeyAndValue[1]);
            } else if (STORAGE_TYPE.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setStorageType(urlKeyAndValue[1]);
            } else if (STORAGE_HOST.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setStorageHost(urlKeyAndValue[1]);
            } else if (STORAGE_PORT.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setStoragePort(urlKeyAndValue[1]);
            } else if (STORAGE_PATH.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setStoragePath(urlKeyAndValue[1]);
            } else if (SPARSE_VOLUMES.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setSparseVolumes(urlKeyAndValue[1]);
            } else if (VOLUME_BLOCK_SIZE.equalsIgnoreCase(urlKeyAndValue[0])) {
                params.setVolumeBlockSize(urlKeyAndValue[1]);
            }
        }
        return params;
    }
}