// 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.
using log4net;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// C# versions of certain CloudStack types to simplify JSON serialisation.
// Limit to the number of types, becasue they are written and maintained manually.
// JsonProperty used to identify property name when serialised, which allows
// later adoption of C# naming conventions if requried. 
namespace HypervResource
{
    public class PrimaryDataStoreTO
    {
        private string path;
        public string host;
        private string poolType;
        public Uri uri;
        public string _role;

        public string Path
        {
            get
            {
                if (this.isLocal)
                {
                    return path;
                }
                else
                {
                    return this.UncPath;
                }
            }
            set
            {
                this.path = value;
            }
        }

        public string UncPath
        {
            get
            {
                string uncPath = null;
                if (uri != null && (uri.Scheme.Equals("cifs") || uri.Scheme.Equals("networkfilesystem") || uri.Scheme.Equals("smb")))
                {
                    uncPath = @"\\" + uri.Host + uri.LocalPath;
                }
                return uncPath;
            }
        }

        public Boolean isLocal
        {
            get
            {
                if (poolType.Equals("Filesystem"))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public static PrimaryDataStoreTO ParseJson(dynamic json)
        {
            PrimaryDataStoreTO result = null;
            if (json == null)
            {
                return result;
            }

            dynamic primaryDataStoreTOJson = json[CloudStackTypes.PrimaryDataStoreTO];
            if (primaryDataStoreTOJson != null)
            {
                result = new PrimaryDataStoreTO()
                {
                    path = (string)primaryDataStoreTOJson.path,
                    host = (string)primaryDataStoreTOJson.host,
                    poolType = (string)primaryDataStoreTOJson.poolType
                };

                if (!result.isLocal)
                {
                    // Delete security credentials in original command.  Prevents logger from spilling the beans, as it were.
                    String uriStr = @"cifs://" + result.host + result.path;
                    result.uri = new Uri(uriStr);
                }
            }
            return result;
        }
    }

    public class VolumeObjectTO
    {
        private static ILog logger = LogManager.GetLogger(typeof(VolumeObjectTO));

        public string FullFileName
        {
            get
            {
                string fileName = null;
                if (this.primaryDataStore != null)
                {
                    PrimaryDataStoreTO store = this.primaryDataStore;
                    if (store.isLocal)
                    {
                        String volume = this.path;
                        if (String.IsNullOrEmpty(volume))
                        {
                            volume = this.uuid;
                        }
                        fileName = Path.Combine(store.Path, volume);
                    }
                    else
                    {
                        String volume = this.path;
                        if (String.IsNullOrEmpty(volume))
                        {
                            volume = this.uuid;
                        }
                        fileName = @"\\" + store.uri.Host + store.uri.LocalPath + @"\" + volume;
                        fileName = Utils.NormalizePath(fileName);
                    }
                }
                else if (this.nfsDataStore != null)
                {
                    fileName = this.nfsDataStore.UncPath;
                    if (this.path != null)
                    {
                        fileName = Utils.NormalizePath(fileName + @"\" + this.path);
                    }

                    if (fileName != null && !File.Exists(fileName))
                    {
                        fileName = Utils.NormalizePath(fileName + @"\" + this.uuid);
                    }
                }
                else
                {
                    String errMsg = "Invalid dataStore in VolumeObjectTO spec";
                    logger.Error(errMsg);
                    throw new InvalidDataException(errMsg);
                }

                if (fileName != null && !Path.HasExtension(fileName) && this.format != null)
                {
                    fileName = fileName + "." + this.format.ToLowerInvariant();
                }

                return fileName;
            }
        }

        public dynamic dataStore;
        public string format;
        public string name;
        public string path;
        public string uuid;
        public ulong size;
        public PrimaryDataStoreTO primaryDataStore;
        public NFSTO nfsDataStore;

        public static VolumeObjectTO ParseJson(dynamic json)
        {
            VolumeObjectTO result = null;

            if (json == null)
            {
                return result;
            }

            dynamic volumeObjectTOJson = json[CloudStackTypes.VolumeObjectTO];
            if (volumeObjectTOJson != null)
            {
                result = new VolumeObjectTO()
                {
                    dataStore = volumeObjectTOJson.dataStore,
                    format = ((string)volumeObjectTOJson.format),
                    name = (string)volumeObjectTOJson.name,
                    path = volumeObjectTOJson.path,
                    uuid = (string)volumeObjectTOJson.uuid,
                    size = (ulong)volumeObjectTOJson.size
                };
                result.primaryDataStore = PrimaryDataStoreTO.ParseJson(volumeObjectTOJson.dataStore);
                result.nfsDataStore = NFSTO.ParseJson(volumeObjectTOJson.dataStore);

                // Assert
                if (result.dataStore == null || (result.primaryDataStore == null && result.nfsDataStore == null))
                {
                    String errMsg = "VolumeObjectTO missing dataStore in spec " + Utils.CleanString(volumeObjectTOJson.ToString());
                    logger.Error(errMsg);
                    throw new ArgumentNullException(errMsg);
                }

                GuessFileExtension(result);
            }
            return result;
        }

        private static void GuessFileExtension(VolumeObjectTO volInfo)
        {
            if (String.IsNullOrEmpty(volInfo.format))
            {
                logger.Info("No image format in VolumeObjectTO, going to use format from first file that matches " + volInfo.FullFileName);

                string path = null;
                if (volInfo.primaryDataStore != null)
                {
                    if (volInfo.primaryDataStore.isLocal)
                    {
                        path = volInfo.primaryDataStore.Path;
                    }
                    else
                    {
                        path = volInfo.primaryDataStore.UncPath;
                    }
                }
                else if (volInfo.nfsDataStore != null)
                {
                    path = volInfo.nfsDataStore.UncPath;
                    if (volInfo.path != null)
                    {
                        path += @"\" + volInfo.path;
                    }
                }
                else
                {
                    String errMsg = "VolumeObjectTO missing dataStore in spec " + Utils.CleanString(volInfo.ToString());
                    logger.Error(errMsg);
                    throw new ArgumentNullException(errMsg);
                }

                path = Utils.NormalizePath(path);
                if (Directory.Exists(path))
                {
                    string[] choices = Directory.GetFiles(path, volInfo.uuid + ".vhd*");
                    if (choices.Length != 1)
                    {
                        String errMsg = "Tried to guess file extension, but cannot find file corresponding to " +
                            Path.Combine(volInfo.primaryDataStore.Path, volInfo.uuid);
                        logger.Debug(errMsg);
                    }
                    else
                    {
                        string[] splitFileName = choices[0].Split(new char[] { '.' });
                        volInfo.format = splitFileName[splitFileName.Length - 1];
                    }
                }
                logger.Debug("Going to use file " + volInfo.FullFileName);
            }
        }
    }

    public class TemplateObjectTO
    {
        /// <summary>
        /// Full file name varies depending on whether the TemplateObjectTO has a path or not.
        /// If it has a path, we use that.  Otherwise, we build it from the name, extension and data store path.
        /// </summary>
        public string FullFileName
        {
            get
            {
                string fileName = null;
                if (this.primaryDataStore != null)
                {
                    PrimaryDataStoreTO store = this.primaryDataStore;
                    if (store.isLocal)
                    {
                        fileName = Path.Combine(store.Path, this.uuid);
                    }
                    else
                    {
                        fileName = @"\\" + store.uri.Host + store.uri.LocalPath + @"\" + this.uuid;
                    }
                    fileName = fileName + '.' + this.format.ToLowerInvariant();
                }
                else if (this.nfsDataStoreTO != null)
                {
                    fileName = this.nfsDataStoreTO.UncPath;
                    if (this.path != null)
                    {
                        fileName = Utils.NormalizePath(fileName + @"\" + this.path);
                    }

                    if (fileName != null && !File.Exists(fileName))
                    {
                        fileName = Utils.NormalizePath(fileName + @"\" + this.uuid);
                    }

                    if (!this.format.Equals("RAW"))
                    {
                        fileName = fileName + '.' + this.format.ToLowerInvariant();
                    }
                }
                else
                {
                    fileName = this.path;
                }
                return Utils.NormalizePath(fileName);
            }
        }

        public dynamic imageDataStore;
        public string format;
        public string name;
        public string uuid;
        public S3TO s3DataStoreTO = null;
        public NFSTO nfsDataStoreTO = null;
        public PrimaryDataStoreTO primaryDataStore = null;
        public string path;
        public string checksum;
        public string size;
        public string id;

        public static TemplateObjectTO ParseJson(dynamic json)
        {
            TemplateObjectTO result = null;
            dynamic templateObjectTOJson = json[CloudStackTypes.TemplateObjectTO];
            if (templateObjectTOJson != null)
            {
                result = new TemplateObjectTO()
                {
                    imageDataStore = templateObjectTOJson.imageDataStore,
                    format = (string)templateObjectTOJson.format,
                    name = (string)templateObjectTOJson.name,
                    uuid = (string)templateObjectTOJson.uuid,
                    path = (string)templateObjectTOJson.path,
                    checksum = (string)templateObjectTOJson.checksum,
                    size = (string)templateObjectTOJson.size,
                    id = (string)templateObjectTOJson.id
                };
                result.s3DataStoreTO = S3TO.ParseJson(templateObjectTOJson.imageDataStore);
                result.nfsDataStoreTO = NFSTO.ParseJson(templateObjectTOJson.imageDataStore);
                result.primaryDataStore = PrimaryDataStoreTO.ParseJson(templateObjectTOJson.imageDataStore);
            }

            return result;
        }
    }

    public class S3TO
    {
        public string bucketName;
        public string secretKey;
        public string accessKey;
        public string endpoint;
        public bool httpsFlag;

        public static S3TO ParseJson(dynamic json)
        {
            S3TO result = null;
            if (json != null)
            {
                dynamic s3TOJson = json[CloudStackTypes.S3TO];
                if (s3TOJson != null)
                {
                    result = new S3TO()
                    {
                        bucketName = (string)s3TOJson.bucketName,
                        secretKey = (string)s3TOJson.secretKey,
                        accessKey = (string)s3TOJson.accessKey,
                        endpoint = (string)s3TOJson.endPoint,
                        httpsFlag = (bool)s3TOJson.httpsFlag
                    };
                    // Delete security credentials in original command. Prevents logger from spilling the beans, as it were.
                    s3TOJson.secretKey = string.Empty;
                    s3TOJson.accessKey = string.Empty;
                }
            }
            return result;
        }
    }

    public class NFSTO
    {
        public Uri uri;
        public string _role;
        public string UncPath
        {
            get
            {
                string uncPath = null;
                if (uri.Scheme.Equals("cifs"))
                {
                    uncPath = @"\\" + uri.Host + uri.LocalPath;
                }
                return uncPath;
            }
        }

        public static NFSTO ParseJson(dynamic json)
        {
            NFSTO result = null;
            if (json != null)
            {
                dynamic nfsTOJson = json[CloudStackTypes.NFSTO];
                if (nfsTOJson != null)
                {
                    result = new NFSTO()
                    {
                        _role = (string)nfsTOJson._role,
                    };
                    // Delete security credentials in original command.  Prevents logger from spilling the beans, as it were.
                    String uriStr = (String)nfsTOJson._url;
                    result.uri = new Uri(uriStr);
                }
            }
            return result;
        }
    }

    public class DiskTO
    {
        public string type;
        public string diskSequence = null;
        public TemplateObjectTO templateObjectTO = null;
        public VolumeObjectTO volumeObjectTO = null;

        public static DiskTO ParseJson(dynamic json)
        {
            DiskTO result = null;
            if (json != null)
            {
                result = new DiskTO()
                {
                    templateObjectTO = TemplateObjectTO.ParseJson(json.data),
                    volumeObjectTO = VolumeObjectTO.ParseJson(json.data),
                    type = (string)json.type,
                    diskSequence = json.diskSeq
                };
            }

            return result;
        }
    }

    enum VolumeType
    {
        UNKNOWN,
        ROOT,
        SWAP,
        DATADISK,
        ISO
    };

    public enum StoragePoolType
    {
        /// <summary>
        /// local directory
        /// </summary>
        Filesystem,
        /// <summary>
        /// NFS or CIFS 
        /// </summary>
        NetworkFilesystem,
        /// <summary>
        /// shared LUN, with a clusterfs overlay 
        /// </summary>
        IscsiLUN,
        /// <summary>
        /// for e.g., ZFS Comstar 
        /// </summary>
        Iscsi,
        /// <summary>
        /// for iso image
        /// </summary>
        ISO,
        /// <summary>
        /// XenServer local LVM SR
        /// </summary>
        LVM,
        /// <summary>
        /// 
        /// </summary>
        CLVM,
        /// <summary>
        /// 
        /// </summary>
        RBD,
        /// <summary>
        /// 
        /// </summary>
        SharedMountPoint,
        /// <summary>
        /// VMware VMFS storage 
        /// </summary>
        VMFS,
        /// <summary>
        /// for XenServer, Storage Pool is set up by customers. 
        /// </summary>
        PreSetup,
        /// <summary>
        /// XenServer local EXT SR 
        /// </summary>
        EXT,
        /// <summary>
        /// 
        /// </summary>
        OCFS2,
        /// <summary>
        /// for hyper-v
        /// </summary>
        SMB
    }

    public enum StorageResourceType
    {
        STORAGE_POOL, STORAGE_HOST, SECONDARY_STORAGE, LOCAL_SECONDARY_STORAGE
    }

    public struct VolumeInfo
    {
#pragma warning disable 0414
        public long id;
        public string type;
        public string storagePoolType;
        public string storagePoolUuid;
        public string name;
        public string mountPoint;
        public string path;
        long size;
        string chainInfo;
#pragma warning restore 0414

        public VolumeInfo(long id, string type, string poolType, String poolUuid, String name, String mountPoint, String path, long size, String chainInfo)
        {
            this.id = id;
            this.name = name;
            this.path = path;
            this.size = size;
            this.type = type;
            this.storagePoolType = poolType;
            this.storagePoolUuid = poolUuid;
            this.mountPoint = mountPoint;
            this.chainInfo = chainInfo;
        }
    }

    public class VmState
    {
#pragma warning disable 0414
        [JsonProperty("state")]
        public String state;
        [JsonProperty("host")]
        String host;
#pragma warning restore 0414
        public VmState() { }
        public VmState(String vmState, String host)
        {
            this.state = vmState;
            this.host = host;
        }
    }

    public struct StoragePoolInfo
    {
#pragma warning disable 0414
        [JsonProperty("uuid")]
        public String uuid;
        [JsonProperty("host")]
        String host;
        [JsonProperty("localPath")]
        String localPath;
        [JsonProperty("hostPath")]
        String hostPath;
        [JsonProperty("poolType")]
        string poolType;
        [JsonProperty("capacityBytes")]
        long capacityBytes;

        // Management server copies this field to the 'used_byptes' in the database table 'storage_pool'.
        [JsonProperty("availableBytes")]
        long availableBytes;
        [JsonProperty("details")]
        Dictionary<String, String> details;
#pragma warning restore 0414

        public StoragePoolInfo(String uuid, String host, String hostPath,
                String localPath, string poolType, long capacityBytes,
                long availableBytes)
        {
            this.uuid = uuid;
            this.host = host;
            this.localPath = localPath;
            this.hostPath = hostPath;
            this.poolType = poolType;
            this.capacityBytes = capacityBytes;
            this.availableBytes = availableBytes;
            details = null;
        }

        public StoragePoolInfo(String uuid, String host, String hostPath,
                String localPath, string poolType, long capacityBytes,
                long availableBytes, Dictionary<String, String> details)
            : this(uuid, host, hostPath, localPath, poolType, capacityBytes, availableBytes)
        {
            this.details = details;
        }
    }

    public class VmStatsEntry
    {
        [JsonProperty("cpuUtilization")]
        public double cpuUtilization;
        [JsonProperty("networkReadKBs")]
        public double networkReadKBs;
        [JsonProperty("networkWriteKBs")]
        public double networkWriteKBs;
        [JsonProperty("numCPUs")]
        public int numCPUs;
        [JsonProperty("entityType")]
        public String entityType;
    }

    public class NicDetails
    {
        [JsonProperty("macAddress")]
        public string macaddress;
        [JsonProperty("vlanid")]
        public int vlanid;
        [JsonProperty("state")]
        public bool state;
        public NicDetails() { }
        public NicDetails(String macaddress, int vlanid, int enabledState)
        {
            this.macaddress = macaddress;
            this.vlanid = vlanid;
            if (enabledState == 2)
            {
                this.state = true;
            }
            else
            {
                this.state = false;
            }

        }
    }

    /// <summary>
    /// Fully qualified named for a number of types used in CloudStack.  Used to specify the intended type for JSON serialised objects. 
    /// </summary>
    public class CloudStackTypes
    {
        public const string Answer = "com.cloud.agent.api.Answer";
        public const string AttachIsoCommand = "com.cloud.agent.api.AttachIsoCommand";
        public const string AttachVolumeAnswer = "com.cloud.agent.api.AttachVolumeAnswer";
        public const string AttachVolumeCommand = "com.cloud.agent.api.AttachVolumeCommand";
        public const string AnsBackupSnapshotAnswerwer = "com.cloud.agent.api.BackupSnapshotAnswer";
        public const string BackupSnapshotCommand = "com.cloud.agent.api.BackupSnapshotCommand";
        public const string BumpUpPriorityCommand = "com.cloud.agent.api.BumpUpPriorityCommand";
        public const string CheckHealthAnswer = "com.cloud.agent.api.CheckHealthAnswer";
        public const string CheckHealthCommand = "com.cloud.agent.api.CheckHealthCommand";
        public const string CheckNetworkAnswer = "com.cloud.agent.api.CheckNetworkAnswer";
        public const string CheckNetworkCommand = "com.cloud.agent.api.CheckNetworkCommand";
        public const string CheckOnHostAnswer = "com.cloud.agent.api.CheckOnHostAnswer";
        public const string CheckOnHostCommand = "com.cloud.agent.api.CheckOnHostCommand";
        public const string CheckRouterAnswer = "com.cloud.agent.api.CheckRouterAnswer";
        public const string CheckRouterCommand = "com.cloud.agent.api.CheckRouterCommand";
        public const string CheckS2SVpnConnectionsAnswer = "com.cloud.agent.api.CheckS2SVpnConnectionsAnswer";
        public const string CheckS2SVpnConnectionsCommand = "com.cloud.agent.api.CheckS2SVpnConnectionsCommand";
        public const string CheckVirtualMachineAnswer = "com.cloud.agent.api.CheckVirtualMachineAnswer";
        public const string CheckVirtualMachineCommand = "com.cloud.agent.api.CheckVirtualMachineCommand";
        public const string CleanupNetworkRulesCmd = "com.cloud.agent.api.CleanupNetworkRulesCmd";
        public const string ClusterSyncAnswer = "com.cloud.agent.api.ClusterSyncAnswer";
        public const string ClusterSyncCommand = "com.cloud.agent.api.ClusterSyncCommand";
        public const string Command = "com.cloud.agent.api.Command";
        public const string CreatePrivateTemplateFromSnapshotCommand = "com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand";
        public const string CreatePrivateTemplateFromVolumeCommand = "com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand";
        public const string CreateStoragePoolCommand = "com.cloud.agent.api.CreateStoragePoolCommand";
        public const string CreateVMSnapshotAnswer = "com.cloud.agent.api.CreateVMSnapshotAnswer";
        public const string CreateVMSnapshotCommand = "com.cloud.agent.api.CreateVMSnapshotCommand";
        public const string CreateVolumeFromSnapshotAnswer = "com.cloud.agent.api.CreateVolumeFromSnapshotAnswer";
        public const string CreateVolumeFromSnapshotCommand = "com.cloud.agent.api.CreateVolumeFromSnapshotCommand";
        public const string DeleteStoragePoolCommand = "com.cloud.agent.api.DeleteStoragePoolCommand";
        public const string DeleteVMSnapshotAnswer = "com.cloud.agent.api.DeleteVMSnapshotAnswer";
        public const string DeleteVMSnapshotCommand = "com.cloud.agent.api.DeleteVMSnapshotCommand";
        public const string GetDomRVersionAnswer = "com.cloud.agent.api.GetDomRVersionAnswer";
        public const string GetDomRVersionCmd = "com.cloud.agent.api.GetDomRVersionCmd";
        public const string GetHostStatsAnswer = "com.cloud.agent.api.GetHostStatsAnswer";
        public const string GetHostStatsCommand = "com.cloud.agent.api.GetHostStatsCommand";
        public const string GetStorageStatsAnswer = "com.cloud.agent.api.GetStorageStatsAnswer";
        public const string GetStorageStatsCommand = "com.cloud.agent.api.GetStorageStatsCommand";
        public const string GetVmDiskStatsAnswer = "com.cloud.agent.api.GetVmDiskStatsAnswer";
        public const string GetVmDiskStatsCommand = "com.cloud.agent.api.GetVmDiskStatsCommand";
        public const string GetVmStatsAnswer = "com.cloud.agent.api.GetVmStatsAnswer";
        public const string GetVmStatsCommand = "com.cloud.agent.api.GetVmStatsCommand";
        public const string GetVmConfigCommand = "com.cloud.agent.api.GetVmConfigCommand";
        public const string GetVmConfigAnswer = "com.cloud.agent.api.GetVmConfigAnswer";
        public const string ModifyVmNicConfigCommand = "com.cloud.agent.api.ModifyVmNicConfigCommand";
        public const string ModifyVmNicConfigAnswer = "com.cloud.agent.api.ModifyVmNicConfigAnswer";
        public const string GetVncPortAnswer = "com.cloud.agent.api.GetVncPortAnswer";
        public const string GetVncPortCommand = "com.cloud.agent.api.GetVncPortCommand";
        public const string HostStatsEntry = "com.cloud.agent.api.HostStatsEntry";
        public const string MaintainAnswer = "com.cloud.agent.api.MaintainAnswer";
        public const string MaintainCommand = "com.cloud.agent.api.MaintainCommand";
        public const string ManageSnapshotAnswer = "com.cloud.agent.api.ManageSnapshotAnswer";
        public const string ManageSnapshotCommand = "com.cloud.agent.api.ManageSnapshotCommand";
        public const string MigrateAnswer = "com.cloud.agent.api.MigrateAnswer";
        public const string MigrateCommand = "com.cloud.agent.api.MigrateCommand";
        public const string MigrateWithStorageAnswer = "com.cloud.agent.api.MigrateWithStorageAnswer";
        public const string MigrateWithStorageCommand = "com.cloud.agent.api.MigrateWithStorageCommand";
        public const string ModifySshKeysCommand = "com.cloud.agent.api.ModifySshKeysCommand";
        public const string ModifyStoragePoolAnswer = "com.cloud.agent.api.ModifyStoragePoolAnswer";
        public const string ModifyStoragePoolCommand = "com.cloud.agent.api.ModifyStoragePoolCommand";
        public const string NetworkRulesSystemVmCommand = "com.cloud.agent.api.NetworkRulesSystemVmCommand";
        public const string NetworkRulesVmSecondaryIpCommand = "com.cloud.agent.api.NetworkRulesVmSecondaryIpCommand";
        public const string PingCommand = "com.cloud.agent.api.PingCommand";
        public const string PingRoutingCommand = "com.cloud.agent.api.PingRoutingCommand";
        public const string PingRoutingWithNwGroupsCommand = "com.cloud.agent.api.PingRoutingWithNwGroupsCommand";
        public const string PingRoutingWithOvsCommand = "com.cloud.agent.api.PingRoutingWithOvsCommand";
        public const string PingTestCommand = "com.cloud.agent.api.PingTestCommand";
        public const string PlugNicAnswer = "com.cloud.agent.api.PlugNicAnswer";
        public const string PlugNicCommand = "com.cloud.agent.api.PlugNicCommand";
        public const string PoolEjectCommand = "com.cloud.agent.api.PoolEjectCommand";
        public const string PrepareForMigrationAnswer = "com.cloud.agent.api.PrepareForMigrationAnswer";
        public const string PrepareForMigrationCommand = "com.cloud.agent.api.PrepareForMigrationCommand";
        public const string PvlanSetupCommand = "com.cloud.agent.api.PvlanSetupCommand";
        public const string ReadyAnswer = "com.cloud.agent.api.ReadyAnswer";
        public const string ReadyCommand = "com.cloud.agent.api.ReadyCommand";
        public const string RebootAnswer = "com.cloud.agent.api.RebootAnswer";
        public const string RebootCommand = "com.cloud.agent.api.RebootCommand";
        public const string RebootRouterCommand = "com.cloud.agent.api.RebootRouterCommand";
        public const string RevertToVMSnapshotAnswer = "com.cloud.agent.api.RevertToVMSnapshotAnswer";
        public const string RevertToVMSnapshotCommand = "com.cloud.agent.api.RevertToVMSnapshotCommand";
        public const string ScaleVmAnswer = "com.cloud.agent.api.ScaleVmAnswer";
        public const string ScaleVmCommand = "com.cloud.agent.api.ScaleVmCommand";
        public const string SecurityGroupRuleAnswer = "com.cloud.agent.api.SecurityGroupRuleAnswer";
        public const string SecurityGroupRulesCmd = "com.cloud.agent.api.SecurityGroupRulesCmd";
        public const string SetupAnswer = "com.cloud.agent.api.SetupAnswer";
        public const string SetupCommand = "com.cloud.agent.api.SetupCommand";
        public const string SetupGuestNetworkAnswer = "com.cloud.agent.api.SetupGuestNetworkAnswer";
        public const string SetupGuestNetworkCommand = "com.cloud.agent.api.SetupGuestNetworkCommand";
        public const string StartAnswer = "com.cloud.agent.api.StartAnswer";
        public const string StartCommand = "com.cloud.agent.api.StartCommand";
        public const string StartupCommand = "com.cloud.agent.api.StartupCommand";
        public const string StartupRoutingCommand = "com.cloud.agent.api.StartupRoutingCommand";
        public const string StartupStorageCommand = "com.cloud.agent.api.StartupStorageCommand";
        public const string StopAnswer = "com.cloud.agent.api.StopAnswer";
        public const string StopCommand = "com.cloud.agent.api.StopCommand";
        public const string StoragePoolInfo = "com.cloud.agent.api.StoragePoolInfo";
        public const string UnPlugNicAnswer = "com.cloud.agent.api.UnPlugNicAnswer";
        public const string UnPlugNicCommand = "com.cloud.agent.api.UnPlugNicCommand";
        public const string UpdateHostPasswordCommand = "com.cloud.agent.api.UpdateHostPasswordCommand";
        public const string UpgradeSnapshotCommand = "com.cloud.agent.api.UpgradeSnapshotCommand";
        public const string VmDiskStatsEntry = "com.cloud.agent.api.VmDiskStatsEntry";
        public const string VmStatsEntry = "com.cloud.agent.api.VmStatsEntry";
        public const string CheckSshAnswer = "com.cloud.agent.api.check.CheckSshAnswer";
        public const string CheckSshCommand = "com.cloud.agent.api.check.CheckSshCommand";
        public const string CheckConsoleProxyLoadCommand = "com.cloud.agent.api.proxy.CheckConsoleProxyLoadCommand";
        public const string ConsoleProxyLoadAnswer = "com.cloud.agent.api.proxy.ConsoleProxyLoadAnswer";
        public const string WatchConsoleProxyLoadCommand = "com.cloud.agent.api.proxy.WatchConsoleProxyLoadCommand";
        public const string CreateIpAliasCommand = "com.cloud.agent.api.routing.CreateIpAliasCommand";
        public const string DeleteIpAliasCommand = "com.cloud.agent.api.routing.DeleteIpAliasCommand";
        public const string DhcpEntryCommand = "com.cloud.agent.api.routing.DhcpEntryCommand";
        public const string DnsMasqConfigCommand = "com.cloud.agent.api.routing.DnsMasqConfigCommand";
        public const string IpAliasTO = "com.cloud.agent.api.routing.IpAliasTO";
        public const string IpAssocAnswer = "com.cloud.agent.api.routing.IpAssocAnswer";
        public const string IpAssocCommand = "com.cloud.agent.api.routing.IpAssocCommand";
        public const string IpAssocVpcCommand = "com.cloud.agent.api.routing.IpAssocVpcCommand";
        public const string LoadBalancerConfigCommand = "com.cloud.agent.api.routing.LoadBalancerConfigCommand";
        public const string NetworkElementCommand = "com.cloud.agent.api.routing.NetworkElementCommand";
        public const string RemoteAccessVpnCfgCommand = "com.cloud.agent.api.routing.RemoteAccessVpnCfgCommand";
        public const string SavePasswordCommand = "com.cloud.agent.api.routing.SavePasswordCommand";
        public const string SetFirewallRulesAnswer = "com.cloud.agent.api.routing.SetFirewallRulesAnswer";
        public const string SetFirewallRulesCommand = "com.cloud.agent.api.routing.SetFirewallRulesCommand";
        public const string SetNetworkACLAnswer = "com.cloud.agent.api.routing.SetNetworkACLAnswer";
        public const string SetNetworkACLCommand = "com.cloud.agent.api.routing.SetNetworkACLCommand";
        public const string SetPortForwardingRulesAnswer = "com.cloud.agent.api.routing.SetPortForwardingRulesAnswer";
        public const string SetPortForwardingRulesCommand = "com.cloud.agent.api.routing.SetPortForwardingRulesCommand";
        public const string SetPortForwardingRulesVpcCommand = "com.cloud.agent.api.routing.SetPortForwardingRulesVpcCommand";
        public const string SetSourceNatAnswer = "com.cloud.agent.api.routing.SetSourceNatAnswer";
        public const string SetSourceNatCommand = "com.cloud.agent.api.routing.SetSourceNatCommand";
        public const string SetStaticNatRulesAnswer = "com.cloud.agent.api.routing.SetStaticNatRulesAnswer";
        public const string SetStaticNatRulesCommand = "com.cloud.agent.api.routing.SetStaticNatRulesCommand";
        public const string SetStaticRouteAnswer = "com.cloud.agent.api.routing.SetStaticRouteAnswer";
        public const string SetStaticRouteCommand = "com.cloud.agent.api.routing.SetStaticRouteCommand";
        public const string Site2SiteVpnCfgCommand = "com.cloud.agent.api.routing.Site2SiteVpnCfgCommand";
        public const string VmDataCommand = "com.cloud.agent.api.routing.VmDataCommand";
        public const string VpnUsersCfgCommand = "com.cloud.agent.api.routing.VpnUsersCfgCommand";
        public const string CopyVolumeAnswer = "com.cloud.agent.api.storage.CopyVolumeAnswer";
        public const string CopyVolumeCommand = "com.cloud.agent.api.storage.CopyVolumeCommand";
        public const string CreateAnswer = "com.cloud.agent.api.storage.CreateAnswer";
        public const string CreateCommand = "com.cloud.agent.api.storage.CreateCommand";
        public const string CreatePrivateTemplateAnswer = "com.cloud.agent.api.storage.CreatePrivateTemplateAnswer";
        public const string DestroyCommand = "com.cloud.agent.api.storage.DestroyCommand";
        public const string MigrateVolumeAnswer = "com.cloud.agent.api.storage.MigrateVolumeAnswer";
        public const string MigrateVolumeCommand = "com.cloud.agent.api.storage.MigrateVolumeCommand";
        public const string PrimaryStorageDownloadAnswer = "com.cloud.agent.api.storage.PrimaryStorageDownloadAnswer";
        public const string PrimaryStorageDownloadCommand = "com.cloud.agent.api.storage.PrimaryStorageDownloadCommand";
        public const string ResizeVolumeAnswer = "com.cloud.agent.api.storage.ResizeVolumeAnswer";
        public const string ResizeVolumeCommand = "com.cloud.agent.api.storage.ResizeVolumeCommand";
        public const string FirewallRuleTO = "com.cloud.agent.api.to.FirewallRuleTO";
        public const string IpAddressTO = "com.cloud.agent.api.to.IpAddressTO";
        public const string NicTO = "com.cloud.agent.api.to.NicTO";
        public const string PortForwardingRuleTO = "com.cloud.agent.api.to.PortForwardingRuleTO";
        public const string S3TO = "com.cloud.agent.api.to.S3TO";
        public const string NFSTO = "com.cloud.agent.api.to.NfsTO";
        public const string StaticNatRuleTO = "com.cloud.agent.api.to.StaticNatRuleTO";
        public const string StorageFilerTO = "com.cloud.agent.api.to.StorageFilerTO";
        public const string SwiftTO = "com.cloud.agent.api.to.SwiftTO";
        public const string VirtualMachineTO = "com.cloud.agent.api.to.VirtualMachineTO";
        public const string VolumeTO = "com.cloud.agent.api.to.VolumeTO";
        public const string DiskTO = "com.cloud.agent.api.to.DiskTO";
        public const string InternalErrorException = "com.cloud.exception.InternalErrorException";
        public const string HostType = "com.cloud.host.Host.Type";
        public const string HypervisorType = "com.cloud.hypervisor.Hypervisor.HypervisorType";
        public const string DnsMasqConfigurator = "com.cloud.network.DnsMasqConfigurator";
        public const string HAProxyConfigurator = "com.cloud.network.HAProxyConfigurator";
        public const string LoadBalancerConfigurator = "com.cloud.network.LoadBalancerConfigurator";
        public const string Networks = "com.cloud.network.Networks";
        public const string BroadcastDomainType = "com.cloud.network.Networks.BroadcastDomainType";
        public const string IsolationType = "com.cloud.network.Networks.IsolationType";
        public const string TrafficType = "com.cloud.network.Networks.TrafficType";
        public const string PhysicalNetworkSetupInfo = "com.cloud.network.PhysicalNetworkSetupInfo";
        public const string OvsCreateGreTunnelAnswer = "com.cloud.network.ovs.OvsCreateGreTunnelAnswer";
        public const string OvsCreateGreTunnelCommand = "com.cloud.network.ovs.OvsCreateGreTunnelCommand";
        public const string OvsCreateTunnelAnswer = "com.cloud.network.ovs.OvsCreateTunnelAnswer";
        public const string OvsCreateTunnelCommand = "com.cloud.network.ovs.OvsCreateTunnelCommand";
        public const string OvsDeleteFlowCommand = "com.cloud.network.ovs.OvsDeleteFlowCommand";
        public const string OvsDestroyBridgeCommand = "com.cloud.network.ovs.OvsDestroyBridgeCommand";
        public const string OvsDestroyTunnelCommand = "com.cloud.network.ovs.OvsDestroyTunnelCommand";
        public const string OvsFetchInterfaceAnswer = "com.cloud.network.ovs.OvsFetchInterfaceAnswer";
        public const string OvsFetchInterfaceCommand = "com.cloud.network.ovs.OvsFetchInterfaceCommand";
        public const string OvsSetTagAndFlowAnswer = "com.cloud.network.ovs.OvsSetTagAndFlowAnswer";
        public const string OvsSetTagAndFlowCommand = "com.cloud.network.ovs.OvsSetTagAndFlowCommand";
        public const string OvsSetupBridgeCommand = "com.cloud.network.ovs.OvsSetupBridgeCommand";
        public const string FirewallRule = "com.cloud.network.rules.FirewallRule";
        public const string ServerResource = "com.cloud.resource.ServerResource";
        public const string HypervisorResource = "com.cloud.resource.hypervisor.HypervisorResource";
        public const string Storage = "com.cloud.storage.Storage";
        public const string ImageFormat = "com.cloud.storage.Storage.ImageFormat";
        public const string StoragePoolType = "com.cloud.storage.Storage.StoragePoolType";
        public const string Volume = "com.cloud.storage.Volume";
        public const string VolumeVO = "com.cloud.storage.VolumeVO";
        public const string StorageSubsystemCommandHandler = "com.cloud.storage.resource.StorageSubsystemCommandHandler";
        public const string StorageSubsystemCommandHandlerBase = "com.cloud.storage.resource.StorageSubsystemCommandHandlerBase";
        public const string TemplateProp = "com.cloud.storage.template.TemplateProp";
        public const string BootloaderType = "com.cloud.template.VirtualMachineTemplate.BootloaderType";
        public const string VolumeObjectTO = "org.apache.cloudstack.storage.to.VolumeObjectTO";
        public const string TemplateObjectTO = "org.apache.cloudstack.storage.to.TemplateObjectTO";
        public const string PrimaryDataStoreTO = "org.apache.cloudstack.storage.to.PrimaryDataStoreTO";
        public const string AttachAnswer = "org.apache.cloudstack.storage.command.AttachAnswer";
        public const string AttachCommand = "org.apache.cloudstack.storage.command.AttachCommand";
        public const string AttachPrimaryDataStoreAnswer = "org.apache.cloudstack.storage.command.AttachPrimaryDataStoreAnswer";
        public const string AttachPrimaryDataStoreCmd = "org.apache.cloudstack.storage.command.AttachPrimaryDataStoreCmd";
        public const string CopyCmdAnswer = "org.apache.cloudstack.storage.command.CopyCmdAnswer";
        public const string CopyCommand = "org.apache.cloudstack.storage.command.CopyCommand";
        public const string CreateObjectAnswer = "org.apache.cloudstack.storage.command.CreateObjectAnswer";
        public const string CreateObjectCommand = "org.apache.cloudstack.storage.command.CreateObjectCommand";
        public const string DeleteCommand = "org.apache.cloudstack.storage.command.DeleteCommand";
        public const string DettachAnswer = "org.apache.cloudstack.storage.command.DettachAnswer";
        public const string DettachCommand = "org.apache.cloudstack.storage.command.DettachCommand";
        public const string HostVmStateReportCommand = "org.apache.cloudstack.HostVmStateReportCommand";
    }
}
