content: // 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 com.cloud.hypervisor.xenserver.resource;
  
  import static com.cloud.utils.NumbersUtil.toHumanReadableSize;
  
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.net.URLConnection;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Properties;
  import java.util.Queue;
  import java.util.Random;
  import java.util.Set;
  import java.util.UUID;
  import java.util.Vector;
  import java.util.concurrent.TimeoutException;
  
  import javax.naming.ConfigurationException;
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.apache.cloudstack.api.ApiConstants;
  import org.apache.cloudstack.diagnostics.CopyToSecondaryStorageAnswer;
  import org.apache.cloudstack.diagnostics.CopyToSecondaryStorageCommand;
  import org.apache.cloudstack.diagnostics.DiagnosticsService;
  import org.apache.cloudstack.hypervisor.xenserver.ExtraConfigurationUtility;
  import org.apache.cloudstack.storage.command.browser.ListDataStoreObjectsAnswer;
  import org.apache.cloudstack.storage.command.browser.ListDataStoreObjectsCommand;
  import org.apache.cloudstack.storage.configdrive.ConfigDrive;
  import org.apache.cloudstack.storage.to.TemplateObjectTO;
  import org.apache.cloudstack.storage.to.VolumeObjectTO;
  import org.apache.cloudstack.utils.security.ParserUtils;
  
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.collections.MapUtils;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang3.BooleanUtils;
  import org.apache.maven.artifact.versioning.ComparableVersion;
  import org.apache.xmlrpc.XmlRpcException;
  
  import org.joda.time.Duration;
  import org.w3c.dom.Document;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  
  import com.cloud.agent.IAgentControl;
  import com.cloud.agent.api.Answer;
  import com.cloud.agent.api.Command;
  import com.cloud.agent.api.GetHostStatsCommand;
  import com.cloud.agent.api.GetVmStatsCommand;
  import com.cloud.agent.api.HostStatsEntry;
  import com.cloud.agent.api.HostVmStateReportEntry;
  import com.cloud.agent.api.PingCommand;
  import com.cloud.agent.api.PingRoutingCommand;
  import com.cloud.agent.api.PingRoutingWithNwGroupsCommand;
  import com.cloud.agent.api.PingRoutingWithOvsCommand;
  import com.cloud.agent.api.RebootAnswer;
  import com.cloud.agent.api.RebootCommand;
  import com.cloud.agent.api.SetupGuestNetworkCommand;
  import com.cloud.agent.api.StartAnswer;
  import com.cloud.agent.api.StartCommand;
  import com.cloud.agent.api.StartupCommand;
  import com.cloud.agent.api.StartupRoutingCommand;
  import com.cloud.agent.api.StartupStorageCommand;
  import com.cloud.agent.api.StopAnswer;
  import com.cloud.agent.api.StopCommand;
  import com.cloud.agent.api.StoragePoolInfo;
  import com.cloud.agent.api.VgpuTypesInfo;
  import com.cloud.agent.api.VmStatsEntry;
  import com.cloud.agent.api.routing.IpAssocCommand;
  import com.cloud.agent.api.routing.IpAssocVpcCommand;
  import com.cloud.agent.api.routing.NetworkElementCommand;
  import com.cloud.agent.api.routing.SetNetworkACLCommand;
  import com.cloud.agent.api.routing.SetSourceNatCommand;
  import com.cloud.agent.api.to.DataStoreTO;
  import com.cloud.agent.api.to.DataTO;
  import com.cloud.agent.api.to.DiskTO;
  import com.cloud.agent.api.to.GPUDeviceTO;
  import com.cloud.agent.api.to.IpAddressTO;
  import com.cloud.agent.api.to.NfsTO;
  import com.cloud.agent.api.to.NicTO;
  import com.cloud.agent.api.to.VirtualMachineTO;
  import com.cloud.agent.resource.virtualnetwork.VRScripts;
  import com.cloud.agent.resource.virtualnetwork.VirtualRouterDeployer;
  import com.cloud.agent.resource.virtualnetwork.VirtualRoutingResource;
  import com.cloud.exception.InternalErrorException;
  import com.cloud.host.Host.Type;
  import com.cloud.hypervisor.Hypervisor.HypervisorType;
  import com.cloud.hypervisor.xenserver.resource.wrapper.xenbase.CitrixRequestWrapper;
  import com.cloud.hypervisor.xenserver.resource.wrapper.xenbase.XenServerUtilitiesHelper;
  import com.cloud.network.Networks;
  import com.cloud.network.Networks.BroadcastDomainType;
  import com.cloud.network.Networks.TrafficType;
  import com.cloud.resource.ServerResource;
  import com.cloud.resource.ServerResourceBase;
  import com.cloud.resource.hypervisor.HypervisorResource;
  import com.cloud.storage.Storage;
  import com.cloud.storage.Storage.StoragePoolType;
  import com.cloud.storage.Volume;
  import com.cloud.storage.VolumeVO;
  import com.cloud.storage.resource.StorageSubsystemCommandHandler;
  import com.cloud.storage.resource.StorageSubsystemCommandHandlerBase;
  import com.cloud.template.TemplateManager;
  import com.cloud.template.VirtualMachineTemplate.BootloaderType;
  import com.cloud.utils.ExecutionResult;
  import com.cloud.utils.NumbersUtil;
  import com.cloud.utils.Pair;
  import com.cloud.utils.PropertiesUtil;
  import com.cloud.utils.StringUtils;
  import com.cloud.utils.Ternary;
  import com.cloud.utils.UuidUtils;
  import com.cloud.utils.exception.CloudRuntimeException;
  import com.cloud.utils.net.NetUtils;
  import com.cloud.utils.script.Script;
  import com.cloud.utils.ssh.SSHCmdHelper;
  import com.cloud.utils.ssh.SshHelper;
  import com.cloud.vm.VirtualMachine;
  import com.cloud.vm.VirtualMachine.PowerState;
  import com.cloud.vm.VmDetailConstants;
  import com.trilead.ssh2.SCPClient;
  import com.trilead.ssh2.SFTPException;
  import com.trilead.ssh2.SFTPv3Client;
  import com.trilead.ssh2.SFTPv3DirectoryEntry;
  import com.trilead.ssh2.SFTPv3FileAttributes;
  import com.xensource.xenapi.Bond;
  import com.xensource.xenapi.Connection;
  import com.xensource.xenapi.Console;
  import com.xensource.xenapi.Host;
  import com.xensource.xenapi.HostCpu;
  import com.xensource.xenapi.HostMetrics;
  import com.xensource.xenapi.Network;
  import com.xensource.xenapi.PBD;
  import com.xensource.xenapi.PIF;
  import com.xensource.xenapi.Pool;
  import com.xensource.xenapi.SR;
  import com.xensource.xenapi.Session;
  import com.xensource.xenapi.Task;
  import com.xensource.xenapi.Types;
  import com.xensource.xenapi.Types.BadServerResponse;
  import com.xensource.xenapi.Types.VmPowerState;
  import com.xensource.xenapi.Types.XenAPIException;
  import com.xensource.xenapi.VBD;
  import com.xensource.xenapi.VDI;
  import com.xensource.xenapi.VIF;
  import com.xensource.xenapi.VLAN;
  import com.xensource.xenapi.VM;
  import com.xensource.xenapi.XenAPIObject;
  
  /**
   * CitrixResourceBase encapsulates the calls to the XenServer Xapi process to
   * perform the required functionalities for CloudStack.
   *
   * ==============> READ THIS <============== Because the XenServer objects can
   * expire when the session expires, we cannot keep any of the actual XenServer
   * objects in this class. The only thing that is constant is the UUID of the
   * XenServer objects but not the objects themselves! This is very important
   * before you do any changes in this code here.
   *
   */
  public abstract class CitrixResourceBase extends ServerResourceBase implements ServerResource, HypervisorResource, VirtualRouterDeployer {
      /**
       * used to describe what type of resource a storage device is of
       */
      public enum SRType {
          EXT, ISO, LVM, LVMOHBA, LVMOISCSI,
          /**
           * used for resigning metadata (like SR UUID and VDI UUID when a
           * particular storage manager is installed on a XenServer host (for back-end snapshots to work))
           */
          RELVMOISCSI, NFS;
  
          final String _str;
  
          SRType() {
              _str = super.toString().toLowerCase();
          }
  
          public boolean equals(final String type) {
              return _str.equalsIgnoreCase(type);
          }
  
          @Override
          public String toString() {
              return _str;
          }
      }
  
      private final static int BASE_TO_CONVERT_BYTES_INTO_KILOBYTES = 1024;
      private final static String BASE_MOUNT_POINT_ON_REMOTE = "/var/cloud_mount/";
  
      private final static int USER_DEVICE_START_ID = 3;
  
      private final static String VM_NAME_ISO_SUFFIX = "-ISO";
  
      private final static String VM_NAME_CONFIGDRIVE_ISO_SUFFIX = "-CONFIGDRIVE-ISO";
  
      private final static String VM_FILE_ISO_SUFFIX = ".iso";
      public final static int DEFAULTDOMRSSHPORT = 3922;
  
      private static final XenServerConnectionPool ConnPool = XenServerConnectionPool.getInstance();
      // static min values for guests on xenserver
      private static final long mem_128m = 134217728L;
  
      static final Random Rand = new Random(System.currentTimeMillis());
      protected static final HashMap<VmPowerState, PowerState> s_powerStatesTable;
  
      public static final String XS_TOOLS_ISO_AFTER_70 = "guest-tools.iso";
  
      protected static final String PLATFORM_CORES_PER_SOCKET_KEY = "cores-per-socket";
  
      static {
          s_powerStatesTable = new HashMap<>();
          s_powerStatesTable.put(VmPowerState.HALTED, PowerState.PowerOff);
          s_powerStatesTable.put(VmPowerState.PAUSED, PowerState.PowerOff);
          s_powerStatesTable.put(VmPowerState.RUNNING, PowerState.PowerOn);
          s_powerStatesTable.put(VmPowerState.SUSPENDED, PowerState.PowerOff);
          s_powerStatesTable.put(VmPowerState.UNRECOGNIZED, PowerState.PowerUnknown);
      }
  
      private static PowerState convertToPowerState(final VmPowerState ps) {
          final PowerState powerState = s_powerStatesTable.get(ps);
          return powerState == null ? PowerState.PowerUnknown : powerState;
      }
  
      private static boolean isAlienVm(final VM vm, final Connection conn) throws XenAPIException, XmlRpcException {
          // TODO : we need a better way to tell whether or not the VM belongs to
          // CloudStack
          final String vmName = vm.getNameLabel(conn);
          return !vmName.matches("^[ivs]-\\d+-.+");
      }
  
      protected IAgentControl _agentControl;
      protected boolean _canBridgeFirewall = false;
      protected String _cluster;
      // Guest and Host Performance Statistics
      protected String _consolidationFunction = "AVERAGE";
      protected long _dcId;
      protected String _guestNetworkName;
      protected int _heartbeatInterval = 60;
      protected int _heartbeatTimeout = 120;
      protected XsHost _host = new XsHost();
      protected String _instance; // instance name (default is usually "VM")
      protected boolean _isOvs = false;
      protected String _linkLocalPrivateNetworkName;
      protected int _maxNics = 7;
  
      final int _maxWeight = 256;
      protected int _migratewait;
      protected String _name;
      protected Queue<String> _password = new LinkedList<>();
  
      protected String _pod;
      protected int _pollingIntervalInSeconds = 60;
  
      protected String _privateNetworkName;
      protected String _publicNetworkName;
  
      protected final int _retry = 100;
  
      protected boolean _securityGroupEnabled;
      protected final int _sleep = 10000;
      protected String _storageNetworkName1;
      protected String _storageNetworkName2;
  
      protected String _username;
  
      protected VirtualRoutingResource _vrResource;
  
      protected String _configDriveIsopath = "/opt/xensource/packages/configdrive_iso/";
      protected String _configDriveSRName = "ConfigDriveISOs";
      public String _attachIsoDeviceNum = "3";
  
      protected XenServerUtilitiesHelper xenServerUtilitiesHelper = new XenServerUtilitiesHelper();
  
      protected int _wait;
      // Hypervisor specific params with generic value, may need to be overridden
      // for specific versions
      long _xsMemoryUsed = 128 * 1024 * 1024L; // xenserver hypervisor used 128 M
  
      double _xsVirtualizationFactor = 63.0 / 64.0; // 1 - virtualization overhead
  
      protected StorageSubsystemCommandHandler storageHandler;
  
      private static final String XENSTORE_DATA_IP = "vm-data/ip";
      private static final String XENSTORE_DATA_GATEWAY = "vm-data/gateway";
      private static final String XENSTORE_DATA_NETMASK = "vm-data/netmask";
      private static final String XENSTORE_DATA_CS_INIT = "vm-data/cloudstack/init";
  
      public CitrixResourceBase() {
      }
  
      /**
       * Replaces the old password with the new password used to connect to the host.
       *
       * @param password  - the new host password.
       * @return the old password.
       */
      public String replaceOldPasswdInQueue(final String password) {
          final String oldPasswd = _password.poll();
          _password.add(password);
  
          return oldPasswd;
      }
  
      public String getPwdFromQueue() {
          return _password.peek();
      }
  
      public XenServerUtilitiesHelper getXenServerUtilitiesHelper() {
          return xenServerUtilitiesHelper;
      }
  
      protected StorageSubsystemCommandHandler buildStorageHandler() {
          final XenServerStorageProcessor processor = new XenServerStorageProcessor(this);
          return new StorageSubsystemCommandHandlerBase(processor);
      }
  
      @Override
      protected String getDefaultScriptsDir() {
          return null;
      }
  
      public String callHostPlugin(final Connection conn, final String plugin, final String cmd, final String... params) {
          final Map<String, String> args = new HashMap<>();
          String msg;
          try {
              for (int i = 0; i < params.length; i += 2) {
                  args.put(params[i], params[i + 1]);
              }
  
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin executing for command " + cmd + " with " + getArgsString(args));
              }
              final Host host = Host.getByUuid(conn, _host.getUuid());
              final String result = host.callPlugin(conn, plugin, cmd, args);
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin Result: " + result);
              }
              return result.replace("\n", "");
          } catch (final XenAPIException e) {
              msg = "callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e;
              logger.warn(msg);
          } catch (final XmlRpcException e) {
              msg = "callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e.getMessage();
              logger.debug(msg);
          }
          throw new CloudRuntimeException(msg);
      }
  
      protected String callHostPluginAsync(final Connection conn, final String plugin, final String cmd, final int wait, final Map<String, String> params) {
          final int timeout = wait * 1000;
          final Map<String, String> args = new HashMap<>();
          Task task = null;
          try {
              args.putAll(params);
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin executing for command " + cmd + " with " + getArgsString(args));
              }
              final Host host = Host.getByUuid(conn, _host.getUuid());
              task = host.callPluginAsync(conn, plugin, cmd, args);
              // poll every 1 seconds
              waitForTask(conn, task, 1000, timeout);
              checkForSuccess(conn, task);
              final String result = task.getResult(conn);
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin Result: " + result);
              }
              return result.replace("<value>", "").replace("</value>", "").replace("\n", "");
          } catch (final Types.HandleInvalid e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to HandleInvalid clazz:" + e.clazz + ", handle:" + e.handle);
          } catch (final Exception e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e, e);
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e1) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e1);
                  }
              }
          }
          return null;
      }
  
      protected String callHostPluginAsync(final Connection conn, final String plugin, final String cmd, final int wait, final String... params) {
          final int timeout = wait * 1000;
          final Map<String, String> args = new HashMap<>();
          Task task = null;
          try {
              for (int i = 0; i < params.length; i += 2) {
                  args.put(params[i], params[i + 1]);
              }
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin executing for command " + cmd + " with " + getArgsString(args));
              }
              final Host host = Host.getByUuid(conn, _host.getUuid());
              task = host.callPluginAsync(conn, plugin, cmd, args);
              // poll every 1 seconds
              waitForTask(conn, task, 1000, timeout);
              checkForSuccess(conn, task);
              final String result = task.getResult(conn);
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin Result: " + result);
              }
              return result.replace("<value>", "").replace("</value>", "").replace("\n", "");
          } catch (final Types.HandleInvalid e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to HandleInvalid clazz:" + e.clazz + ", handle:" + e.handle);
          } catch (final XenAPIException e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e, e);
          } catch (final Exception e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e.getMessage(), e);
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e1) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e1);
                  }
              }
          }
          return null;
      }
  
      public String callHostPluginPremium(final Connection conn, final String cmd, final String... params) {
          return callHostPlugin(conn, "vmopspremium", cmd, params);
      }
  
      protected String callHostPluginThroughMaster(final Connection conn, final String plugin, final String cmd, final String... params) {
          final Map<String, String> args = new HashMap<>();
  
          try {
              final Map<Pool, Pool.Record> poolRecs = Pool.getAllRecords(conn);
              if (poolRecs.size() != 1) {
                  throw new CloudRuntimeException("There are " + poolRecs.size() + " pool for host :" + _host.getUuid());
              }
              final Host master = poolRecs.values().iterator().next().master;
              for (int i = 0; i < params.length; i += 2) {
                  args.put(params[i], params[i + 1]);
              }
  
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin executing for command " + cmd + " with " + getArgsString(args));
              }
              final String result = master.callPlugin(conn, plugin, cmd, args);
              if (logger.isTraceEnabled()) {
                  logger.trace("callHostPlugin Result: " + result);
              }
              return result.replace("\n", "");
          } catch (final Types.HandleInvalid e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to HandleInvalid clazz:" + e.clazz + ", handle:" + e.handle);
          } catch (final XenAPIException e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e, e);
          } catch (final XmlRpcException e) {
              logger.warn("callHostPlugin failed for cmd: " + cmd + " with args " + getArgsString(args) + " due to " + e.getMessage(), e);
          }
          return null;
      }
  
      public boolean canBridgeFirewall() {
          return _canBridgeFirewall;
      }
  
      public boolean canBridgeFirewall(final Connection conn) {
          return Boolean.parseBoolean(callHostPlugin(conn, "vmops", "can_bridge_firewall", "host_uuid", _host.getUuid(), "instance", _instance));
      }
  
      public void checkForSuccess(final Connection c, final Task task) throws XenAPIException, XmlRpcException {
          if (task.getStatus(c) == Types.TaskStatusType.SUCCESS) {
              if (logger.isTraceEnabled()) {
                  logger.trace("Task " + task.getNameLabel(c) + " (" + task.getUuid(c) + ") completed");
              }
          } else {
              final String msg = "Task failed! Task record: " + task.getRecord(c);
              logger.warn(msg);
              task.cancel(c);
              task.destroy(c);
              throw new Types.BadAsyncResult(msg);
          }
      }
  
      protected boolean checkSR(final Connection conn, final SR sr) {
          try {
              final SR.Record srr = sr.getRecord(conn);
              final Set<PBD> pbds = sr.getPBDs(conn);
              if (pbds.isEmpty()) {
                  final String msg = "There is no PBDs for this SR: " + srr.nameLabel + " on host:" + _host.getUuid();
                  logger.warn(msg);
                  return false;
              }
              if (logger.isDebugEnabled()) {
                  logger.debug("Checking " + srr.nameLabel + " or SR " + srr.uuid + " on " + _host);
              }
              if (srr.shared) {
                  if (SRType.NFS.equals(srr.type)) {
                      final Map<String, String> smConfig = srr.smConfig;
                      if (!smConfig.containsKey("nosubdir")) {
                          smConfig.put("nosubdir", "true");
                          sr.setSmConfig(conn, smConfig);
                      }
                  }
  
                  final Host host = Host.getByUuid(conn, _host.getUuid());
                  boolean found = false;
                  for (final PBD pbd : pbds) {
                      final PBD.Record pbdr = pbd.getRecord(conn);
                      if (host.equals(pbdr.host)) {
                          if (!pbdr.currentlyAttached) {
                              pbdPlug(conn, pbd, pbdr.uuid);
                          }
                          found = true;
                          break;
                      }
                  }
                  if (!found) {
                      final PBD.Record pbdr = srr.PBDs.iterator().next().getRecord(conn);
                      pbdr.host = host;
                      pbdr.uuid = "";
                      final PBD pbd = PBD.create(conn, pbdr);
                      pbdPlug(conn, pbd, pbd.getUuid(conn));
                  }
              } else {
                  for (final PBD pbd : pbds) {
                      final PBD.Record pbdr = pbd.getRecord(conn);
                      if (!pbdr.currentlyAttached) {
                          pbdPlug(conn, pbd, pbdr.uuid);
                      }
                  }
              }
  
          } catch (final Exception e) {
              final String msg = "checkSR failed host:" + _host + " due to " + e;
              logger.warn(msg, e);
              return false;
          }
          return true;
      }
  
      private void CheckXenHostInfo() throws ConfigurationException {
          final Connection conn = ConnPool.getConnect(_host.getIp(), _username, _password);
          if (conn == null) {
              throw new ConfigurationException("Can not create connection to " + _host.getIp());
          }
          try {
              Host.Record hostRec;
              try {
                  final Host host = Host.getByUuid(conn, _host.getUuid());
                  hostRec = host.getRecord(conn);
                  final Pool.Record poolRec = Pool.getAllRecords(conn).values().iterator().next();
                  _host.setPool(poolRec.uuid);
  
              } catch (final Exception e) {
                  throw new ConfigurationException("Can not get host information from " + _host.getIp());
              }
              if (!hostRec.address.equals(_host.getIp())) {
                  final String msg = "Host " + _host.getIp() + " seems be reinstalled, please remove this host and readd";
                  logger.error(msg);
                  throw new ConfigurationException(msg);
              }
          } finally {
              try {
                  Session.logout(conn);
              } catch (final Exception ignored) {
              }
          }
      }
  
      @Override
      public ExecutionResult cleanupCommand(final NetworkElementCommand cmd) {
          if (cmd instanceof IpAssocCommand && !(cmd instanceof IpAssocVpcCommand)) {
              return cleanupNetworkElementCommand((IpAssocCommand)cmd);
          }
          return new ExecutionResult(true, null);
      }
  
      public boolean cleanupHaltedVms(final Connection conn) throws XenAPIException, XmlRpcException {
          final Host host = Host.getByUuid(conn, _host.getUuid());
          final Map<VM, VM.Record> vms = VM.getAllRecords(conn);
          boolean success = true;
          if (vms != null && !vms.isEmpty()) {
              for (final Map.Entry<VM, VM.Record> entry : vms.entrySet()) {
                  final VM vm = entry.getKey();
                  final VM.Record vmRec = entry.getValue();
                  if (vmRec.isATemplate || vmRec.isControlDomain) {
                      continue;
                  }
  
                  if (VmPowerState.HALTED.equals(vmRec.powerState) && vmRec.affinity.equals(host) && !isAlienVm(vm, conn)) {
                      try {
                          destroyVm(vm, conn);
                      } catch (final Exception e) {
                          logger.warn("Catch Exception " + e.getClass().getName() + ": unable to destroy VM " + vmRec.nameLabel + " due to ", e);
                          success = false;
                      }
                  }
              }
          }
          return success;
      }
  
      protected ExecutionResult cleanupNetworkElementCommand(final IpAssocCommand cmd) {
          final Connection conn = getConnection();
          final String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
          final String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
          final String lastIp = cmd.getAccessDetail(NetworkElementCommand.NETWORK_PUB_LAST_IP);
  
          try {
              final IpAddressTO[] ips = cmd.getIpAddresses();
              for (final IpAddressTO ip : ips) {
  
                  final VM router = getVM(conn, routerName);
  
                  final NicTO nic = new NicTO();
                  nic.setMac(ip.getVifMacAddress());
                  nic.setType(ip.getTrafficType());
                  if (ip.getBroadcastUri() == null) {
                      nic.setBroadcastType(BroadcastDomainType.Native);
                  } else {
                      final URI uri = BroadcastDomainType.fromString(ip.getBroadcastUri());
                      nic.setBroadcastType(BroadcastDomainType.getSchemeValue(uri));
                      nic.setBroadcastUri(uri);
                  }
                  nic.setDeviceId(0);
                  nic.setNetworkRateMbps(ip.getNetworkRate());
                  nic.setName(ip.getNetworkName());
  
                  Network network = getNetwork(conn, nic);
  
                  // If we are disassociating the last IP address in the VLAN, we
                  // need
                  // to remove a VIF
                  boolean removeVif = false;
  
                  // there is only one ip in this public vlan and removing it, so
                  // remove the nic
                  if (StringUtils.equalsIgnoreCase(lastIp, "true") && !ip.isAdd()) {
                      final VIF correctVif = getCorrectVif(conn, router, network);
                      // in isolated network eth2 is the default public interface. We don't want to delete it.
                      if (correctVif != null && !correctVif.getDevice(conn).equals("2")) {
                          removeVif = true;
                      }
                  }
  
                  if (removeVif) {
  
                      // Determine the correct VIF on DomR to
                      // associate/disassociate the
                      // IP address with
  
                      final VIF correctVif = getCorrectVif(conn, router, network);
                      if (correctVif != null) {
                          network = correctVif.getNetwork(conn);
  
                          // Mark this vif to be removed from network usage
                          networkUsage(conn, routerIp, "deleteVif", "eth" + correctVif.getDevice(conn));
  
                          // Remove the VIF from DomR
                          correctVif.unplug(conn);
                          correctVif.destroy(conn);
  
                          // Disable the VLAN network if necessary
                          disableVlanNetwork(conn, network, true);
                      }
                  }
              }
          } catch (final Exception e) {
              logger.debug("Ip Assoc failure on applying one ip due to exception:  ", e);
              return new ExecutionResult(false, e.getMessage());
          }
          return new ExecutionResult(true, null);
      }
  
      public void cleanupTemplateSR(final Connection conn) {
          Set<PBD> pbds;
          try {
              final Host host = Host.getByUuid(conn, _host.getUuid());
              pbds = host.getPBDs(conn);
          } catch (final XenAPIException e) {
              logger.warn("Unable to get the SRs " + e, e);
              throw new CloudRuntimeException("Unable to get SRs " + e, e);
          } catch (final Exception e) {
              throw new CloudRuntimeException("Unable to get SRs " + e.getMessage(), e);
          }
          for (final PBD pbd : pbds) {
              SR sr;
              SR.Record srRec;
              try {
                  sr = pbd.getSR(conn);
                  srRec = sr.getRecord(conn);
              } catch (final Exception e) {
                  logger.warn("pbd.getSR get Exception due to ", e);
                  continue;
              }
              final String type = srRec.type;
              if (srRec.shared) {
                  continue;
              }
              if (SRType.NFS.equals(type) || SRType.ISO.equals(type) && srRec.nameDescription.contains("template")) {
                  try {
                      pbd.unplug(conn);
                      pbd.destroy(conn);
                      sr.forget(conn);
                  } catch (final Exception e) {
                      logger.warn("forget SR catch Exception due to ", e);
                  }
              }
          }
      }
  
      public void cleanUpTmpDomVif(final Connection conn, final Network nw) throws XenAPIException, XmlRpcException {
  
          final Pair<VM, VM.Record> vm = getControlDomain(conn);
          final VM dom0 = vm.first();
          final Set<VIF> dom0Vifs = dom0.getVIFs(conn);
          for (final VIF v : dom0Vifs) {
              String vifName = "unknown";
              try {
                  final VIF.Record vifr = v.getRecord(conn);
                  if (v.getNetwork(conn).getUuid(conn).equals(nw.getUuid(conn))) {
                      if (vifr != null) {
                          final Map<String, String> config = vifr.otherConfig;
                          vifName = config.get("nameLabel");
                      }
                      logger.debug("A VIF in dom0 for the network is found - so destroy the vif");
                      v.destroy(conn);
                      logger.debug("Destroy temp dom0 vif" + vifName + " success");
                  }
              } catch (final Exception e) {
                  logger.warn("Destroy temp dom0 vif " + vifName + "failed", e);
              }
          }
      }
  
      protected VDI cloudVDIcopy(final Connection conn, final VDI vdi, final SR sr, int wait) throws Exception {
          Task task = null;
          if (wait == 0) {
              wait = 2 * 60 * 60;
          }
          try {
              task = vdi.copyAsync(conn, sr);
              // poll every 1 seconds , timeout after 2 hours
              waitForTask(conn, task, 1000, (long)wait * 1000);
              checkForSuccess(conn, task);
              return Types.toVDI(task, conn);
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e);
                  }
              }
          }
      }
  
      public HashMap<String, String> clusterVMMetaDataSync(final Connection conn) {
          final HashMap<String, String> vmMetaDatum = new HashMap<>();
          try {
              final Map<VM, VM.Record> vm_map = VM.getAllRecords(conn); // USE
              if (vm_map != null) {
                  for (final VM.Record record : vm_map.values()) {
                      if (record.isControlDomain || record.isASnapshot || record.isATemplate) {
                          continue; // Skip DOM0
                      }
                      final String platform = com.cloud.utils.StringUtils.mapToString(record.platform);
                      if (platform.isEmpty()) {
                          continue; //Skip if platform is null
                      }
                      vmMetaDatum.put(record.nameLabel, com.cloud.utils.StringUtils.mapToString(record.platform));
                  }
              }
          } catch (final Throwable e) {
              final String msg = "Unable to get vms through host " + _host.getUuid() + " due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg);
          }
          return vmMetaDatum;
      }
  
      @Override
      public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException {
          _name = name;
  
          try {
              _dcId = Long.parseLong((String)params.get("zone"));
          } catch (final NumberFormatException e) {
              throw new ConfigurationException("Unable to get the zone " + params.get("zone"));
          }
  
          _host.setUuid((String)params.get("guid"));
  
          _name = _host.getUuid();
          _host.setIp((String)params.get("ipaddress"));
  
          _username = (String)params.get("username");
          _password.add((String)params.get("password"));
          _pod = (String)params.get("pod");
          _cluster = (String)params.get("cluster");
          _privateNetworkName = (String)params.get("private.network.device");
          _publicNetworkName = (String)params.get("public.network.device");
          _guestNetworkName = (String)params.get("guest.network.device");
          _instance = (String)params.get("instance.name");
          _securityGroupEnabled = Boolean.parseBoolean((String)params.get("securitygroupenabled"));
  
          _linkLocalPrivateNetworkName = (String)params.get("private.linkLocal.device");
          if (_linkLocalPrivateNetworkName == null) {
              _linkLocalPrivateNetworkName = "cloud_link_local_network";
          }
  
          _storageNetworkName1 = (String)params.get("storage.network.device1");
          _storageNetworkName2 = (String)params.get("storage.network.device2");
  
          _heartbeatTimeout = NumbersUtil.parseInt((String)params.get("xenserver.heartbeat.timeout"), 120);
          _heartbeatInterval = NumbersUtil.parseInt((String)params.get("xenserver.heartbeat.interval"), 60);
  
          String value = (String)params.get("wait");
          _wait = NumbersUtil.parseInt(value, 600);
  
          value = (String)params.get("migratewait");
          _migratewait = NumbersUtil.parseInt(value, 3600);
  
          _maxNics = NumbersUtil.parseInt((String)params.get("xenserver.nics.max"), 7);
  
          if (_pod == null) {
              throw new ConfigurationException("Unable to get the pod");
          }
  
          if (_host.getIp() == null) {
              throw new ConfigurationException("Unable to get the host address");
          }
  
          if (_username == null) {
              throw new ConfigurationException("Unable to get the username");
          }
  
          if (_password.peek() == null) {
              throw new ConfigurationException("Unable to get the password");
          }
  
          if (_host.getUuid() == null) {
              throw new ConfigurationException("Unable to get the uuid");
          }
  
          CheckXenHostInfo();
  
          storageHandler = buildStorageHandler();
  
          _vrResource = new VirtualRoutingResource(this);
          if (!_vrResource.configure(name, params)) {
              throw new ConfigurationException("Unable to configure VirtualRoutingResource");
          }
          return true;
      }
  
      /**
       * This method creates a XenServer network and configures it for being used
       * as a L2-in-L3 tunneled network
       */
      public synchronized Network configureTunnelNetwork(final Connection conn, final Long networkId, final long hostId, final String bridgeName) {
          try {
              final Network nw = findOrCreateTunnelNetwork(conn, bridgeName);
              // Invoke plugin to setup the bridge which will be used by this
              // network
              final String bridge = nw.getBridge(conn);
              String result;
              if (bridgeName.startsWith("OVS-DR-VPC-Bridge")) {
                  result = callHostPlugin(conn, "ovstunnel", "setup_ovs_bridge_for_distributed_routing", "bridge", bridge, "key", bridgeName, "xs_nw_uuid", nw.getUuid(conn), "cs_host_id",
                          ((Long)hostId).toString());
              } else {
                  result = callHostPlugin(conn, "ovstunnel", "setup_ovs_bridge", "bridge", bridge, "key", bridgeName, "xs_nw_uuid", nw.getUuid(conn), "cs_host_id", ((Long)hostId).toString());
              }
  
              // Note down the fact that the ovs bridge has been setup
              final String[] res = result.split(":");
              if (res.length != 2 || !res[0].equalsIgnoreCase("SUCCESS")) {
                  throw new CloudRuntimeException("Unable to pre-configure OVS bridge " + bridge);
              }
              return nw;
          } catch (final Exception e) {
              logger.warn("createandConfigureTunnelNetwork failed", e);
              return null;
          }
      }
  
      public String connect(final Connection conn, final String vmname, final String ipAddress, int sleep) {
          return connect(conn, vmname, ipAddress, DEFAULTDOMRSSHPORT, sleep);
      }
  
      public String connect(final Connection conn, final String vmName, final String ipAddress, final int port, int sleep) {
          if (sleep == 0) {
              sleep = _sleep;
          }
  
          for (int i = 0; i <= _retry; i++) {
              try {
                  final Set<VM> vms = VM.getByNameLabel(conn, vmName);
                  if (vms.isEmpty()) {
                      final String msg = "VM " + vmName + " is not running";
                      logger.warn(msg);
                      return msg;
                  }
              } catch (final Exception e) {
                  final String msg = "VM.getByNameLabel " + vmName + " failed due to " + e;
                  logger.warn(msg, e);
                  return msg;
              }
              if (logger.isDebugEnabled()) {
                  logger.debug("Trying to connect to " + ipAddress + " attempt " + i + " of " + _retry);
              }
              if (pingdomr(conn, ipAddress, Integer.toString(port))) {
                  return null;
              }
              try {
                  Thread.sleep(sleep);
              } catch (final InterruptedException ignored) {
              }
          }
          final String msg = "Timeout, Unable to logon to " + ipAddress;
          logger.debug(msg);
  
          return msg;
      }
  
      public String copyVhdFromSecondaryStorage(final Connection conn, final String mountpoint, final String sruuid, final int wait) {
          final String nameLabel = "cloud-" + UUID.randomUUID();
          final String results = callHostPluginAsync(conn, "vmopspremium", "copy_vhd_from_secondarystorage", wait, "mountpoint", mountpoint, "sruuid", sruuid, "namelabel", nameLabel);
          String errMsg;
          if (results == null || results.isEmpty()) {
              errMsg = "copy_vhd_from_secondarystorage return null";
          } else {
              final String[] tmp = results.split("#");
              final String status = tmp[0];
              if (status.equals("0")) {
                  return tmp[1];
              } else {
                  errMsg = tmp[1];
              }
          }
          final String source = mountpoint.substring(mountpoint.lastIndexOf('/') + 1);
          if (killCopyProcess(conn, source)) {
              destroyVDIbyNameLabel(conn, nameLabel);
          }
          logger.warn(errMsg);
          throw new CloudRuntimeException(errMsg);
      }
  
      @Override
      public ExecutionResult createFileInVR(final String routerIp, final String path, final String filename, final String content) {
          final Connection conn = getConnection();
          final String hostPath = "/tmp/";
  
          logger.debug("Copying VR with ip " + routerIp + " config file into host " + _host.getIp());
          try {
              SshHelper.scpTo(_host.getIp(), 22, _username, null, _password.peek(), hostPath, content.getBytes(Charset.defaultCharset()), filename, null);
          } catch (final Exception e) {
              logger.warn("scp VR config file into host " + _host.getIp() + " failed with exception " + e.getMessage());
          }
  
          final String rc = callHostPlugin(conn, "vmops", "createFileInDomr", "domrip", routerIp, "srcfilepath", hostPath + filename, "dstfilepath", path, "cleanup", "true");
          logger.debug("VR Config file " + filename + " got created in VR, IP: " + routerIp + " with content \n" + content);
  
          return new ExecutionResult(rc.startsWith("succ#"), rc.substring(5));
      }
  
      public ExecutionResult copyPatchFilesToVR(final String routerIp, final String path) {
          final Connection conn = getConnection();
          final String hostPath = "/opt/xensource/packages/resources/";
          String rc = "";
          for (String file: systemVmPatchFiles) {
              rc = callHostPlugin(conn, "vmops", "createFileInDomr", "domrip", routerIp, "srcfilepath", hostPath.concat(file), "dstfilepath", path, "cleanup", "false");
              if (rc.startsWith("fail#")) {
                  logger.error(String.format("Failed to scp file %s required for patching the systemVM", file));
                  break;
              }
          }
  
          logger.debug("VR Config files at " + hostPath + " got created in VR, IP: " + routerIp);
  
          return new ExecutionResult(rc.startsWith("succ#"), rc.substring(5));
      }
  
      protected SR createIsoSRbyURI(final Connection conn, final URI uri, final String vmName, final boolean shared) {
          try {
              final Map<String, String> deviceConfig = new HashMap<>();
              final boolean isConfigDrive = uri.toString().endsWith(ConfigDrive.CONFIGDRIVEDIR);
              String path = uri.getPath();
              path = path.replace("//", "/");
              deviceConfig.put("location", uri.getHost() + ":" + path);
              final Host host = Host.getByUuid(conn, _host.getUuid());
              final SR sr = SR.create(conn, host, deviceConfig, 0L, uri.getHost() + path, "iso", "iso", "iso", shared, new HashMap<>());
              sr.setNameLabel(conn, vmName + (isConfigDrive ? VM_NAME_CONFIGDRIVE_ISO_SUFFIX: VM_NAME_ISO_SUFFIX));
              sr.setNameDescription(conn, deviceConfig.get("location"));
  
              sr.scan(conn);
              return sr;
          } catch (final XenAPIException e) {
              final String msg = "createIsoSRbyURI failed! mountpoint: " + uri.getHost() + uri.getPath() + " due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          } catch (final Exception e) {
              final String msg = "createIsoSRbyURI failed! mountpoint: " + uri.getHost() + uri.getPath() + " due to " + e.getMessage();
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          }
      }
  
      protected SR createNfsSRbyURI(final Connection conn, final URI uri, final boolean shared) {
          try {
              if (logger.isDebugEnabled()) {
                  logger.debug("Creating a " + (shared ? "shared SR for " : "not shared SR for ") + uri);
              }
  
              final Map<String, String> deviceConfig = new HashMap<>();
              String path = uri.getPath();
              path = path.replace("//", "/");
              deviceConfig.put("server", uri.getHost());
              deviceConfig.put("serverpath", path);
              final String name = UuidUtils.nameUUIDFromBytes((uri.getHost() + path).getBytes()).toString();
              if (!shared) {
                  final Set<SR> srs = SR.getByNameLabel(conn, name);
                  for (final SR sr : srs) {
                      final SR.Record record = sr.getRecord(conn);
                      if (SRType.NFS.equals(record.type) && record.contentType.equals("user") && !record.shared) {
                          removeSRSync(conn, sr);
                      }
                  }
              }
  
              final Host host = Host.getByUuid(conn, _host.getUuid());
              final Map<String, String> smConfig = new HashMap<>();
              smConfig.put("nosubdir", "true");
              final SR sr = SR.create(conn, host, deviceConfig, 0L, name, uri.getHost() + uri.getPath(), SRType.NFS.toString(), "user", shared, smConfig);
  
              if (!checkSR(conn, sr)) {
                  throw new Exception("no attached PBD");
              }
              if (logger.isDebugEnabled()) {
                  logger.debug(logX(sr, "Created a SR; UUID is " + sr.getUuid(conn) + " device config is " + deviceConfig));
              }
              sr.scan(conn);
              return sr;
          } catch (final XenAPIException e) {
              final String msg = "Can not create second storage SR mountpoint: " + uri.getHost() + uri.getPath() + " due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          } catch (final Exception e) {
              final String msg = "Can not create second storage SR mountpoint: " + uri.getHost() + uri.getPath() + " due to " + e.getMessage();
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          }
      }
  
      public SR findPatchIsoSR(final Connection conn) throws XmlRpcException, XenAPIException {
          Set<SR> srs = SR.getByNameLabel(conn, "XenServer Tools");
          if (srs.size() != 1) {
              logger.debug("Failed to find SR by name 'XenServer Tools', will try to find 'XCP-ng Tools' SR");
              srs = SR.getByNameLabel(conn, "XCP-ng Tools");
          }
          if (srs.size() != 1) {
              logger.debug("Failed to find SR by name 'XenServer Tools' or 'XCP-ng Tools', will try to find 'Citrix Hypervisor' SR");
              srs = SR.getByNameLabel(conn, "Citrix Hypervisor Tools");
          }
          if (srs.size() != 1) {
              throw new CloudRuntimeException("There are " + srs.size() + " SRs with name XenServer Tools or XCP-ng Tools or Citrix Hypervisor Tools");
          }
          final SR sr = srs.iterator().next();
          sr.scan(conn);
          return sr;
      }
  
      public VDI findPatchIsoVDI(final Connection conn, final SR sr) throws XmlRpcException, XenAPIException {
          if (sr == null) {
              return null;
          }
          final SR.Record srr = sr.getRecord(conn);
          for (final VDI vdi : srr.VDIs) {
              final VDI.Record vdir = vdi.getRecord(conn);
              if (vdir.nameLabel.contains("systemvm.iso")) {
                  return vdi;
              }
          }
          return null;
      }
  
      public VBD createPatchVbd(final Connection conn, final String vmName, final VM vm) throws XmlRpcException, XenAPIException {
  
          if (_host.getSystemvmisouuid() == null) {
              final SR sr = findPatchIsoSR(conn);
              if (_host.getSystemvmisouuid() == null) {
                  final VDI vdi = findPatchIsoVDI(conn, sr);
                  if (vdi != null) {
                      _host.setSystemvmisouuid(vdi.getRecord(conn).uuid);
                  }
              }
          }
  
          final VBD.Record cdromVBDR = new VBD.Record();
          cdromVBDR.VM = vm;
          cdromVBDR.empty = true;
          cdromVBDR.bootable = false;
          cdromVBDR.userdevice = "3";
          cdromVBDR.mode = Types.VbdMode.RO;
          cdromVBDR.type = Types.VbdType.CD;
  
          return VBD.create(conn, cdromVBDR);
      }
  
      protected boolean createSecondaryStorageFolder(final Connection conn, final String remoteMountPath, final String newFolder, final String nfsVersion) {
          final String result = callHostPlugin(conn, "vmopsSnapshot", "create_secondary_storage_folder", "remoteMountPath", remoteMountPath, "newFolder", newFolder, "nfsVersion", nfsVersion);
          return result != null;
      }
  
      String createTemplateFromSnapshot(final Connection conn, final String templatePath, final String snapshotPath, final int wait) {
          final String tmpltLocalDir = UUID.randomUUID().toString();
          final String results = callHostPluginAsync(conn, "vmopspremium", "create_privatetemplate_from_snapshot", wait, "templatePath", templatePath, "snapshotPath", snapshotPath, "tmpltLocalDir",
                  tmpltLocalDir);
          String errMsg;
          if (results == null || results.isEmpty()) {
              errMsg = "create_privatetemplate_from_snapshot return null";
          } else {
              final String[] tmp = results.split("#");
              final String status = tmp[0];
              if (status.equals("0")) {
                  return results;
              } else {
                  errMsg = "create_privatetemplate_from_snapshot failed due to " + tmp[1];
              }
          }
          final String source = "cloud_mount/" + tmpltLocalDir;
          killCopyProcess(conn, source);
          logger.warn(errMsg);
          throw new CloudRuntimeException(errMsg);
      }
  
      public VBD createVbd(final Connection conn, final DiskTO volume, final String vmName, final VM vm, final BootloaderType bootLoaderType, VDI vdi, int isoCount) throws XmlRpcException, XenAPIException {
          final Volume.Type type = volume.getType();
  
          if (vdi == null) {
              vdi = mount(conn, vmName, volume);
          }
  
          if (vdi != null) {
              if ("detached".equals(vdi.getNameLabel(conn))) {
                  vdi.setNameLabel(conn, vmName + "-DATA");
              }
  
              final Map<String, String> smConfig = vdi.getSmConfig(conn);
              for (final String key : smConfig.keySet()) {
                  if (key.startsWith("host_")) {
                      vdi.removeFromSmConfig(conn, key);
                      break;
                  }
              }
          }
          final VBD.Record vbdr = new VBD.Record();
          vbdr.VM = vm;
          if (vdi != null) {
              vbdr.VDI = vdi;
          } else {
              vbdr.empty = true;
          }
          if (type == Volume.Type.ROOT && bootLoaderType == BootloaderType.PyGrub) {
              vbdr.bootable = true;
          } else if (type == Volume.Type.ISO && bootLoaderType == BootloaderType.CD) {
              vbdr.bootable = true;
          }
  
          if (volume.getType() == Volume.Type.ISO) {
              vbdr.mode = Types.VbdMode.RO;
              vbdr.type = Types.VbdType.CD;
              vbdr.userdevice = String.valueOf(USER_DEVICE_START_ID + isoCount);
          } else {
              vbdr.mode = Types.VbdMode.RW;
              vbdr.type = Types.VbdType.DISK;
              vbdr.unpluggable = volume.getType() != Volume.Type.ROOT;
              vbdr.userdevice = "autodetect";
              final Long deviceId = volume.getDiskSeq();
              if (deviceId != null && (!isDeviceUsed(conn, vm, deviceId) || deviceId > 3)) {
                  vbdr.userdevice = deviceId.toString();
              }
          }
          final VBD vbd = VBD.create(conn, vbdr);
  
          if (logger.isDebugEnabled()) {
              logger.debug("VBD " + vbd.getUuid(conn) + " created for " + volume);
          }
  
          return vbd;
      }
  
      public VDI createVdi(final SR sr, final String vdiNameLabel, final Long volumeSize) throws Types.XenAPIException, XmlRpcException {
          final Connection conn = getConnection();
  
          final VDI.Record vdir = new VDI.Record();
  
          vdir.nameLabel = vdiNameLabel;
          vdir.SR = sr;
          vdir.type = Types.VdiType.USER;
  
          final long totalSrSpace = sr.getPhysicalSize(conn);
          final long unavailableSrSpace = sr.getPhysicalUtilisation(conn);
          final long availableSrSpace = totalSrSpace - unavailableSrSpace;
  
          if (availableSrSpace < volumeSize) {
              throw new CloudRuntimeException("Available space for SR cannot be less than " + volumeSize + ".");
          }
  
          vdir.virtualSize = volumeSize;
  
          return VDI.create(conn, vdir);
      }
  
      public void createVGPU(final Connection conn, final StartCommand cmd, final VM vm, final GPUDeviceTO gpuDevice) throws XenAPIException, XmlRpcException {
      }
  
      public VIF createVif(final Connection conn, final String vmName, final VM vm, final VirtualMachineTO vmSpec, final NicTO nic) throws XmlRpcException, XenAPIException {
          assert nic.getUuid() != null : "Nic should have a uuid value";
  
          if (logger.isDebugEnabled()) {
              logger.debug("Creating VIF for " + vmName + " on nic " + nic);
          }
          VIF.Record vifr = new VIF.Record();
          vifr.VM = vm;
          vifr.device = Integer.toString(nic.getDeviceId());
          vifr.MAC = nic.getMac();
  
          // Nicira needs these IDs to find the NIC
          vifr.otherConfig = new HashMap<>();
          vifr.otherConfig.put("nicira-iface-id", nic.getUuid());
          vifr.otherConfig.put("nicira-vm-id", vm.getUuid(conn));
          // Provide XAPI with the cloudstack vm and nic uids.
          vifr.otherConfig.put("cloudstack-nic-id", nic.getUuid());
          if (vmSpec != null) {
              vifr.otherConfig.put("cloudstack-vm-id", vmSpec.getUuid());
          }
  
          // OVS plugin looks at network UUID in the vif 'otherconfig' details to
          // group VIF's & tunnel ports as part of tier
          // when bridge is setup for distributed routing
          vifr.otherConfig.put("cloudstack-network-id", nic.getNetworkUuid());
          vifr.network = getNetwork(conn, nic);
  
          if (nic.getNetworkRateMbps() != null && nic.getNetworkRateMbps() != -1) {
              vifr.qosAlgorithmType = "ratelimit";
              vifr.qosAlgorithmParams = new HashMap<>();
              // convert mbs to kilobyte per second
              vifr.qosAlgorithmParams.put("kbps", Integer.toString(nic.getNetworkRateMbps() * 128));
          }
  
          vifr.lockingMode = Types.VifLockingMode.NETWORK_DEFAULT;
          final VIF vif = VIF.create(conn, vifr);
          if (logger.isDebugEnabled()) {
              vifr = vif.getRecord(conn);
              if (vifr != null) {
                  logger.debug("Created a vif " + vifr.uuid + " on " + nic.getDeviceId());
              }
          }
  
          return vif;
      }
  
      public VM createVmFromTemplate(final Connection conn, final VirtualMachineTO vmSpec, final Host host) throws XenAPIException, XmlRpcException {
          final String guestOsTypeName = getGuestOsType(vmSpec.getPlatformEmulator());
          final Set<VM> templates = VM.getByNameLabel(conn, guestOsTypeName);
          if (templates == null || templates.isEmpty()) {
              throw new CloudRuntimeException("Cannot find template " + guestOsTypeName + " on XenServer host");
          }
          assert templates.size() == 1 : "Should only have 1 template but found " + templates.size();
          final VM template = templates.iterator().next();
  
          final VM.Record vmr = template.getRecord(conn);
          vmr.affinity = host;
          vmr.otherConfig.remove("disks");
          vmr.otherConfig.remove("default_template");
          vmr.otherConfig.remove("mac_seed");
          vmr.isATemplate = false;
          vmr.nameLabel = vmSpec.getName();
          vmr.actionsAfterCrash = Types.OnCrashBehaviour.DESTROY;
          vmr.actionsAfterShutdown = Types.OnNormalExit.DESTROY;
          vmr.otherConfig.put("vm_uuid", vmSpec.getUuid());
          vmr.VCPUsMax = (long)vmSpec.getCpus(); // FIX ME: In case of dynamic
          // scaling this VCPU max should
          // be the minumum of
          // recommended value for that template and capacity remaining on host
  
          long recommendedMemoryMin = 0L;
          long recommendedMemoryMax = 0L;
  
          Map<String, String> guestOsDetails = vmSpec.getGuestOsDetails();
  
          if (guestOsDetails != null) {
              if (guestOsDetails.containsKey("xenserver.dynamicMin")) {
                  recommendedMemoryMin = Long.parseLong(guestOsDetails.get("xenserver.dynamicMin"));
              }
  
              if (guestOsDetails.containsKey("xenserver.dynamicMax")) {
                  recommendedMemoryMax = Long.parseLong(guestOsDetails.get("xenserver.dynamicMax"));
              }
          }
  
          if (isDmcEnabled(conn, host) && vmSpec.isEnableDynamicallyScaleVm()) {
              // scaling is allowed
              vmr.memoryStaticMin = getStaticMin(vmSpec.getOs(), vmSpec.getBootloader() == BootloaderType.CD, vmSpec.getMinRam(), vmSpec.getMaxRam(), recommendedMemoryMin);
              vmr.memoryStaticMax = getStaticMax(vmSpec.getOs(), vmSpec.getBootloader() == BootloaderType.CD, vmSpec.getMinRam(), vmSpec.getMaxRam(), recommendedMemoryMax);
              vmr.memoryDynamicMin = vmSpec.getMinRam();
              vmr.memoryDynamicMax = vmSpec.getMaxRam();
              if (guestOsTypeName.toLowerCase().contains("windows")) {
                  vmr.VCPUsMax = (long)vmSpec.getCpus();
              } else {
                  if (vmSpec.getVcpuMaxLimit() != null) {
                      vmr.VCPUsMax = Math.min(vmSpec.getVcpuMaxLimit(), (long) _host.getCpus());
                  }
              }
          } else {
              // scaling disallowed, set static memory target
              if (vmSpec.isEnableDynamicallyScaleVm() && !isDmcEnabled(conn, host)) {
                  logger.warn("Host " + host.getHostname(conn) + " does not support dynamic scaling, so the vm " + vmSpec.getName() + " is not dynamically scalable");
              }
              vmr.memoryStaticMin = vmSpec.getMinRam();
              vmr.memoryStaticMax = vmSpec.getMaxRam();
              vmr.memoryDynamicMin = vmSpec.getMinRam();
              vmr.memoryDynamicMax = vmSpec.getMaxRam();
  
              vmr.VCPUsMax = (long)vmSpec.getCpus();
          }
  
          vmr.VCPUsAtStartup = (long)vmSpec.getCpus();
          vmr.consoles.clear();
          vmr.xenstoreData.clear();
          //Add xenstore data for the NetscalerVM
          if (vmSpec.getType() == VirtualMachine.Type.NetScalerVm) {
              NicTO mgmtNic = vmSpec.getNics()[0];
              if (mgmtNic != null) {
                  Map<String, String> xenstoreData = new HashMap<>(3);
                  xenstoreData.put(XENSTORE_DATA_IP, mgmtNic.getIp().trim());
                  xenstoreData.put(XENSTORE_DATA_GATEWAY, mgmtNic.getGateway().trim());
                  xenstoreData.put(XENSTORE_DATA_NETMASK, mgmtNic.getNetmask().trim());
                  vmr.xenstoreData = xenstoreData;
              }
          }
  
          final VM vm = VM.create(conn, vmr);
          logger.debug("Created VM " + vm.getUuid(conn) + " for " + vmSpec.getName());
  
          final Map<String, String> vcpuParams = new HashMap<>();
  
          final Integer speed = vmSpec.getMinSpeed();
          if (speed != null) {
              int cpuWeight; // cpu_weight
              int utilization = 0; // max CPU cap, default is unlimited
  
              // weight based allocation, CPU weight is calculated per VCPU
              cpuWeight = (int)(speed * 0.99 / _host.getSpeed() * _maxWeight);
              if (cpuWeight > _maxWeight) {
                  cpuWeight = _maxWeight;
              }
  
              if (vmSpec.isLimitCpuUse()) {
                  // CPU cap is per VM, so need to assign cap based on the number
                  // of vcpus
                  utilization = (int)(vmSpec.getMaxSpeed() * 0.99 * vmSpec.getCpus() / _host.getSpeed() * 100);
              }
  
              vcpuParams.put("weight", Integer.toString(cpuWeight));
              vcpuParams.put("cap", Integer.toString(utilization));
  
          }
  
          if (!vcpuParams.isEmpty()) {
              vm.setVCPUsParams(conn, vcpuParams);
          }
  
          final String bootArgs = vmSpec.getBootArgs();
          if (bootArgs != null && !bootArgs.isEmpty()) {
              // send boot args for PV instances
              String pvargs = vm.getPVArgs(conn);
              pvargs = pvargs + vmSpec.getBootArgs().replaceAll(" ", "%");
              vm.setPVArgs(conn, pvargs);
              logger.debug("PV args are " + pvargs);
  
              // send boot args into xenstore-data for HVM instances
              Map<String, String> xenstoreData = new HashMap<>();
  
              xenstoreData.put(XENSTORE_DATA_CS_INIT, bootArgs);
              vm.setXenstoreData(conn, xenstoreData);
              logger.debug("HVM args are " + bootArgs);
          }
  
          if (!(guestOsTypeName.startsWith("Windows") || guestOsTypeName.startsWith("Citrix") || guestOsTypeName.startsWith("Other"))) {
              if (vmSpec.getBootloader() == BootloaderType.CD) {
                  final DiskTO[] disks = vmSpec.getDisks();
                  for (final DiskTO disk : disks) {
                      if (disk.getType() == Volume.Type.ISO) {
                          final TemplateObjectTO iso = (TemplateObjectTO) disk.getData();
                          final String osType = iso.getGuestOsType();
                          if (osType != null) {
                              final String isoGuestOsName = getGuestOsType(vmSpec.getPlatformEmulator());
                              if (!isoGuestOsName.equals(guestOsTypeName)) {
                                  vmSpec.setBootloader(BootloaderType.PyGrub);
                              }
                          }
                      }
                  }
              }
              if (vmSpec.getBootloader() == BootloaderType.CD) {
                  vm.setPVBootloader(conn, "eliloader");
                  if (!vm.getOtherConfig(conn).containsKey("install-repository")) {
                      vm.addToOtherConfig(conn, "install-repository", "cdrom");
                  }
              } else if (vmSpec.getBootloader() == BootloaderType.PyGrub) {
                  vm.setPVBootloader(conn, "pygrub");
                  vm.setPVBootloaderArgs(conn, CitrixHelper.getPVbootloaderArgs(guestOsTypeName));
              } else {
                  destroyVm(vm, conn, true);
                  throw new CloudRuntimeException("Unable to handle boot loader type: " + vmSpec.getBootloader());
              }
          }
          try {
              finalizeVmMetaData(vm, vmr, conn, vmSpec);
          } catch (final Exception e) {
              throw new CloudRuntimeException("Unable to finalize VM MetaData: " + vmSpec);
          }
          try {
              String bootMode = StringUtils.defaultIfEmpty(vmSpec.getDetails().get(ApiConstants.BootType.UEFI.toString()), null);
              String bootType = (bootMode == null) ? ApiConstants.BootType.BIOS.toString() : ApiConstants.BootType.UEFI.toString();
              setVmBootDetails(vm, conn, bootType, bootMode);
          } catch (final XenAPIException | XmlRpcException e) {
              throw new CloudRuntimeException(String.format("Unable to handle VM boot options: %s", vmSpec), e);
          }
          return vm;
      }
  
      public VM createWorkingVM(final Connection conn, final String vmName, final String guestOSType, final String platformEmulator, final List<VolumeObjectTO> listVolumeTo)
              throws XenAPIException, XmlRpcException {
          // below is redundant but keeping for consistency and code readabilty
          if (platformEmulator == null) {
              final String msg = " Hypervisor " + this.getClass().getName() + " doesn't support guest OS type " + guestOSType + ". you can choose 'Other install media' to run it as HVM";
              logger.warn(msg);
              throw new CloudRuntimeException(msg);
          }
          final VM template = getVM(conn, platformEmulator);
          final VM vm = template.createClone(conn, vmName);
          vm.setIsATemplate(conn, false);
          final Map<VDI, VolumeObjectTO> vdiMap = new HashMap<>();
          for (final VolumeObjectTO volume : listVolumeTo) {
              final String vdiUuid = volume.getPath();
              try {
                  final VDI vdi = VDI.getByUuid(conn, vdiUuid);
                  vdiMap.put(vdi, volume);
              } catch (final Types.UuidInvalid e) {
                  logger.warn("Unable to find vdi by uuid: " + vdiUuid + ", skip it");
              }
          }
          for (final Map.Entry<VDI, VolumeObjectTO> entry : vdiMap.entrySet()) {
              final VDI vdi = entry.getKey();
              final VolumeObjectTO volumeTO = entry.getValue();
              final VBD.Record vbdr = new VBD.Record();
              vbdr.VM = vm;
              vbdr.VDI = vdi;
              if (volumeTO.getVolumeType() == Volume.Type.ROOT) {
                  vbdr.bootable = true;
                  vbdr.unpluggable = false;
              } else {
                  vbdr.bootable = false;
                  vbdr.unpluggable = true;
              }
              vbdr.userdevice = "autodetect";
              vbdr.mode = Types.VbdMode.RW;
              vbdr.type = Types.VbdType.DISK;
              Long deviceId = volumeTO.getDeviceId();
              if (deviceId != null && (!isDeviceUsed(conn, vm, deviceId) || deviceId > 3)) {
                  vbdr.userdevice = deviceId.toString();
              }
              VBD.create(conn, vbdr);
          }
          return vm;
      }
  
      protected boolean deleteSecondaryStorageFolder(final Connection conn, final String remoteMountPath, final String folder, final String nfsVersion) {
          final String details = callHostPlugin(conn, "vmopsSnapshot", "delete_secondary_storage_folder", "remoteMountPath", remoteMountPath, "folder", folder, "nfsVersion", nfsVersion);
          return details != null && details.equals("1");
      }
  
      protected String deleteSnapshotBackup(final Connection conn, final Long dcId, final Long accountId, final Long volumeId, final String secondaryStorageMountPath, final String backupUUID) {
  
          // If anybody modifies the formatting below again, I'll skin them
  
          return callHostPlugin(conn, "vmopsSnapshot", "deleteSnapshotBackup", "backupUUID", backupUUID, "dcId", dcId.toString(), "accountId", accountId.toString(), "volumeId",
                  volumeId.toString(), "secondaryStorageMountPath", secondaryStorageMountPath);
      }
  
      public void destroyPatchVbd(final Connection conn, final Set<VM> vms) throws XmlRpcException, XenAPIException {
          final SR sr = findPatchIsoSR(conn);
          final VDI patchVDI = findPatchIsoVDI(conn, sr);
          for (final VM vm : vms) {
              final String vmName = vm.getNameLabel(conn);
              if (!vmName.startsWith("r-") && !vmName.startsWith("s-") && !vmName.startsWith("v-")) {
                  continue;
              }
              final Set<VBD> vbds = vm.getVBDs(conn);
              for (final VBD vbd : vbds) {
                  if (Types.VbdType.CD.equals(vbd.getType(conn))) {
                      try {
                          if (!vbd.getEmpty(conn)) {
                              vbd.eject(conn);
                          }
                          // Workaround for any file descriptor caching issue
                          if (patchVDI != null) {
                              vbd.insert(conn, patchVDI);
                              vbd.eject(conn);
                          }
                      } catch (Exception e) {
                          logger.debug("Cannot eject CD-ROM device for VM " + vmName + " due to " + e, e);
                      }
                      try {
                          vbd.destroy(conn);
                      } catch (Exception e) {
                          logger.debug("Cannot destroy CD-ROM device for VM " + vmName + " due to " + e, e);
                      }
                      break;
                  }
              }
          }
      }
  
      public synchronized void destroyTunnelNetwork(final Connection conn, final Network nw, final long hostId) {
          try {
              final String bridge = nw.getBridge(conn);
              final String result = callHostPlugin(conn, "ovstunnel", "destroy_ovs_bridge", "bridge", bridge, "cs_host_id", ((Long)hostId).toString());
              final String[] res = result.split(":");
              if (res.length != 2 || !res[0].equalsIgnoreCase("SUCCESS")) {
                  throw new CloudRuntimeException("Unable to remove OVS bridge " + bridge + ":" + result);
              }
          } catch (final Exception e) {
              logger.warn("destroyTunnelNetwork failed:", e);
          }
      }
  
      void destroyVDIbyNameLabel(final Connection conn, final String nameLabel) {
          try {
              final Set<VDI> vdis = VDI.getByNameLabel(conn, nameLabel);
              if (vdis.size() != 1) {
                  logger.warn("destroyVDIbyNameLabel failed due to there are " + vdis.size() + " VDIs with name " + nameLabel);
                  return;
              }
              for (final VDI vdi : vdis) {
                  try {
                      vdi.destroy(conn);
                  } catch (final Exception e) {
                      final String msg = "Failed to destroy VDI : " + nameLabel + "due to " + e + "\n Force deleting VDI using system 'rm' command";
                      logger.warn(msg);
                      try {
                          final String srUUID = vdi.getSR(conn).getUuid(conn);
                          final String vdiUUID = vdi.getUuid(conn);
                          final String vdifile = "/var/run/sr-mount/" + srUUID + "/" + vdiUUID + ".vhd";
                          callHostPluginAsync(conn, "vmopspremium", "remove_corrupt_vdi", 10, "vdifile", vdifile);
                      } catch (final Exception e2) {
                          logger.warn(e2);
                      }
                  }
              }
          } catch (final Exception ignored) {
          }
      }
  
      public void disableVlanNetwork(final Connection conn, final Network network, boolean deleteVlan) {
      }
  
      @Override
      public void disconnected() {
      }
  
      public boolean doPingTest(final Connection conn, final String computingHostIp) {
          final com.trilead.ssh2.Connection sshConnection = new com.trilead.ssh2.Connection(_host.getIp(), 22);
          try {
              sshConnection.connect(null, 60000, 60000);
              if (!sshConnection.authenticateWithPassword(_username, _password.peek())) {
                  throw new CloudRuntimeException("Unable to authenticate");
              }
  
              final String cmd = "ping -c 2 " + computingHostIp;
              if (!SSHCmdHelper.sshExecuteCmd(sshConnection, cmd)) {
                  throw new CloudRuntimeException("Cannot ping host " + computingHostIp + " from host " + _host.getIp());
              }
              return true;
          } catch (final Exception e) {
              logger.warn("Catch exception " + e, e);
              return false;
          } finally {
              sshConnection.close();
          }
      }
  
      public boolean doPingTest(final Connection conn, final String domRIp, final String vmIp) {
          final String args = "-i " + domRIp + " -p " + vmIp;
          final String result = callHostPlugin(conn, "vmops", "pingtest", "args", args);
          return result != null && !result.isEmpty();
      }
  
      /**
       * enableVlanNetwork creates a Network object, Vlan object, and thereby a
       * tagged PIF object in Xapi.
       *
       * In XenServer, VLAN is added by - Create a network, which is unique
       * cluster wide. - Find the PIF that you want to create the VLAN on. -
       * Create a VLAN using the network and the PIF. As a result of this
       * operation, a tagged PIF object is also created.
       *
       * Here is a list of problems with clustered Xapi implementation that we are
       * trying to circumvent. - There can be multiple Networks with the same
       * name-label so searching using name-label is not unique. - There are no
       * other ways to search for Networks other than listing all of them which is
       * not efficient in our implementation because we can have over 4000 VLAN
       * networks. - In a clustered situation, it's possible for both hosts to
       * detect that the Network is missing and both creates it. This causes a lot
       * of problems as one host may be using one Network and another may be using
       * a different network for their VMs. This causes problems in migration
       * because the VMs are logically attached to different networks in Xapi's
       * database but in reality, they are attached to the same network.
       *
       * To work around these problems, we do the following.
       *
       * - When creating the VLAN network, we name it as VLAN-UUID of the Network
       * it is created on-VLAN Tag. Because VLAN tags is unique with one
       * particular network, this is a unique name-label to quickly retrieve the
       * the VLAN network with when we need it again. - When we create the VLAN
       * network, we add a timestamp and a random number as a tag into the
       * network. Then instead of creating VLAN on that network, we actually
       * retrieve the Network again and this time uses the VLAN network with
       * lowest timestamp or lowest random number as the VLAN network. This allows
       * VLAN creation to happen on multiple hosts concurrently but even if two
       * VLAN networks were created with the same name, only one of them is used.
       *
       * One cavaet about this approach is that it relies on the timestamp to be
       * relatively accurate among different hosts.
       *
       * @param conn
       *            Xapi Connection
       * @param tag
       *            VLAN tag
       * @param network
       *            network on this host to create the VLAN on.
       * @return VLAN Network created.
       * @throws XenAPIException
       * @throws XmlRpcException
       */
      protected Network enableVlanNetwork(final Connection conn, final long tag, final XsLocalNetwork network) throws XenAPIException, XmlRpcException {
          Network vlanNetwork;
          final String oldName = "VLAN" + tag;
          final String newName = "VLAN-" + network.getNetworkRecord(conn).uuid + "-" + tag;
          XsLocalNetwork vlanNic = getNetworkByName(conn, newName);
          if (vlanNic == null) {
              if (logger.isDebugEnabled()) {
                  logger.debug("Couldn't find vlan network with the new name so trying old name: " + oldName);
              }
              vlanNic = getNetworkByName(conn, oldName);
              if (vlanNic != null) {
                  logger.info("Renaming VLAN with old name " + oldName + " to " + newName);
                  vlanNic.getNetwork().setNameLabel(conn, newName);
              }
          }
          if (vlanNic == null) { // Can't find it, then create it.
              if (logger.isDebugEnabled()) {
                  logger.debug("Creating VLAN network for " + tag + " on host " + _host.getIp());
              }
              final Network.Record nwr = new Network.Record();
              nwr.nameLabel = newName;
              nwr.tags = new HashSet<>();
              nwr.tags.add(generateTimeStamp());
              nwr.managed = true;
              vlanNetwork = Network.create(conn, nwr);
              vlanNic = getNetworkByName(conn, newName);
              if (vlanNic == null) { // Still vlanNic is null means we could not
                  // create it for some reason and no exception
                  // capture happened.
                  throw new CloudRuntimeException("Could not find/create vlan network with name: " + newName);
              }
          }
  
          final PIF nPif = network.getPif(conn);
          final PIF.Record nPifr = network.getPifRecord(conn);
  
          vlanNetwork = vlanNic.getNetwork();
          if (vlanNic.getPif(conn) != null) {
              return vlanNetwork;
          }
  
          if (logger.isDebugEnabled()) {
              logger.debug("Creating VLAN " + tag + " on host " + _host.getIp() + " on device " + nPifr.device);
          }
          final VLAN vlan = VLAN.create(conn, nPif, tag, vlanNetwork);
          if (vlan != null) {
              final VLAN.Record vlanr = vlan.getRecord(conn);
              if (vlanr != null) {
                  if (logger.isDebugEnabled()) {
                      logger.debug("VLAN is created for " + tag + ".  The uuid is " + vlanr.uuid);
                  }
              }
          }
          return vlanNetwork;
      }
  
      @Override
      public RebootAnswer execute(final RebootCommand cmd) {
          throw new CloudRuntimeException("The method has been replaced but the implementation CitrixRebootCommandWrapper. "
                  + "Please use the new design in order to keep compatibility. Once all ServerResource implementation are refactored those methods will dissapper.");
      }
  
      @Override
      public StartAnswer execute(final StartCommand cmd) {
          throw new CloudRuntimeException("The method has been replaced but the implementation CitrixStartCommandWrapper. "
                  + "Please use the new design in order to keep compatibility. Once all ServerResource implementation are refactored those methods will dissapper.");
      }
  
      @Override
      public StopAnswer execute(final StopCommand cmd) {
          throw new CloudRuntimeException("The method has been replaced but the implementation CitrixStopCommandWrapper. "
                  + "Please use the new design in order to keep compatibility. Once all ServerResource implementation are refactored those methods will dissapper.");
      }
  
      @Override
      public ExecutionResult executeInVR(final String routerIP, final String script, final String args) {
          // Timeout is 120 seconds by default
          return executeInVR(routerIP, script, args, VRScripts.VR_SCRIPT_EXEC_TIMEOUT);
      }
  
      @Override
      public ExecutionResult executeInVR(final String routerIP, final String script, final String args, final Duration timeout) {
          Pair<Boolean, String> result;
          String cmdline = "/opt/cloud/bin/router_proxy.sh " + script + " " + routerIP + " " + args;
          // semicolon need to be escape for bash
          cmdline = cmdline.replaceAll(";", "\\\\;");
          try {
              logger.debug("Executing command in VR: " + cmdline);
              result = SshHelper.sshExecute(_host.getIp(), 22, _username, null, _password.peek(), cmdline, VRScripts.CONNECTION_TIMEOUT, VRScripts.CONNECTION_TIMEOUT, timeout);
          } catch (final Exception e) {
              return new ExecutionResult(false, e.getMessage());
          }
          return new ExecutionResult(result.first(), result.second());
      }
  
      @Override
      public Answer executeRequest(final Command cmd) {
          final CitrixRequestWrapper wrapper = CitrixRequestWrapper.getInstance();
          try {
              return wrapper.execute(cmd, this);
          } catch (final Exception e) {
              return Answer.createUnsupportedCommandAnswer(cmd);
          }
      }
  
      protected void fillHostInfo(final Connection conn, final StartupRoutingCommand cmd) {
          final StringBuilder caps = new StringBuilder();
          try {
  
              final Host host = Host.getByUuid(conn, _host.getUuid());
              final Host.Record hr = host.getRecord(conn);
  
              Map<String, String> details = cmd.getHostDetails();
              if (details == null) {
                  details = new HashMap<>();
              }
  
              String productBrand = hr.softwareVersion.get("product_brand");
              if (productBrand == null) {
                  productBrand = hr.softwareVersion.get("platform_name");
              }
              details.put("product_brand", productBrand);
              details.put("product_version", _host.getProductVersion());
              if (hr.softwareVersion.get("product_version_text_short") != null) {
                  details.put("product_version_text_short", hr.softwareVersion.get("product_version_text_short"));
                  cmd.setHypervisorVersion(hr.softwareVersion.get("product_version_text_short"));
  
                  cmd.setHypervisorVersion(_host.getProductVersion());
              }
              if (_privateNetworkName != null) {
                  details.put("private.network.device", _privateNetworkName);
              }
  
              cmd.setHostDetails(details);
              cmd.setName(hr.nameLabel);
              cmd.setGuid(_host.getUuid());
              cmd.setPool(_host.getPool());
              cmd.setDataCenter(Long.toString(_dcId));
              for (final String cap : hr.capabilities) {
                  if (!cap.isEmpty()) {
                      caps.append(cap).append(" , ");
                  }
              }
              if (caps.length() > 0) {
                  caps.delete(caps.length() - 3, caps.length());
              }
              cmd.setCaps(caps.toString());
  
              cmd.setSpeed(_host.getSpeed());
              cmd.setCpuSockets(_host.getCpuSockets());
              cmd.setCpus(_host.getCpus());
  
              final HostMetrics hm = host.getMetrics(conn);
  
              long ram;
              long dom0Ram = 0;
              ram = hm.getMemoryTotal(conn);
              final Set<VM> vms = host.getResidentVMs(conn);
              for (final VM vm : vms) {
                  if (vm.getIsControlDomain(conn)) {
                      dom0Ram = vm.getMemoryStaticMax(conn);
                      break;
                  }
              }
  
              ram = (long)((ram - dom0Ram - _xsMemoryUsed) * _xsVirtualizationFactor);
              cmd.setMemory(ram);
              cmd.setDom0MinMemory(dom0Ram);
  
              if (logger.isDebugEnabled()) {
                  logger.debug("Total Ram: " + toHumanReadableSize(ram) + " dom0 Ram: " + toHumanReadableSize(dom0Ram));
              }
  
              PIF pif = PIF.getByUuid(conn, _host.getPrivatePif());
              PIF.Record pifr = pif.getRecord(conn);
              if (pifr.IP != null && !pifr.IP.isEmpty()) {
                  cmd.setPrivateIpAddress(pifr.IP);
                  cmd.setPrivateMacAddress(pifr.MAC);
                  cmd.setPrivateNetmask(pifr.netmask);
              } else {
                  cmd.setPrivateIpAddress(_host.getIp());
                  cmd.setPrivateMacAddress(pifr.MAC);
                  cmd.setPrivateNetmask("255.255.255.0");
              }
  
              pif = PIF.getByUuid(conn, _host.getPublicPif());
              pifr = pif.getRecord(conn);
              if (pifr.IP != null && !pifr.IP.isEmpty()) {
                  cmd.setPublicIpAddress(pifr.IP);
                  cmd.setPublicMacAddress(pifr.MAC);
                  cmd.setPublicNetmask(pifr.netmask);
              }
  
              if (_host.getStoragePif1() != null) {
                  pif = PIF.getByUuid(conn, _host.getStoragePif1());
                  pifr = pif.getRecord(conn);
                  if (pifr.IP != null && !pifr.IP.isEmpty()) {
                      cmd.setStorageIpAddress(pifr.IP);
                      cmd.setStorageMacAddress(pifr.MAC);
                      cmd.setStorageNetmask(pifr.netmask);
                  }
              }
  
              if (_host.getStoragePif2() != null) {
                  pif = PIF.getByUuid(conn, _host.getStoragePif2());
                  pifr = pif.getRecord(conn);
                  if (pifr.IP != null && !pifr.IP.isEmpty()) {
                      cmd.setStorageIpAddressDeux(pifr.IP);
                      cmd.setStorageMacAddressDeux(pifr.MAC);
                      cmd.setStorageNetmaskDeux(pifr.netmask);
                  }
              }
  
              final Map<String, String> configs = hr.otherConfig;
              cmd.setIqn(configs.get("iscsi_iqn"));
  
              cmd.setPod(_pod);
              cmd.setVersion(CitrixResourceBase.class.getPackage().getImplementationVersion());
  
              try {
                  final String cmdLine = "xe sm-list | grep \"resigning of duplicates\"";
  
                  final XenServerUtilitiesHelper xenServerUtilitiesHelper = getXenServerUtilitiesHelper();
  
                  Pair<Boolean, String> result = xenServerUtilitiesHelper.executeSshWrapper(_host.getIp(), 22, _username, null, getPwdFromQueue(), cmdLine);
  
                  boolean supportsClonedVolumes = result != null && result.first() != null && result.first() && result.second() != null && !result.second().isEmpty();
  
                  cmd.setSupportsClonedVolumes(supportsClonedVolumes);
              } catch (NumberFormatException ex) {
                  logger.warn("Issue sending 'xe sm-list' via SSH to XenServer host: " + ex.getMessage());
              }
          } catch (final XmlRpcException e) {
              throw new CloudRuntimeException("XML RPC Exception: " + e.getMessage(), e);
          } catch (final XenAPIException e) {
              throw new CloudRuntimeException("XenAPIException: " + e, e);
          } catch (final Exception e) {
              throw new CloudRuntimeException("Exception: " + e, e);
          }
      }
  
      protected void syncPlatformAndCoresPerSocketSettings(String coresPerSocket, Map<String, String> platform) {
          if (org.apache.commons.lang3.StringUtils.isBlank(coresPerSocket) || platform == null) {
              return;
          }
          if (platform.containsKey(PLATFORM_CORES_PER_SOCKET_KEY)) {
              logger.debug("Updating the cores per socket value from: " + platform.get(PLATFORM_CORES_PER_SOCKET_KEY) + " to " + coresPerSocket);
          }
          platform.put(PLATFORM_CORES_PER_SOCKET_KEY, coresPerSocket);
      }
  
      protected void finalizeVmMetaData(final VM vm, final VM.Record vmr, final Connection conn, final VirtualMachineTO vmSpec) throws Exception {
  
          final Map<String, String> details = vmSpec.getDetails();
          if (details != null) {
              final String platformstring = details.get(VmDetailConstants.PLATFORM);
              final String coresPerSocket = details.get(VmDetailConstants.CPU_CORE_PER_SOCKET);
              if (platformstring != null && !platformstring.isEmpty()) {
                  final Map<String, String> platform = com.cloud.utils.StringUtils.stringToMap(platformstring);
                  syncPlatformAndCoresPerSocketSettings(coresPerSocket, platform);
                  vm.setPlatform(conn, platform);
              } else {
                  final String timeoffset = details.get(VmDetailConstants.TIME_OFFSET);
                  if (timeoffset != null) {
                      final Map<String, String> platform = vm.getPlatform(conn);
                      platform.put(VmDetailConstants.TIME_OFFSET, timeoffset);
                      vm.setPlatform(conn, platform);
                  }
                  if (coresPerSocket != null) {
                      final Map<String, String> platform = vm.getPlatform(conn);
                      syncPlatformAndCoresPerSocketSettings(coresPerSocket, platform);
                      vm.setPlatform(conn, platform);
                  }
              }
              if (!BootloaderType.CD.equals(vmSpec.getBootloader())) {
                  final String xenservertoolsversion = details.get(VmDetailConstants.HYPERVISOR_TOOLS_VERSION);
                  if ((xenservertoolsversion == null || !xenservertoolsversion.equalsIgnoreCase("xenserver61")) && vmSpec.getGpuDevice() == null) {
                      final Map<String, String> platform = vm.getPlatform(conn);
                      platform.remove("device_id");
                      vm.setPlatform(conn, platform);
                  }
              }
          }
  
          // Add configuration settings VM record for User VM instances before creating VM
          Map<String, String> extraConfig = vmSpec.getExtraConfig();
          if (vmSpec.getType().equals(VirtualMachine.Type.User) && MapUtils.isNotEmpty(extraConfig)) {
              logger.info("Appending user extra configuration settings [{}] to [{}].", extraConfig, vmSpec);
              ExtraConfigurationUtility.setExtraConfigurationToVm(conn,vmr, vm, extraConfig);
          }
      }
  
      protected void setVmBootDetails(final VM vm, final Connection conn, String bootType, String bootMode) throws XenAPIException, XmlRpcException {
          if (logger.isDebugEnabled()) {
              logger.debug(String.format("Setting boottype=%s and bootmode=%s for VM: %s", bootType, bootMode, vm.getUuid(conn)));
          }
          Boolean isSecure = bootType.equals(ApiConstants.BootType.UEFI.toString()) &&
                  ApiConstants.BootMode.SECURE.toString().equals(bootMode);
          final Map<String, String> bootParams = vm.getHVMBootParams(conn);
          bootParams.replace("firmware", bootType.toLowerCase());
          vm.setHVMBootParams(conn, bootParams);
          final Map<String, String> platform = vm.getPlatform(conn);
          platform.put("secureboot", isSecure.toString());
          vm.setPlatform(conn, platform);
      }
  
      /**
       * This method just creates a XenServer network following the tunnel network
       * naming convention
       */
      public synchronized Network findOrCreateTunnelNetwork(final Connection conn, final String nwName) {
          try {
              Network nw;
              final Network.Record rec = new Network.Record();
              final Set<Network> networks = Network.getByNameLabel(conn, nwName);
  
              if (networks.isEmpty()) {
                  rec.nameDescription = "tunnel network id# " + nwName;
                  rec.nameLabel = nwName;
                  // Initialize the ovs-host-setup to avoid error when doing
                  // get-param in plugin
                  final Map<String, String> otherConfig = new HashMap<>();
                  otherConfig.put("ovs-host-setup", "");
                  // Mark 'internal network' as shared so bridge gets
                  // automatically created on each host in the cluster
                  // when VM with vif connected to this internal network is
                  // started
                  otherConfig.put("assume_network_is_shared", "true");
                  rec.otherConfig = otherConfig;
                  rec.managed = true;
                  nw = Network.create(conn, rec);
                  logger.debug("### XenServer network for tunnels created:" + nwName);
              } else {
                  nw = networks.iterator().next();
                  logger.debug("XenServer network for tunnels found:" + nwName);
              }
              return nw;
          } catch (final Exception e) {
              logger.warn("createTunnelNetwork failed", e);
              return null;
          }
      }
  
      void forceShutdownVM(final Connection conn, final VM vm) {
          try {
              final Long domId = vm.getDomid(conn);
              callHostPlugin(conn, "vmopspremium", "forceShutdownVM", "domId", domId.toString());
              vm.powerStateReset(conn);
              destroyVm(vm, conn);
          } catch (final Exception e) {
              final String msg = "forceShutdown failed due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg);
          }
      }
  
      protected String generateTimeStamp() {
          return "CsCreateTime" + System.currentTimeMillis() + "-" + Rand.nextInt(Integer.MAX_VALUE);
      }
  
      @Override
      public IAgentControl getAgentControl() {
          return _agentControl;
      }
  
      protected String getArgsString(final Map<String, String> args) {
          final StringBuilder argString = new StringBuilder();
          for (final Map.Entry<String, String> arg : args.entrySet()) {
              argString.append(arg.getKey()).append(": ").append(arg.getValue()).append(", ");
          }
          return argString.toString();
      }
  
      @Override
      public Map<String, Object> getConfigParams() {
          return null;
      }
  
      public Connection getConnection() {
          return ConnPool.connect(_host.getUuid(), _host.getPool(), _host.getIp(), _username, _password, _wait);
      }
  
      protected Pair<VM, VM.Record> getControlDomain(final Connection conn) throws XenAPIException, XmlRpcException {
          final Host host = Host.getByUuid(conn, _host.getUuid());
          Set<VM> vms;
          vms = host.getResidentVMs(conn);
          for (final VM vm : vms) {
              if (vm.getIsControlDomain(conn)) {
                  return new Pair<>(vm, vm.getRecord(conn));
              }
          }
  
          throw new CloudRuntimeException("Com'on no control domain?  What the crap?!#@!##$@");
      }
  
      protected VIF getCorrectVif(final Connection conn, final VM router, final IpAddressTO ip) throws XmlRpcException, XenAPIException {
          final NicTO nic = new NicTO();
          nic.setType(ip.getTrafficType());
          nic.setName(ip.getNetworkName());
          if (ip.getBroadcastUri() == null) {
              nic.setBroadcastType(BroadcastDomainType.Native);
          } else {
              final URI uri = BroadcastDomainType.fromString(ip.getBroadcastUri());
              nic.setBroadcastType(BroadcastDomainType.getSchemeValue(uri));
              nic.setBroadcastUri(uri);
          }
          final Network network = getNetwork(conn, nic);
          // Determine the correct VIF on DomR to associate/disassociate the
          // IP address with
          final Set<VIF> routerVIFs = router.getVIFs(conn);
          for (final VIF vif : routerVIFs) {
              final Network vifNetwork = vif.getNetwork(conn);
              if (vifNetwork.getUuid(conn).equals(network.getUuid(conn))) {
                  return vif;
              }
          }
          return null;
      }
  
      protected VIF getCorrectVif(final Connection conn, final VM router, final Network network) throws XmlRpcException, XenAPIException {
          final Set<VIF> routerVIFs = router.getVIFs(conn);
          for (final VIF vif : routerVIFs) {
              final Network vifNetwork = vif.getNetwork(conn);
              if (vifNetwork.getUuid(conn).equals(network.getUuid(conn))) {
                  return vif;
              }
          }
  
          return null;
      }
  
      @Override
      public PingCommand getCurrentStatus(final long id) {
          try {
              if (!pingXAPI()) {
                  Thread.sleep(1000);
                  if (!pingXAPI()) {
                      logger.warn("can not ping xenserver " + _host.getUuid());
                      return null;
                  }
              }
              final Connection conn = getConnection();
              if (!_canBridgeFirewall && !_isOvs) {
                  return new PingRoutingCommand(getType(), id, getHostVmStateReport(conn));
              } else if (_isOvs) {
                  final List<Pair<String, Long>> ovsStates = ovsFullSyncStates();
                  return new PingRoutingWithOvsCommand(getType(), id, getHostVmStateReport(conn), ovsStates);
              } else {
                  final HashMap<String, Pair<Long, Long>> nwGrpStates = syncNetworkGroups(conn, id);
                  return new PingRoutingWithNwGroupsCommand(getType(), id, getHostVmStateReport(conn), nwGrpStates);
              }
          } catch (final Exception e) {
              logger.warn("Unable to get current status", e);
              return null;
          }
      }
  
      protected double getDataAverage(final Node dataNode, final int col, final int numRows) {
          double value = 0;
          final double dummy = 0;
          int numRowsUsed = 0;
          for (int row = 0; row < numRows; row++) {
              final Node data = dataNode.getChildNodes().item(numRows - 1 - row).getChildNodes().item(col + 1);
              final Double currentDataAsDouble = Double.valueOf(getXMLNodeValue(data));
              if (!currentDataAsDouble.equals(Double.NaN)) {
                  numRowsUsed += 1;
                  value += currentDataAsDouble;
              }
          }
  
          if (numRowsUsed == 0) {
              if (!Double.isInfinite(value) && !Double.isNaN(value)) {
                  return value;
              } else {
                  logger.warn("Found an invalid value (infinity/NaN) in getDataAverage(), numRows=0");
                  return dummy;
              }
          } else {
              if (!Double.isInfinite(value / numRowsUsed) && !Double.isNaN(value / numRowsUsed)) {
                  return value / numRowsUsed;
              } else {
                  logger.warn("Found an invalid value (infinity/NaN) in getDataAverage(), numRows>0");
                  return dummy;
              }
          }
  
      }
  
      public HashMap<String, HashMap<String, VgpuTypesInfo>> getGPUGroupDetails(final Connection conn) throws XenAPIException, XmlRpcException {
          return null;
      }
  
      protected String getGuestOsType(String platformEmulator) {
          if (StringUtils.isBlank(platformEmulator)) {
              logger.debug("no guest OS type, start it as HVM guest");
              platformEmulator = "Other install media";
          }
          return platformEmulator;
      }
  
      public XsHost getHost() {
          return _host;
      }
  
      public int getMigrateWait() {
          return _migratewait;
      }
  
      public StorageSubsystemCommandHandler getStorageHandler() {
          return storageHandler;
      }
  
      protected boolean getHostInfo(final Connection conn) throws IllegalArgumentException {
          try {
              final Host myself = Host.getByUuid(conn, _host.getUuid());
              Set<HostCpu> hcs = null;
              for (int i = 0; i < 10; i++) {
                  hcs = myself.getHostCPUs(conn);
                  if (hcs != null) {
                      _host.setCpus(hcs.size());
                      if (_host.getCpus() > 0) {
                          break;
                      }
                  }
                  Thread.sleep(5000);
              }
              if (_host.getCpus() <= 0) {
                  throw new CloudRuntimeException("Cannot get the numbers of cpu from XenServer host " + _host.getIp());
              }
              final Map<String, String> cpuInfo = myself.getCpuInfo(conn);
              if (cpuInfo.get("socket_count") != null) {
                  _host.setCpuSockets(Integer.parseInt(cpuInfo.get("socket_count")));
              }
              // would hcs be null we would have thrown an exception on condition
              // (_host.getCpus() <= 0) by now
              if (hcs != null) {
                  for (final HostCpu hc : hcs) {
                      _host.setSpeed(hc.getSpeed(conn).intValue());
                      break;
                  }
              }
              final Host.Record hr = myself.getRecord(conn);
              _host.setProductVersion(CitrixHelper.getProductVersion(hr));
  
              final XsLocalNetwork privateNic = getManagementNetwork(conn);
              _privateNetworkName = privateNic.getNetworkRecord(conn).nameLabel;
              _host.setPrivatePif(privateNic.getPifRecord(conn).uuid);
              _host.setPrivateNetwork(privateNic.getNetworkRecord(conn).uuid);
              _host.setSystemvmisouuid(null);
  
              XsLocalNetwork guestNic;
              if (_guestNetworkName != null && !_guestNetworkName.equals(_privateNetworkName)) {
                  guestNic = getNetworkByName(conn, _guestNetworkName);
                  if (guestNic == null) {
                      logger.warn("Unable to find guest network " + _guestNetworkName);
                      throw new IllegalArgumentException("Unable to find guest network " + _guestNetworkName + " for host " + _host.getIp());
                  }
              } else {
                  guestNic = privateNic;
                  _guestNetworkName = _privateNetworkName;
              }
              _host.setGuestNetwork(guestNic.getNetworkRecord(conn).uuid);
              _host.setGuestPif(guestNic.getPifRecord(conn).uuid);
  
              XsLocalNetwork publicNic;
              if (_publicNetworkName != null && !_publicNetworkName.equals(_guestNetworkName)) {
                  publicNic = getNetworkByName(conn, _publicNetworkName);
                  if (publicNic == null) {
                      logger.warn("Unable to find public network " + _publicNetworkName + " for host " + _host.getIp());
                      throw new IllegalArgumentException("Unable to find public network " + _publicNetworkName + " for host " + _host.getIp());
                  }
              } else {
                  publicNic = guestNic;
                  _publicNetworkName = _guestNetworkName;
              }
              _host.setPublicPif(publicNic.getPifRecord(conn).uuid);
              _host.setPublicNetwork(publicNic.getNetworkRecord(conn).uuid);
              if (_storageNetworkName1 == null) {
                  _storageNetworkName1 = _guestNetworkName;
              }
              XsLocalNetwork storageNic1;
              storageNic1 = getNetworkByName(conn, _storageNetworkName1);
              if (storageNic1 == null) {
                  logger.warn("Unable to find storage network " + _storageNetworkName1 + " for host " + _host.getIp());
                  throw new IllegalArgumentException("Unable to find storage network " + _storageNetworkName1 + " for host " + _host.getIp());
              } else {
                  _host.setStorageNetwork1(storageNic1.getNetworkRecord(conn).uuid);
                  _host.setStoragePif1(storageNic1.getPifRecord(conn).uuid);
              }
  
              XsLocalNetwork storageNic2;
              if (_storageNetworkName2 != null) {
                  storageNic2 = getNetworkByName(conn, _storageNetworkName2);
                  if (storageNic2 != null) {
                      _host.setStoragePif2(storageNic2.getPifRecord(conn).uuid);
                  }
              }
  
              logger.info("XenServer Version is " + _host.getProductVersion() + " for host " + _host.getIp());
              logger.info("Private Network is " + _privateNetworkName + " for host " + _host.getIp());
              logger.info("Guest Network is " + _guestNetworkName + " for host " + _host.getIp());
              logger.info("Public Network is " + _publicNetworkName + " for host " + _host.getIp());
  
              return true;
          } catch (final Exception e) {
              logger.warn("Unable to get host information for " + _host.getIp(), e);
              return false;
          }
      }
  
      public HostStatsEntry getHostStats(final Connection conn, final GetHostStatsCommand cmd, final String hostGuid, final long hostId) {
  
          final HostStatsEntry hostStats = new HostStatsEntry(hostId, 0, 0, 0, "host", 0, 0, 0, 0);
          final Object[] rrdData = getRRDData(conn, 1); // call rrd method with 1
          // for host
  
          if (rrdData == null) {
              return null;
          }
  
          final Integer numRows = (Integer)rrdData[0];
          final Integer numColumns = (Integer)rrdData[1];
          final Node legend = (Node)rrdData[2];
          final Node dataNode = (Node)rrdData[3];
  
          final NodeList legendChildren = legend.getChildNodes();
          for (int col = 0; col < numColumns; col++) {
  
              if (legendChildren == null || legendChildren.item(col) == null) {
                  continue;
              }
  
              final String columnMetadata = getXMLNodeValue(legendChildren.item(col));
  
              if (columnMetadata == null) {
                  continue;
              }
  
              final String[] columnMetadataList = columnMetadata.split(":");
  
              if (columnMetadataList.length != 4) {
                  continue;
              }
  
              final String type = columnMetadataList[1];
              final String param = columnMetadataList[3];
  
              if (type.equalsIgnoreCase("host")) {
  
                  if (param.matches("pif_eth0_rx")) {
                      hostStats.setNetworkReadKBs(getDataAverage(dataNode, col, numRows) / 1000);
                  } else if (param.matches("pif_eth0_tx")) {
                      hostStats.setNetworkWriteKBs(getDataAverage(dataNode, col, numRows) / 1000);
                  } else if (param.contains("memory_total_kib")) {
                      hostStats.setTotalMemoryKBs(getDataAverage(dataNode, col, numRows));
                  } else if (param.contains("memory_free_kib")) {
                      hostStats.setFreeMemoryKBs(getDataAverage(dataNode, col, numRows));
                  } else if (param.matches("cpu_avg")) {
                      // hostStats.setNumCpus(hostStats.getNumCpus() + 1);
                      hostStats.setCpuUtilization(hostStats.getCpuUtilization() + getDataAverage(dataNode, col, numRows));
                  }
  
                  /*
                   * if (param.contains("loadavg")) {
                   * hostStats.setAverageLoad((hostStats.getAverageLoad() +
                   * getDataAverage(dataNode, col, numRows))); }
                   */
              }
          }
  
          // add the host cpu utilization
          /*
           * if (hostStats.getNumCpus() != 0) {
           * hostStats.setCpuUtilization(hostStats.getCpuUtilization() /
           * hostStats.getNumCpus()); logger.debug("Host cpu utilization " +
           * hostStats.getCpuUtilization()); }
           */
  
          return hostStats;
      }
  
      protected HashMap<String, HostVmStateReportEntry> getHostVmStateReport(final Connection conn) {
          final HashMap<String, HostVmStateReportEntry> vmStates = new HashMap<>();
          Map<VM, VM.Record> vm_map = null;
          for (int i = 0; i < 2; i++) {
              try {
                  vm_map = VM.getAllRecords(conn);
                  break;
              } catch (final Throwable e) {
                  logger.warn("Unable to get vms", e);
              }
              try {
                  Thread.sleep(1000);
              } catch (final InterruptedException ignored) {
  
              }
          }
  
          if (vm_map == null) {
              return vmStates;
          }
          for (final VM.Record record : vm_map.values()) {
              if (record.isControlDomain || record.isASnapshot || record.isATemplate) {
                  continue; // Skip DOM0
              }
  
              final VmPowerState ps = record.powerState;
              final Host host = record.residentOn;
              String host_uuid;
              if (!isRefNull(host)) {
                  try {
                      host_uuid = host.getUuid(conn);
                      if (host_uuid.equalsIgnoreCase(_host.getUuid())) {
                          vmStates.put(record.nameLabel, new HostVmStateReportEntry(convertToPowerState(ps), host_uuid));
                      }
                  } catch (final XmlRpcException | XenAPIException e) {
                      logger.error("Failed to get host uuid for host " + host.toWireString(), e);
                  }
              }
          }
  
          return vmStates;
      }
  
      public SR getIscsiSR(final Connection conn, final String srNameLabel, final String target, String path, final String chapInitiatorUsername, final String chapInitiatorPassword,
              final boolean ignoreIntroduceException) {
  
          return getIscsiSR(conn, srNameLabel, target, path, chapInitiatorUsername, chapInitiatorPassword, false, SRType.LVMOISCSI.toString(), ignoreIntroduceException);
      }
  
      public SR getIscsiSR(final Connection conn, final String srNameLabel, final String target, String path, final String chapInitiatorUsername, final String chapInitiatorPassword,
              final boolean resignature, final boolean ignoreIntroduceException) {
  
          return getIscsiSR(conn, srNameLabel, target, path, chapInitiatorUsername, chapInitiatorPassword, resignature, SRType.LVMOISCSI.toString(), ignoreIntroduceException);
      }
  
      public SR getIscsiSR(final Connection conn, final String srNameLabel, final String target, String path, final String chapInitiatorUsername, final String chapInitiatorPassword,
              final boolean resignature, final String srType, final boolean ignoreIntroduceException) {
          synchronized (srNameLabel.intern()) {
              final Map<String, String> deviceConfig = new HashMap<>();
              try {
                  if (path.endsWith("/")) {
                      path = path.substring(0, path.length() - 1);
                  }
  
                  final String[] tmp = path.split("/");
                  if (tmp.length != 3) {
                      final String msg = "Wrong iscsi path " + path + " it should be /targetIQN/LUN";
                      logger.warn(msg);
                      throw new CloudRuntimeException(msg);
                  }
                  final String targetiqn = tmp[1].trim();
                  final String lunid = tmp[2].trim();
                  String scsiid;
  
                  //Throws an exception if SR already exists and is attached
                  checkIfIscsiSrExisits(conn, srNameLabel, target, targetiqn, lunid);
  
                  // We now know the SR is not attached to the XenServer. We probe the
                  // LUN to see if an SR was already exists on it, if so, we just
                  // attach it or else we create a brand new SR
  
                  deviceConfig.put("target", target);
                  deviceConfig.put("targetIQN", targetiqn);
  
                  if (StringUtils.isNoneBlank(chapInitiatorUsername, chapInitiatorPassword)) {
                      deviceConfig.put("chapuser", chapInitiatorUsername);
                      deviceConfig.put("chappassword", chapInitiatorPassword);
                  }
  
                  final Host host = Host.getByUuid(conn, _host.getUuid());
                  final Map<String, String> smConfig = new HashMap<>();
                  SR sr;
                  String pooluuid = null;
  
                  if (SRType.LVMOISCSI.equals(srType)) {
                      scsiid = probeScisiId(conn, host, deviceConfig, srType, srNameLabel, lunid, smConfig);
                      deviceConfig.put("SCSIid", scsiid);
  
                      String result = SR.probe(conn, host, deviceConfig, srType, smConfig);
                      if (result.contains("<UUID>")) {
                          pooluuid = result.substring(result.indexOf("<UUID>") + 6, result.indexOf("</UUID>")).trim();
                      }
                  }
  
                  if (pooluuid == null || pooluuid.length() != 36) {
                      sr = SR.create(conn, host, deviceConfig, 0L, srNameLabel, srNameLabel, srType, "user", true, smConfig);
                  } else {
                      if (resignature) {
                          // We resignature the SR for managed storage if needed. At the end of this
                          // we have an SR which is ready to be attached. For VHDoISCSI SR,
                          // we don't need to resignature
                          pooluuid = resignatureIscsiSr(conn, host, deviceConfig, srNameLabel, smConfig);
                      }
                      sr = introduceAndPlugIscsiSr(conn, pooluuid, srNameLabel, srType, smConfig, deviceConfig, ignoreIntroduceException);
                  }
  
                  sr.scan(conn);
                  return sr;
  
              } catch (final XenAPIException e) {
                  final String msg = "Unable to create Iscsi SR  " + deviceConfig + " due to  " + e;
                  logger.warn(msg, e);
                  throw new CloudRuntimeException(msg, e);
              } catch (final Exception e) {
                  final String msg = "Unable to create Iscsi SR  " + deviceConfig + " due to  " + e.getMessage();
                  logger.warn(msg, e);
                  throw new CloudRuntimeException(msg, e);
              }
          }
      }
  
      private SR introduceAndPlugIscsiSr(Connection conn, String pooluuid, String srNameLabel, String type, Map<String, String> smConfig, Map<String, String> deviceConfig,
              boolean ignoreIntroduceException) throws XmlRpcException, XenAPIException {
          SR sr = null;
          try {
              sr = SR.introduce(conn, pooluuid, srNameLabel, srNameLabel, type, "user", true, smConfig);
          } catch (final XenAPIException ex) {
              if (ignoreIntroduceException) {
                  return sr;
              }
  
              throw ex;
          }
  
          final Set<Host> setHosts = Host.getAll(conn);
  
          if (setHosts == null) {
              final String msg = "Unable to create iSCSI SR " + deviceConfig + " due to hosts not available.";
  
              logger.warn(msg);
  
              throw new CloudRuntimeException(msg);
          }
  
          for (final Host currentHost : setHosts) {
              final PBD.Record rec = new PBD.Record();
  
              rec.deviceConfig = deviceConfig;
              rec.host = currentHost;
              rec.SR = sr;
  
              final PBD pbd = PBD.create(conn, rec);
  
              pbd.plug(conn);
          }
  
          return sr;
      }
  
      private String resignatureIscsiSr(Connection conn, Host host, Map<String, String> deviceConfig, String srNameLabel, Map<String, String> smConfig) throws XmlRpcException, XenAPIException {
          String pooluuid;
  
          try {
              SR.create(conn, host, deviceConfig, 0L, srNameLabel, srNameLabel, SRType.RELVMOISCSI.toString(), "user", true, smConfig);
  
              // The successful outcome of SR.create (right above) is to throw an exception of type XenAPIException (with expected
              // toString() text) after resigning the metadata (we indicated to perform a resign by passing in SRType.RELVMOISCSI.toString()).
              // That being the case, if this CloudRuntimeException statement is executed, there appears to have been some kind
              // of failure in the execution of the above SR.create (resign) method.
              throw new CloudRuntimeException("Problem resigning the metadata");
          } catch (XenAPIException ex) {
              String msg = ex.toString();
  
              if (!msg.contains("successfully resigned")) {
                  throw ex;
              }
  
              String type = SRType.LVMOISCSI.toString();
              String result = SR.probe(conn, host, deviceConfig, type, smConfig);
  
              pooluuid = null;
  
              if (result.contains("<UUID>")) {
                  pooluuid = result.substring(result.indexOf("<UUID>") + 6, result.indexOf("</UUID>")).trim();
              }
  
              if (pooluuid == null || pooluuid.length() != 36) {
                  throw new CloudRuntimeException("Non-existent or invalid SR UUID");
              }
          }
  
          return pooluuid;
      }
  
      private void checkIfIscsiSrExisits(Connection conn, String srNameLabel, String target, String targetiqn, String lunid) throws XenAPIException, XmlRpcException {
          final Set<SR> srs = SR.getByNameLabel(conn, srNameLabel);
          for (final SR sr : srs) {
              if (!(SRType.LVMOISCSI.equals(sr.getType(conn)))) {
                  continue;
              }
              final Set<PBD> pbds = sr.getPBDs(conn);
              if (pbds.isEmpty()) {
                  continue;
              }
              final PBD pbd = pbds.iterator().next();
              final Map<String, String> dc = pbd.getDeviceConfig(conn);
              if (dc == null) {
                  continue;
              }
              if (dc.get("target") == null) {
                  continue;
              }
              if (dc.get("targetIQN") == null) {
                  continue;
              }
              if (dc.get("lunid") == null) {
                  continue;
              }
              if (target.equals(dc.get("target")) && targetiqn.equals(dc.get("targetIQN")) && lunid.equals(dc.get("lunid"))) {
                  throw new CloudRuntimeException("There is a SR using the same configuration target:" + dc.get("target") + ",  targetIQN:" + dc.get("targetIQN") + ", lunid:" + dc.get("lunid")
                  + " for pool " + srNameLabel + "on host:" + _host.getUuid());
              }
          }
  
      }
  
      private String probeScisiId(Connection conn, Host host, Map<String, String> deviceConfig, String type, String srNameLabel, String lunid, Map<String, String> smConfig)
              throws XenAPIException, XmlRpcException {
          String scsiid = null;
  
          try {
              SR.create(conn, host, deviceConfig, 0L, srNameLabel, srNameLabel, type, "user", true, smConfig);
          } catch (final XenAPIException e) {
              final String errmsg = e.toString();
              if (errmsg.contains("SR_BACKEND_FAILURE_107")) {
                  final String[] lun = errmsg.split("<LUN>");
                  boolean found = false;
                  for (int i = 1; i < lun.length; i++) {
                      final int blunindex = lun[i].indexOf("<LUNid>") + 7;
                      final int elunindex = lun[i].indexOf("</LUNid>");
                      String ilun = lun[i].substring(blunindex, elunindex);
                      ilun = ilun.trim();
                      if (ilun.equals(lunid)) {
                          final int bscsiindex = lun[i].indexOf("<SCSIid>") + 8;
                          final int escsiindex = lun[i].indexOf("</SCSIid>");
                          scsiid = lun[i].substring(bscsiindex, escsiindex);
                          scsiid = scsiid.trim();
                          found = true;
                          break;
                      }
                  }
                  if (!found) {
                      final String msg = "can not find LUN " + lunid + " in " + errmsg;
                      logger.warn(msg);
                      throw new CloudRuntimeException(msg);
                  }
              } else {
                  final String msg = "Unable to create Iscsi SR  " + deviceConfig + " due to  " + e;
                  logger.warn(msg, e);
                  throw new CloudRuntimeException(msg, e);
              }
          }
          return scsiid;
      }
  
      public SR getISOSRbyVmName(final Connection conn, final String vmName, boolean isConfigDrive) {
          try {
              final Set<SR> srs = SR.getByNameLabel(conn, vmName +
                      (isConfigDrive ? VM_NAME_CONFIGDRIVE_ISO_SUFFIX : VM_NAME_ISO_SUFFIX));
              if (srs.isEmpty()) {
                  return null;
              } else if (srs.size() == 1) {
                  return srs.iterator().next();
              } else {
                  final String msg = "getIsoSRbyVmName failed due to there are more than 1 SR having same Label";
                  logger.warn(msg);
              }
          } catch (final XenAPIException e) {
              final String msg = "getIsoSRbyVmName failed due to " + e;
              logger.warn(msg, e);
          } catch (final Exception e) {
              final String msg = "getIsoSRbyVmName failed due to " + e.getMessage();
              logger.warn(msg, e);
          }
          return null;
      }
  
      public VDI getIsoVDIByURL(final Connection conn, final String vmName, final String isoURL) {
          SR isoSR;
          String mountpoint;
          if (isoURL.startsWith("xs-tools")) {
              try {
                  final String actualIsoURL = getActualIsoTemplate(conn);
                  final Set<VDI> vdis = VDI.getByNameLabel(conn, actualIsoURL);
                  if (vdis.isEmpty()) {
                      throw new CloudRuntimeException("Could not find ISO with URL: " + actualIsoURL);
                  }
                  return vdis.iterator().next();
  
              } catch (final Exception e) {
                  throw new CloudRuntimeException("Unable to get pv iso: " + isoURL + " due to " + e);
              }
          }
  
          final int index = isoURL.lastIndexOf("/");
          mountpoint = isoURL.substring(0, index);
  
          URI uri;
          try {
              uri = new URI(mountpoint);
          } catch (final URISyntaxException e) {
              throw new CloudRuntimeException("isoURL is wrong: " + isoURL);
          }
          isoSR = getISOSRbyVmName(conn, vmName, false);
          if (isoSR == null) {
              isoSR = createIsoSRbyURI(conn, uri, vmName, false);
          } else {
              try {
                  String description = isoSR.getNameDescription(conn);
                  if (description.endsWith(ConfigDrive.CONFIGDRIVEDIR)) {
                      throw new CloudRuntimeException(String.format("VM %s already has %s ISO attached. Please " +
                              "stop-start VM to allow attaching-detaching both ISOs", vmName, ConfigDrive.CONFIGDRIVEDIR));
                  }
              } catch (XenAPIException | XmlRpcException e) {
                  throw new CloudRuntimeException(String.format("Unable to retrieve name description for the already " +
                          "attached ISO on VM %s", vmName));
              }
          }
  
          final String isoName = isoURL.substring(index + 1);
  
          final VDI isoVDI = getVDIbyLocationandSR(conn, isoName, isoSR);
  
          if (isoVDI != null) {
              return isoVDI;
          } else {
              throw new CloudRuntimeException("Could not find ISO with URL: " + isoURL);
          }
      }
  
      /**
       * Retrieve the actual ISO 'name-label' to be used.
       * We based our decision on XenServer version.
       * <ul>
       *  <li> for XenServer 7.0+, we use {@value #XS_TOOLS_ISO_AFTER_70};
       *  <li> for versions before 7.0, we use {@value TemplateManager#XS_TOOLS_ISO}.
       * </ul>
       *
       */
      protected String getActualIsoTemplate(Connection conn) throws XenAPIException, XmlRpcException {
          Host host = Host.getByUuid(conn, _host.getUuid());
          Host.Record record = host.getRecord(conn);
          String xenBrand = record.softwareVersion.get("product_brand");
          String xenVersion = record.softwareVersion.get("product_version");
          String[] items = xenVersion.split("\\.");
  
          if ((xenBrand.equals("XenServer") || xenBrand.equals("XCP-ng")) && Integer.parseInt(items[0]) >= 7) {
              return XS_TOOLS_ISO_AFTER_70;
          }
          return TemplateManager.XS_TOOLS_ISO;
      }
  
      public String getLabel() {
          final Connection conn = getConnection();
          return callHostPlugin(conn, "ovstunnel", "getLabel");
      }
  
      public String getLowestAvailableVIFDeviceNum(final Connection conn, final VM vm) {
          String vmName = "";
          try {
              vmName = vm.getNameLabel(conn);
              final List<Integer> usedDeviceNums = new ArrayList<>();
              final Set<VIF> vifs = vm.getVIFs(conn);
              final Iterator<VIF> vifIter = vifs.iterator();
              while (vifIter.hasNext()) {
                  final VIF vif = vifIter.next();
                  try {
                      final String deviceId = vif.getDevice(conn);
                      if (vm.getIsControlDomain(conn) || vif.getCurrentlyAttached(conn)) {
                          usedDeviceNums.add(Integer.valueOf(deviceId));
                      } else {
                          logger.debug("Found unplugged VIF " + deviceId + " in VM " + vmName + " destroy it");
                          vif.destroy(conn);
                      }
                  } catch (final NumberFormatException e) {
                      final String msg = "Obtained an invalid value for an allocated VIF device number for VM: " + vmName;
                      logger.debug(msg, e);
                      throw new CloudRuntimeException(msg);
                  }
              }
  
              for (Integer i = 0; i < _maxNics; i++) {
                  if (!usedDeviceNums.contains(i)) {
                      logger.debug("Lowest available Vif device number: " + i + " for VM: " + vmName);
                      return i.toString();
                  }
              }
          } catch (final XmlRpcException e) {
              final String msg = "Caught XmlRpcException: " + e.getMessage();
              logger.warn(msg, e);
          } catch (final XenAPIException e) {
              final String msg = "Caught XenAPIException: " + e;
              logger.warn(msg, e);
          }
  
          throw new CloudRuntimeException("Could not find available VIF slot in VM with name: " + vmName);
      }
  
      protected XsLocalNetwork getManagementNetwork(final Connection conn) throws XmlRpcException, XenAPIException {
          PIF mgmtPif = null;
          PIF.Record mgmtPifRec = null;
          final Host host = Host.getByUuid(conn, _host.getUuid());
          final Set<PIF> hostPifs = host.getPIFs(conn);
          for (final PIF pif : hostPifs) {
              final PIF.Record rec = pif.getRecord(conn);
              if (rec.management) {
                  if (rec.VLAN != null && rec.VLAN != -1) {
                      final String msg = "Unsupported configuration.  Management network is on a VLAN.  host=" + _host.getUuid() + "; pif=" + rec.uuid +
                              "; vlan=" + rec.VLAN;
                      logger.warn(msg);
                      throw new CloudRuntimeException(msg);
                  }
                  if (logger.isDebugEnabled()) {
                      logger.debug("Management network is on pif=" + rec.uuid);
                  }
                  mgmtPif = pif;
                  mgmtPifRec = rec;
                  break;
              }
          }
          if (mgmtPif == null) {
              final String msg = "Unable to find management network for " + _host.getUuid();
              logger.warn(msg);
              throw new CloudRuntimeException(msg);
          }
          final Bond bond = mgmtPifRec.bondSlaveOf;
          if (!isRefNull(bond)) {
              final String msg = "Management interface is on slave(" + mgmtPifRec.uuid + ") of bond(" + bond.getUuid(conn) + ") on host(" + _host.getUuid()
              + "), please move management interface to bond!";
              logger.warn(msg);
              throw new CloudRuntimeException(msg);
          }
          final Network nk = mgmtPifRec.network;
          final Network.Record nkRec = nk.getRecord(conn);
          return new XsLocalNetwork(this, nk, nkRec, mgmtPif, mgmtPifRec);
      }
  
      @Override
      public String getName() {
          return _name;
      }
  
      public XsLocalNetwork getNativeNetworkForTraffic(final Connection conn, final TrafficType type, final String name) throws XenAPIException, XmlRpcException {
          if (name != null) {
              if (logger.isDebugEnabled()) {
                  logger.debug("Looking for network named " + name);
              }
              return getNetworkByName(conn, name);
          }
  
          if (type == TrafficType.Guest) {
              return new XsLocalNetwork(this, Network.getByUuid(conn, _host.getGuestNetwork()), null, PIF.getByUuid(conn, _host.getGuestPif()), null);
          } else if (type == TrafficType.Control) {
              setupLinkLocalNetwork(conn);
              return new XsLocalNetwork(this, Network.getByUuid(conn, _host.getLinkLocalNetwork()));
          } else if (type == TrafficType.Management) {
              return new XsLocalNetwork(this, Network.getByUuid(conn, _host.getPrivateNetwork()), null, PIF.getByUuid(conn, _host.getPrivatePif()), null);
          } else if (type == TrafficType.Public) {
              return new XsLocalNetwork(this, Network.getByUuid(conn, _host.getPublicNetwork()), null, PIF.getByUuid(conn, _host.getPublicPif()), null);
          } else if (type == TrafficType.Storage) {
              /*
               * TrafficType.Storage is for secondary storage, while
               * storageNetwork1 is for primary storage, we need better name here
               */
              return new XsLocalNetwork(this, Network.getByUuid(conn, _host.getStorageNetwork1()), null, PIF.getByUuid(conn, _host.getStoragePif1()), null);
          }
  
          throw new CloudRuntimeException("Unsupported network type: " + type);
      }
  
      public Network getNetwork(final Connection conn, final NicTO nic) throws XenAPIException, XmlRpcException {
          final String name = nic.getName();
          final XsLocalNetwork network = getNativeNetworkForTraffic(conn, nic.getType(), name);
          if (network == null) {
              logger.error("Network is not configured on the backend for nic " + nic);
              throw new CloudRuntimeException("Network for the backend is not configured correctly for network broadcast domain: " + nic.getBroadcastUri());
          }
          final URI uri = nic.getBroadcastUri();
          final BroadcastDomainType type = nic.getBroadcastType();
          if (uri != null && uri.toString().contains("untagged")) {
              return network.getNetwork();
          } else if (uri != null && type == BroadcastDomainType.Vlan) {
              assert BroadcastDomainType.getSchemeValue(uri) == BroadcastDomainType.Vlan;
              final long vlan = Long.parseLong(BroadcastDomainType.getValue(uri));
              return enableVlanNetwork(conn, vlan, network);
          } else if (type == BroadcastDomainType.Native || type == BroadcastDomainType.LinkLocal) {
              return network.getNetwork();
          } else if (uri != null && type == BroadcastDomainType.Vswitch) {
              final String header = uri.toString().substring(Networks.BroadcastDomainType.Vswitch.scheme().length() + "://".length());
              if (header.startsWith("vlan")) {
                  _isOvs = true;
                  return setupvSwitchNetwork(conn);
              } else {
                  return findOrCreateTunnelNetwork(conn, getOvsTunnelNetworkName(uri.getAuthority()));
              }
          } else if (type == BroadcastDomainType.Storage) {
              if (uri == null) {
                  return network.getNetwork();
              } else {
                  final long vlan = Long.parseLong(BroadcastDomainType.getValue(uri));
                  return enableVlanNetwork(conn, vlan, network);
              }
          } else if (type == BroadcastDomainType.Lswitch) {
              // Nicira Logical Switch
              return network.getNetwork();
          } else if (uri != null && type == BroadcastDomainType.Pvlan) {
              assert BroadcastDomainType.getSchemeValue(uri) == BroadcastDomainType.Pvlan;
              // should we consider moving this NetUtils method to
              // BroadcastDomainType?
              final long vlan = Long.parseLong(NetUtils.getPrimaryPvlanFromUri(uri));
              return enableVlanNetwork(conn, vlan, network);
          }
  
          throw new CloudRuntimeException("Unable to support this type of network broadcast domain: " + nic.getBroadcastUri());
      }
  
      /**
       * getNetworkByName() retrieves what the server thinks is the actual network
       * used by the XenServer host. This method should always be used to talk to
       * retrieve a network by the name. The reason is because of the problems in
       * using the name label as the way to find the Network.
       *
       * To see how we are working around these problems, take a look at
       * enableVlanNetwork(). The following description assumes you have looked at
       * the description on that method.
       *
       * In order to understand this, we have to see what type of networks are
       * within a XenServer that's under CloudStack control.
       *
       * - Native Networks: these are networks that are untagged on the XenServer
       * and are used to crate VLAN networks on. These are created by the user and
       * is assumed to be one per cluster. - VLAN Networks: these are dynamically
       * created by CloudStack and can have problems with duplicated names. -
       * LinkLocal Networks: these are dynamically created by CloudStack and can
       * also have problems with duplicated names but these don't have actual
       * PIFs.
       *
       * In order to speed to retrieval of a network, we do the following: - We
       * retrieve by the name. If only one network is retrieved, we assume we
       * retrieved the right network. - If more than one network is retrieved, we
       * check to see which one has the pif for the local host and use that. - If
       * a pif is not found, then we look at the tags and find the one with the
       * lowest timestamp. (See enableVlanNetwork())
       *
       * @param conn
       *            Xapi connection
       * @param name
       *            name of the network
       * @return XsNic an object that contains network, network record, pif, and
       *         pif record.
       * @throws XenAPIException
       * @throws XmlRpcException
       *
       * @see CitrixResourceBase#enableVlanNetwork
       */
      public XsLocalNetwork getNetworkByName(final Connection conn, final String name) throws XenAPIException, XmlRpcException {
          final Set<Network> networks = Network.getByNameLabel(conn, name);
          if (networks.size() == 1) {
              return new XsLocalNetwork(this, networks.iterator().next(), null, null, null);
          }
  
          if (networks.isEmpty()) {
              return null;
          }
  
          if (logger.isDebugEnabled()) {
              logger.debug("Found more than one network with the name " + name);
          }
          Network earliestNetwork = null;
          Network.Record earliestNetworkRecord = null;
          long earliestTimestamp = Long.MAX_VALUE;
          int earliestRandom = Integer.MAX_VALUE;
          for (final Network network : networks) {
              final XsLocalNetwork nic = new XsLocalNetwork(this, network);
  
              if (nic.getPif(conn) != null) {
                  return nic;
              }
  
              final Network.Record record = network.getRecord(conn);
              if (record.tags != null) {
                  for (final String tag : record.tags) {
                      final Pair<Long, Integer> stamp = parseTimestamp(tag);
                      if (stamp == null) {
                          continue;
                      }
  
                      if (stamp.first() < earliestTimestamp || stamp.first() == earliestTimestamp && stamp.second() < earliestRandom) {
                          earliestTimestamp = stamp.first();
                          earliestRandom = stamp.second();
                          earliestNetwork = network;
                          earliestNetworkRecord = record;
                      }
                  }
              }
          }
  
          return earliestNetwork != null ? new XsLocalNetwork(this, earliestNetwork, earliestNetworkRecord, null, null) : null;
      }
  
      public long[] getNetworkStats(final Connection conn, final String privateIP, final String publicIp) {
          final String result = networkUsage(conn, privateIP, "get", null, publicIp);
          final long[] stats = new long[2];
          if (result != null) {
              final String[] splitResult = result.split(":");
              int i = 0;
              while (i < splitResult.length - 1) {
                  stats[0] += Long.parseLong(splitResult[i++]);
                  stats[1] += Long.parseLong(splitResult[i++]);
              }
          }
          return stats;
      }
  
      public long[] getVPCNetworkStats(final String privateIP, final String publicIp) {
          String args = " -l " + publicIp + " -g";
          final ExecutionResult result = executeInVR(privateIP, "vpc_netusage.sh", args);
          final String detail = result.getDetails();
          final long[] stats = new long[2];
          if (detail != null) {
              final String[] splitResult = detail.split(":");
              int i = 0;
              while (i < splitResult.length - 1) {
                  stats[0] += Long.parseLong(splitResult[i++]);
                  stats[1] += Long.parseLong(splitResult[i++]);
              }
          }
          return stats;
      }
  
      public long[] getNetworkLbStats(final String privateIp, final String publicIp, final Integer port) {
          String args = publicIp + " " + port;
          ExecutionResult callResult = executeInVR(privateIp, "get_haproxy_stats.sh", args);
          String detail = callResult.getDetails();
          if (detail == null || detail.isEmpty()) {
              logger.error("Get network loadbalancer stats returns empty result");
          }
          final long[] stats = new long[1];
          if (detail != null) {
              final String[] splitResult = detail.split(",");
              stats[0] += Long.parseLong(splitResult[0]);
          }
          return stats;
      }
  
      public SR getNfsSR(final Connection conn, final String poolid, final String uuid, final String server, String serverpath, final String pooldesc) {
          final Map<String, String> deviceConfig = new HashMap<>();
          try {
              serverpath = serverpath.replace("//", "/");
              final Set<SR> srs = SR.getAll(conn);
              if (srs != null && !srs.isEmpty()) {
                  for (final SR sr : srs) {
                      if (!SRType.NFS.equals(sr.getType(conn))) {
                          continue;
                      }
  
                      final Set<PBD> pbds = sr.getPBDs(conn);
                      if (pbds.isEmpty()) {
                          continue;
                      }
  
                      final PBD pbd = pbds.iterator().next();
  
                      final Map<String, String> dc = pbd.getDeviceConfig(conn);
  
                      if (dc == null) {
                          continue;
                      }
  
                      if (dc.get("server") == null) {
                          continue;
                      }
  
                      if (dc.get("serverpath") == null) {
                          continue;
                      }
  
                      if (server.equals(dc.get("server")) && serverpath.equals(dc.get("serverpath"))) {
                          throw new CloudRuntimeException(
                                  "There is a SR using the same configuration server:" + dc.get("server") + ", serverpath:" + dc.get("serverpath") + " for pool " + uuid + " on host:" + _host.getUuid());
                      }
  
                  }
              }
              deviceConfig.put("server", server);
              deviceConfig.put("serverpath", serverpath);
              final Host host = Host.getByUuid(conn, _host.getUuid());
              final Map<String, String> smConfig = new HashMap<>();
              smConfig.put("nosubdir", "true");
              final SR sr = SR.create(conn, host, deviceConfig, 0L, uuid, poolid, SRType.NFS.toString(), "user", true, smConfig);
              sr.scan(conn);
              return sr;
          } catch (final XenAPIException | XmlRpcException e) {
              throw new CloudRuntimeException("Unable to create NFS SR " + pooldesc, e);
          }
      }
  
      private String getOvsTunnelNetworkName(final String broadcastUri) {
          if (broadcastUri.contains(".")) {
              final String[] parts = broadcastUri.split("\\.");
              return "OVS-DR-VPC-Bridge" + parts[0];
          } else {
              try {
                  return "OVSTunnel" + broadcastUri;
              } catch (final Exception e) {
                  return null;
              }
          }
      }
  
      protected List<File> getPatchFiles() {
          String patch = getPatchFilePath();
          String patchfilePath = Script.findScript("", patch);
          if (patchfilePath == null) {
              throw new CloudRuntimeException("Unable to find patch file " + patch);
          }
          List<File> files = new ArrayList<>();
          files.add(new File(patchfilePath));
          return files;
      }
  
      protected abstract String getPatchFilePath();
  
      public String getPerfMon(final Connection conn, final Map<String, String> params, final int wait) {
          String result;
          try {
              result = callHostPluginAsync(conn, "vmopspremium", "asmonitor", 60, params);
              if (result != null) {
                  return result;
              }
          } catch (final Exception e) {
              logger.error("Can not get performance monitor for AS due to ", e);
          }
          return null;
      }
  
      protected Object[] getRRDData(final Connection conn, final int flag) {
  
          /*
           * Note: 1 => called from host, hence host stats 2 => called from vm,
           * hence vm stats
           */
          Document doc;
  
          try {
              doc = getStatsRawXML(conn, flag == 1);
          } catch (final Exception e1) {
              logger.warn("Error whilst collecting raw stats from plugin: ", e1);
              return null;
          }
  
          if (doc == null) { // stats are null when the host plugin call fails
              // (host down state)
              return null;
          }
  
          final NodeList firstLevelChildren = doc.getChildNodes();
          final NodeList secondLevelChildren = firstLevelChildren.item(0).getChildNodes();
          final Node metaNode = secondLevelChildren.item(0);
          final Node dataNode = secondLevelChildren.item(1);
  
          Integer numRows = 0;
          Integer numColumns = 0;
          Node legend = null;
          final NodeList metaNodeChildren = metaNode.getChildNodes();
          for (int i = 0; i < metaNodeChildren.getLength(); i++) {
              final Node n = metaNodeChildren.item(i);
              switch (n.getNodeName()) {
                  case "rows":
                      numRows = Integer.valueOf(getXMLNodeValue(n));
                      break;
                  case "columns":
                      numColumns = Integer.valueOf(getXMLNodeValue(n));
                      break;
                  case "legend":
                      legend = n;
                      break;
              }
          }
  
          return new Object[] {numRows, numColumns, legend, dataNode};
      }
  
      @Override
      public int getRunLevel() {
          return 0;
      }
  
      protected SR getSRByNameLabelandHost(final Connection conn, final String name) throws XenAPIException, XmlRpcException {
          final Set<SR> srs = SR.getByNameLabel(conn, name);
          SR ressr = null;
          for (final SR sr : srs) {
              Set<PBD> pbds;
              pbds = sr.getPBDs(conn);
              for (final PBD pbd : pbds) {
                  final PBD.Record pbdr = pbd.getRecord(conn);
                  if (pbdr.host != null && pbdr.host.getUuid(conn).equals(_host.getUuid())) {
                      if (!pbdr.currentlyAttached) {
                          pbd.plug(conn);
                      }
                      ressr = sr;
                      break;
                  }
              }
          }
          return ressr;
      }
  
      private long getStaticMax(final String os, final boolean b, final long dynamicMinRam, final long dynamicMaxRam, final long recommendedValue) {
          if (recommendedValue == 0) {
              logger.warn("No recommended value found for dynamic max, setting static max and dynamic max equal");
              return dynamicMaxRam;
          }
          final long staticMax = Math.min(recommendedValue, 4L * dynamicMinRam); // XS
          // constraint
          // for
          // stability
          if (dynamicMaxRam > staticMax) { // XS constraint that dynamic max <=
              // static max
              logger.warn("dynamic max " + toHumanReadableSize(dynamicMaxRam) + " can't be greater than static max " + toHumanReadableSize(staticMax) + ", this can lead to stability issues. Setting static max as much as dynamic max ");
              return dynamicMaxRam;
          }
          return staticMax;
      }
  
      private long getStaticMin(final String os, final boolean b, final long dynamicMinRam, final long dynamicMaxRam, final long recommendedValue) {
          if (recommendedValue == 0) {
              logger.warn("No recommended value found for dynamic min");
              return dynamicMinRam;
          }
  
          if (dynamicMinRam < recommendedValue) { // XS constraint that dynamic min
              // > static min
              logger.warn("Vm ram is set to dynamic min " + toHumanReadableSize(dynamicMinRam) + " and is less than the recommended static min " + toHumanReadableSize(recommendedValue) + ", this could lead to stability issues");
          }
          return dynamicMinRam;
      }
  
      protected Document getStatsRawXML(final Connection conn, final boolean host) {
          final Date currentDate = new Date();
          String urlStr = "http://" + _host.getIp() + "/rrd_updates?";
          urlStr += "session_id=" + conn.getSessionReference();
          urlStr += "&host=" + (host ? "true" : "false");
          urlStr += "&cf=" + _consolidationFunction;
          urlStr += "&interval=" + _pollingIntervalInSeconds;
          urlStr += "&start=" + (currentDate.getTime() / 1000 - 1000 - 100);
  
          URL url;
          BufferedReader in = null;
          try {
              url = new URL(urlStr);
              url.openConnection();
              final URLConnection uc = url.openConnection();
              in = new BufferedReader(new InputStreamReader(uc.getInputStream()));
              final InputSource statsSource = new InputSource(in);
              return ParserUtils.getSaferDocumentBuilderFactory().newDocumentBuilder().parse(statsSource);
          } catch (final MalformedURLException e) {
              logger.warn("Malformed URL?  come on...." + urlStr);
              return null;
          } catch (final IOException | ParserConfigurationException | SAXException e) {
              logger.warn("Problems getting stats using " + urlStr, e);
              return null;
          } finally {
              if (in != null) {
                  try {
                      in.close();
                  } catch (final IOException e) {
                      logger.warn("Unable to close the buffer ", e);
                  }
              }
          }
      }
  
      public SR getStorageRepository(final Connection conn, final String srNameLabel) {
          Set<SR> srs;
          try {
              srs = SR.getByNameLabel(conn, srNameLabel);
          } catch (final XenAPIException e) {
              throw new CloudRuntimeException("Unable to get SR " + srNameLabel + " due to " + e, e);
          } catch (final Exception e) {
              throw new CloudRuntimeException("Unable to get SR " + srNameLabel + " due to " + e.getMessage(), e);
          }
  
          if (srs.size() > 1) {
              throw new CloudRuntimeException("More than one storage repository was found for pool with uuid: " + srNameLabel);
          } else if (srs.size() == 1) {
              final SR sr = srs.iterator().next();
              if (logger.isDebugEnabled()) {
                  logger.debug("SR retrieved for " + srNameLabel);
              }
  
              if (checkSR(conn, sr)) {
                  return sr;
              }
              throw new CloudRuntimeException("SR check failed for storage pool: " + srNameLabel + "on host:" + _host.getUuid());
          } else {
              throw new CloudRuntimeException("Can not see storage pool: " + srNameLabel + " from on host:" + _host.getUuid());
          }
      }
  
      protected Storage.StorageResourceType getStorageResourceType() {
          return Storage.StorageResourceType.STORAGE_POOL;
      }
  
      @Override
      public Type getType() {
          return com.cloud.host.Host.Type.Routing;
      }
  
      protected VDI getVDIbyLocationandSR(final Connection conn, final String loc, final SR sr) {
          try {
              final Set<VDI> vdis = sr.getVDIs(conn);
              for (final VDI vdi : vdis) {
                  if (vdi.getLocation(conn).startsWith(loc)) {
                      return vdi;
                  }
              }
  
              final String msg = "can not getVDIbyLocationandSR " + loc;
              logger.warn(msg);
              return null;
          } catch (final XenAPIException e) {
              final String msg = "getVDIbyLocationandSR exception " + loc + " due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          } catch (final Exception e) {
              final String msg = "getVDIbyLocationandSR exception " + loc + " due to " + e.getMessage();
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          }
  
      }
  
      public VDI getVDIbyUuid(final Connection conn, final String uuid) {
          return getVDIbyUuid(conn, uuid, true);
      }
  
      public VDI getVDIbyUuid(final Connection conn, final String uuid, final boolean throwExceptionIfNotFound) {
          try {
              return VDI.getByUuid(conn, uuid);
          } catch (final Exception e) {
              if (throwExceptionIfNotFound) {
                  final String msg = "Catch Exception " + e.getClass().getName() + " :VDI getByUuid for uuid: " + uuid + " failed due to " + e;
  
                  logger.debug(msg);
  
                  throw new CloudRuntimeException(msg, e);
              }
  
              return null;
          }
      }
  
      public String getVhdParent(final Connection conn, final String primaryStorageSRUuid, final String snapshotUuid, final Boolean isISCSI) {
          final String parentUuid = callHostPlugin(conn, "vmopsSnapshot", "getVhdParent", "primaryStorageSRUuid", primaryStorageSRUuid, "snapshotUuid", snapshotUuid, "isISCSI", isISCSI.toString());
  
          if (parentUuid == null || parentUuid.isEmpty() || parentUuid.equalsIgnoreCase("None")) {
              logger.debug("Unable to get parent of VHD " + snapshotUuid + " in SR " + primaryStorageSRUuid);
              // errString is already logged.
              return null;
          }
          return parentUuid;
      }
  
      public VIF getVifByMac(final Connection conn, final VM router, String mac) throws XmlRpcException, XenAPIException {
          final Set<VIF> routerVIFs = router.getVIFs(conn);
          mac = mac.trim();
          for (final VIF vif : routerVIFs) {
              final String lmac = vif.getMAC(conn);
              if (lmac.trim().equals(mac)) {
                  return vif;
              }
          }
          return null;
      }
  
      public VirtualRoutingResource getVirtualRoutingResource() {
          return _vrResource;
      }
  
      public VM getVM(final Connection conn, final String vmName) {
          // Look up VMs with the specified name
          Set<VM> vms;
          try {
              vms = VM.getByNameLabel(conn, vmName);
          } catch (final XenAPIException e) {
              throw new CloudRuntimeException("Unable to get " + vmName + ": " + e, e);
          } catch (final Exception e) {
              throw new CloudRuntimeException("Unable to get " + vmName + ": " + e.getMessage(), e);
          }
  
          // If there are no VMs, throw an exception
          if (vms.isEmpty()) {
              throw new CloudRuntimeException("VM with name: " + vmName + " does not exist.");
          }
  
          // If there is more than one VM, print a warning
          if (vms.size() > 1) {
              logger.warn("Found " + vms.size() + " VMs with name: " + vmName);
          }
  
          // Return the first VM in the set
          return vms.iterator().next();
      }
  
      public String getVMInstanceName() {
          return _instance;
      }
  
      public long getVMSnapshotChainSize(final Connection conn, final VolumeObjectTO volumeTo, final String vmName, final String vmSnapshotName)
              throws XenAPIException, XmlRpcException {
          if (volumeTo.getVolumeType() == Volume.Type.DATADISK) {
              final VDI dataDisk = VDI.getByUuid(conn, volumeTo.getPath());
              if (dataDisk != null) {
                  final String dataDiskName = dataDisk.getNameLabel(conn);
                  if (dataDiskName != null && !dataDiskName.isEmpty()) {
                      volumeTo.setName(dataDiskName);
                  }
              }
          }
          final Set<VDI> allvolumeVDIs = VDI.getByNameLabel(conn, volumeTo.getName());
          long size = 0;
          for (final VDI vdi : allvolumeVDIs) {
              try {
                  if (vdi.getIsASnapshot(conn) && vdi.getSmConfig(conn).get("vhd-parent") != null) {
                      final String parentUuid = vdi.getSmConfig(conn).get("vhd-parent");
                      final VDI parentVDI = VDI.getByUuid(conn, parentUuid);
                      // add size of snapshot vdi node, usually this only contains
                      // meta data
                      size = size + vdi.getPhysicalUtilisation(conn);
                      // add size of snapshot vdi parent, this contains data
                      if (!isRefNull(parentVDI)) {
                          size = size + parentVDI.getPhysicalUtilisation(conn);
                      }
                  }
              } catch (final Exception e) {
                  logger.debug("Exception occurs when calculate snapshot capacity for volumes: due to " + e);
              }
          }
          if (volumeTo.getVolumeType() == Volume.Type.ROOT) {
              VM vm = getVM(conn, vmName);
              if (vm != null) {
                  Set<VM> vmSnapshots = vm.getSnapshots(conn);
                  if (vmSnapshots != null) {
                      for (VM vmsnap : vmSnapshots) {
                          try {
                              final String vmSnapName = vmsnap.getNameLabel(conn);
                              logger.debug("snapname " + vmSnapName);
                              if (vmSnapName != null && vmSnapName.contains(vmSnapshotName) && vmsnap.getIsASnapshot(conn)) {
                                  logger.debug("snapname " + vmSnapName + "isASnapshot");
                                  VDI memoryVDI = vmsnap.getSuspendVDI(conn);
                                  if (!isRefNull(memoryVDI)) {
                                      size = size + memoryVDI.getPhysicalUtilisation(conn);
                                      logger.debug("memoryVDI size :" + toHumanReadableSize(size));
                                      String parentUuid = memoryVDI.getSmConfig(conn).get("vhd-parent");
                                      VDI pMemoryVDI = VDI.getByUuid(conn, parentUuid);
                                      if (!isRefNull(pMemoryVDI)) {
                                          size = size + pMemoryVDI.getPhysicalUtilisation(conn);
                                      }
                                      logger.debug("memoryVDI size+parent :" + toHumanReadableSize(size));
                                  }
                              }
                          } catch (Exception e) {
                              logger.debug("Exception occurs when calculate snapshot capacity for memory: due to " + e);
                          }
  
                      }
                  }
              }
          }
          return size;
      }
  
      public PowerState getVmState(final Connection conn, final String vmName) {
          int retry = 3;
          while (retry-- > 0) {
              try {
                  final Set<VM> vms = VM.getByNameLabel(conn, vmName);
                  for (final VM vm : vms) {
                      return convertToPowerState(vm.getPowerState(conn));
                  }
              } catch (final BadServerResponse e) {
                  // There is a race condition within xenserver such that if a vm
                  // is
                  // deleted and we
                  // happen to ask for it, it throws this stupid response. So
                  // if this happens,
                  // we take a nap and try again which then avoids the race
                  // condition because
                  // the vm's information is now cleaned up by xenserver. The
                  // error
                  // is as follows
                  // com.xensource.xenapi.Types$BadServerResponse
                  // [HANDLE_INVALID, VM,
                  // 3dde93f9-c1df-55a7-2cde-55e1dce431ab]
                  logger.info("Unable to get a vm PowerState due to " + e + ". We are retrying.  Count: " + retry);
                  try {
                      Thread.sleep(3000);
                  } catch (final InterruptedException ignored) {
  
                  }
              } catch (final XenAPIException e) {
                  final String msg = "Unable to get a vm PowerState due to " + e;
                  logger.warn(msg, e);
                  break;
              } catch (final XmlRpcException e) {
                  final String msg = "Unable to get a vm PowerState due to " + e.getMessage();
                  logger.warn(msg, e);
                  break;
              }
          }
  
          return PowerState.PowerOff;
      }
  
      public HashMap<String, VmStatsEntry> getVmStats(final Connection conn, final GetVmStatsCommand cmd, final List<String> vmUUIDs, final String hostGuid) {
          final HashMap<String, VmStatsEntry> vmResponseMap = new HashMap<>();
  
          for (final String vmUUID : vmUUIDs) {
              vmResponseMap.put(vmUUID, new VmStatsEntry(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "vm"));
          }
  
          final Object[] rrdData = getRRDData(conn, 2); // call rrddata with 2 for
          // vm
  
          if (rrdData == null) {
              return null;
          }
  
          final Integer numRows = (Integer)rrdData[0];
          final Integer numColumns = (Integer)rrdData[1];
          final Node legend = (Node)rrdData[2];
          final Node dataNode = (Node)rrdData[3];
  
          final NodeList legendChildren = legend.getChildNodes();
          for (int col = 0; col < numColumns; col++) {
  
              if (legendChildren == null || legendChildren.item(col) == null) {
                  continue;
              }
  
              final String columnMetadata = getXMLNodeValue(legendChildren.item(col));
  
              if (columnMetadata == null) {
                  continue;
              }
  
              final String[] columnMetadataList = columnMetadata.split(":");
  
              if (columnMetadataList.length != 4) {
                  continue;
              }
  
              final String type = columnMetadataList[1];
              final String uuid = columnMetadataList[2];
              final String param = columnMetadataList[3];
  
              if (type.equals("vm") && vmResponseMap.containsKey(uuid)) {
                  final VmStatsEntry vmStatsAnswer = vmResponseMap.get(uuid);
  
                  vmStatsAnswer.setEntityType("vm");
  
                  if (param.contains("cpu")) {
                      vmStatsAnswer.setNumCPUs(vmStatsAnswer.getNumCPUs() + 1);
                      vmStatsAnswer.setCPUUtilization(vmStatsAnswer.getCPUUtilization() + getDataAverage(dataNode, col, numRows));
                  } else if (param.matches("vif_\\d*_rx")) {
                      vmStatsAnswer.setNetworkReadKBs(vmStatsAnswer.getNetworkReadKBs() + getDataAverage(dataNode, col, numRows) / BASE_TO_CONVERT_BYTES_INTO_KILOBYTES);
                  } else if (param.matches("vif_\\d*_tx")) {
                      vmStatsAnswer.setNetworkWriteKBs(vmStatsAnswer.getNetworkWriteKBs() + getDataAverage(dataNode, col, numRows) / BASE_TO_CONVERT_BYTES_INTO_KILOBYTES);
                  } else if (param.matches("vbd_.*_read")) {
                      vmStatsAnswer.setDiskReadKBs(vmStatsAnswer.getDiskReadKBs() + getDataAverage(dataNode, col, numRows) / BASE_TO_CONVERT_BYTES_INTO_KILOBYTES);
                  } else if (param.matches("vbd_.*_write")) {
                      vmStatsAnswer.setDiskWriteKBs(vmStatsAnswer.getDiskWriteKBs() + getDataAverage(dataNode, col, numRows) / BASE_TO_CONVERT_BYTES_INTO_KILOBYTES);
                  } else if (param.contains("memory_internal_free")) {
                      vmStatsAnswer.setIntFreeMemoryKBs(vmStatsAnswer.getIntFreeMemoryKBs() + getDataAverage(dataNode, col, numRows));
                  } else if (param.contains("memory_target")) {
                      vmStatsAnswer.setTargetMemoryKBs(vmStatsAnswer.getTargetMemoryKBs() + getDataAverage(dataNode, col, numRows) / BASE_TO_CONVERT_BYTES_INTO_KILOBYTES);
                  } else if (param.contains("memory")) {
                      vmStatsAnswer.setMemoryKBs(vmStatsAnswer.getMemoryKBs() + getDataAverage(dataNode, col, numRows) / BASE_TO_CONVERT_BYTES_INTO_KILOBYTES);
                  }
  
              }
          }
  
          for (final Map.Entry<String, VmStatsEntry> entry : vmResponseMap.entrySet()) {
              final VmStatsEntry vmStatsAnswer = entry.getValue();
  
              if (vmStatsAnswer.getNumCPUs() != 0) {
                  vmStatsAnswer.setCPUUtilization(vmStatsAnswer.getCPUUtilization() / vmStatsAnswer.getNumCPUs());
              }
  
              vmStatsAnswer.setCPUUtilization(vmStatsAnswer.getCPUUtilization() * 100);
              if (logger.isDebugEnabled()) {
                  logger.debug("Vm cpu utilization " + vmStatsAnswer.getCPUUtilization());
              }
          }
  
          return vmResponseMap;
      }
  
      public String getVncUrl(final Connection conn, final VM vm) {
          VM.Record record;
          try {
              record = vm.getRecord(conn);
              final Set<Console> consoles = record.consoles;
  
              if (consoles.isEmpty()) {
                  logger.warn("There are no Consoles available to the vm : " + record.nameDescription);
                  return null;
              }
              for (Console console : consoles) {
                  if (console.getProtocol(conn) == Types.ConsoleProtocol.RFB) {
                      return console.getLocation(conn);
                  }
              }
          } catch (final XenAPIException e) {
              final String msg = "Unable to get console url due to " + e;
              logger.warn(msg, e);
              return null;
          } catch (final XmlRpcException e) {
              final String msg = "Unable to get console url due to " + e.getMessage();
              logger.warn(msg, e);
              return null;
          }
          return null;
      }
  
      protected String getXMLNodeValue(final Node n) {
          return n.getChildNodes().item(0).getNodeValue();
      }
  
      public void handleSrAndVdiDetach(final String iqn, final Connection conn) {
          final SR sr = getStorageRepository(conn, iqn);
  
          removeSR(conn, sr);
      }
  
      protected void destroyUnattachedVBD(Connection conn, VM vm) {
          try {
              for (VBD vbd : vm.getVBDs(conn)) {
                  if (Types.VbdType.DISK.equals(vbd.getType(conn)) && !vbd.getCurrentlyAttached(conn)) {
                      vbd.destroy(conn);
                  }
              }
          } catch (final Exception e) {
              logger.debug("Failed to destroy unattached VBD due to ", e);
          }
      }
  
      public String handleVmStartFailure(final Connection conn, final String vmName, final VM vm, final String message, final Throwable th) {
          final String msg = "Unable to start " + vmName + " due to " + message;
          logger.warn(msg, th);
  
          if (vm == null) {
              return msg;
          }
  
          try {
              final VM.Record vmr = vm.getRecord(conn);
              final List<Network> networks = new ArrayList<>();
              for (final VIF vif : vmr.VIFs) {
                  try {
                      final VIF.Record rec = vif.getRecord(conn);
                      if (rec != null) {
                          networks.add(rec.network);
                      } else {
                          logger.warn("Unable to cleanup VIF: " + vif.toWireString() + " As vif record is null");
                      }
                  } catch (final Exception e) {
                      logger.warn("Unable to cleanup VIF", e);
                  }
              }
              if (vmr.powerState == VmPowerState.RUNNING) {
                  try {
                      vm.hardShutdown(conn);
                  } catch (final Exception e) {
                      logger.warn("VM hardshutdown failed due to ", e);
                  }
              }
              if (vm.getPowerState(conn) == VmPowerState.HALTED) {
                  try {
                      destroyVm(vm, conn, true);
                  } catch (final Exception e) {
                      logger.warn("VM destroy failed due to ", e);
                  }
              }
              for (final VBD vbd : vmr.VBDs) {
                  try {
                      vbd.unplug(conn);
                      vbd.destroy(conn);
                  } catch (final Exception e) {
                      logger.warn("Unable to clean up VBD due to ", e);
                  }
              }
              for (final VIF vif : vmr.VIFs) {
                  try {
                      vif.unplug(conn);
                      vif.destroy(conn);
                  } catch (final Exception e) {
                      logger.warn("Unable to cleanup VIF", e);
                  }
              }
              for (final Network network : networks) {
                  if (network.getNameLabel(conn).startsWith("VLAN")) {
                      disableVlanNetwork(conn, network, true);
                  }
              }
          } catch (final Exception e) {
              logger.warn("VM getRecord failed due to ", e);
          }
  
          return msg;
      }
  
      @Override
      public StartupCommand[] initialize() throws IllegalArgumentException {
          return initialize(false);
      }
  
      @Override
      public StartupCommand[] initialize(boolean isTransferredConnection) throws IllegalArgumentException {
          final Connection conn = getConnection();
          if (!getHostInfo(conn)) {
              logger.warn("Unable to get host information for " + _host.getIp());
              return null;
          }
          final StartupRoutingCommand cmd = new StartupRoutingCommand();
          fillHostInfo(conn, cmd);
          cmd.setHypervisorType(HypervisorType.XenServer);
          cmd.setCluster(_cluster);
          cmd.setPoolSync(false);
          cmd.setConnectionTransferred(isTransferredConnection);
  
          try {
              final Pool pool = Pool.getByUuid(conn, _host.getPool());
              final Pool.Record poolr = pool.getRecord(conn);
              poolr.master.getRecord(conn);
          } catch (final Throwable e) {
              logger.warn("Check for master failed, failing the FULL Cluster sync command");
          }
          List<StartupStorageCommand> startUpLocalStorageCommands = null;
          try {
              startUpLocalStorageCommands = initializeLocalSrs(conn);
          } catch (XenAPIException | XmlRpcException e) {
              logger.warn("Could not initialize local SRs on host: " + _host.getUuid(), e);
          }
          if (CollectionUtils.isEmpty(startUpLocalStorageCommands)) {
              return new StartupCommand[] {cmd};
          }
          return createStartupCommandsArray(cmd, startUpLocalStorageCommands);
      }
  
      /**
       * We simply create an array and add the {@link StartupRoutingCommand} as the first element of the array. Then, we add all elements from startUpLocalStorageCommands
       */
      private StartupCommand[] createStartupCommandsArray(StartupRoutingCommand startupRoutingCommand, List<StartupStorageCommand> startUpLocalStorageCommands) {
          StartupCommand[] startupCommands = new StartupCommand[startUpLocalStorageCommands.size() + 1];
          startupCommands[0] = startupRoutingCommand;
          for (int i = 1; i < startupCommands.length; i++) {
              startupCommands[i] = startUpLocalStorageCommands.get(i - 1);
          }
          return startupCommands;
      }
  
      /**
       * This  method will return a list of all local SRs.
       * An SR is considered local if it meets all of the following criteria:
       * <ul>
       *  <li> {@link Record#shared} is equal to false
       *  <li> The PBDs of the SR ({@link Record#PBDs}) are connected to host {@link #_host}
       *  <li> SR type is equal to the {@link SRType} sent as parameter
       * </ul>
       */
      protected List<SR> getAllLocalSrForType(Connection conn, SRType srType) throws XenAPIException, XmlRpcException {
          List<SR> localSrs = new ArrayList<>();
          Map<SR, SR.Record> allSrRecords = SR.getAllRecords(conn);
          if (MapUtils.isEmpty(allSrRecords)) {
              return localSrs;
          }
          for (Map.Entry<SR, SR.Record> entry : allSrRecords.entrySet()) {
              SR.Record srRec = entry.getValue();
              if (!srType.equals(srRec.type)) {
                  continue;
              }
              if (BooleanUtils.toBoolean(srRec.shared)) {
                  continue;
              }
              Set<PBD> pbds = srRec.PBDs;
              if (CollectionUtils.isEmpty(pbds)) {
                  continue;
              }
              for (PBD pbd : pbds) {
                  Host host = pbd.getHost(conn);
                  if (!isRefNull(host) && StringUtils.equals(host.getUuid(conn), _host.getUuid())) {
                      if (!pbd.getCurrentlyAttached(conn)) {
                          logger.debug(String.format("PBD [%s] of local SR [%s] was unplugged, pluggin it now", pbd.getUuid(conn), srRec.uuid));
                          pbd.plug(conn);
                      }
                      logger.debug("Scanning local SR: " + srRec.uuid);
                      SR sr = entry.getKey();
                      sr.scan(conn);
                      localSrs.add(sr);
                  }
              }
          }
          logger.debug(String.format("Found %d local storage of type [%s] for host [%s]", localSrs.size(), srType.toString(), _host.getUuid()));
          return localSrs;
      }
  
      /**
       *  This method will prepare Local SRs to be used by Apache CloudStack.
       */
      protected List<StartupStorageCommand> initializeLocalSrs(Connection conn) throws XenAPIException, XmlRpcException {
          List<StartupStorageCommand> localStorageStartupCommands = new ArrayList<>();
          List<SR> allLocalSrs = getAllLocalSrs(conn);
  
          for (SR sr : allLocalSrs) {
              long totalCapacity = sr.getPhysicalSize(conn);
              if (totalCapacity > 0) {
                  StartupStorageCommand cmd = createStartUpStorageCommand(conn, sr);
                  localStorageStartupCommands.add(cmd);
              }
          }
          return localStorageStartupCommands;
      }
  
      /**
       * This method will retrieve all Local SRs according to {@link #getAllLocalSrForType(Connection, SRType)}.
       * The types used are {@link SRType#LVM} and {@link SRType#EXT}.
       *
       */
      protected List<SR> getAllLocalSrs(Connection conn) throws XenAPIException, XmlRpcException {
          List<SR> allLocalSrLvmType = getAllLocalSrForType(conn, SRType.LVM);
          List<SR> allLocalSrExtType = getAllLocalSrForType(conn, SRType.EXT);
          List<SR> allLocalSrs = new ArrayList<>(allLocalSrLvmType);
          allLocalSrs.addAll(allLocalSrExtType);
          return allLocalSrs;
      }
  
      /**
       * This method creates the StartUp storage command for the local SR.
       * We will configure 'name-label' and 'description' using {@link #configureStorageNameAndDescription(Connection, SR)}.
       * Then, we will create the POJO {@link StoragePoolInfo} with SR's information using method {@link #createStoragePoolInfo(Connection, SR)}.
       */
      protected StartupStorageCommand createStartUpStorageCommand(Connection conn, SR sr) throws XenAPIException, XmlRpcException {
          configureStorageNameAndDescription(conn, sr);
  
          StoragePoolInfo storagePoolInfo = createStoragePoolInfo(conn, sr);
  
          StartupStorageCommand cmd = new StartupStorageCommand();
          cmd.setPoolInfo(storagePoolInfo);
          cmd.setGuid(_host.getUuid());
          cmd.setDataCenter(Long.toString(_dcId));
          cmd.setResourceType(Storage.StorageResourceType.STORAGE_POOL);
  
          logger.info("StartUp command created for local storage [{}] of type [{}] on host [{}]", storagePoolInfo.getUuid(), storagePoolInfo.getPoolType(), _host.getUuid());
          return cmd;
      }
  
      /**
       *  Instantiate {@link StoragePoolInfo} with SR's information.
       */
      protected StoragePoolInfo createStoragePoolInfo(Connection conn, SR sr) throws XenAPIException, XmlRpcException {
          long totalCapacity = sr.getPhysicalSize(conn);
          String srUuid = sr.getUuid(conn);
          Host host = Host.getByUuid(conn, _host.getUuid());
          String address = host.getAddress(conn);
          long availableCapacity = totalCapacity - sr.getPhysicalUtilisation(conn);
          String srType = sr.getType(conn).toUpperCase();
          return new StoragePoolInfo(srUuid, address, srType, srType, StoragePoolType.valueOf(srType), totalCapacity, availableCapacity);
      }
  
      protected void configureStorageNameAndDescription(Connection conn, SR sr) throws XenAPIException, XmlRpcException {
          String srUuid = sr.getUuid(conn);
          sr.setNameLabel(conn, srUuid);
  
          String nameFormat = "Cloud Stack Local (%s) Storage Pool for %s";
          sr.setNameDescription(conn, String.format(nameFormat, sr.getType(conn), _host.getUuid()));
      }
  
      public boolean isDeviceUsed(final Connection conn, final VM vm, final Long deviceId) {
          // Figure out the disk number to attach the VM to
  
          String msg;
          try {
              final Set<String> allowedVBDDevices = vm.getAllowedVBDDevices(conn);
              return !allowedVBDDevices.contains(deviceId.toString());
          } catch (final XmlRpcException e) {
              msg = "Catch XmlRpcException due to: " + e.getMessage();
              logger.warn(msg, e);
          } catch (final XenAPIException e) {
              msg = "Catch XenAPIException due to: " + e;
              logger.warn(msg, e);
          }
          throw new CloudRuntimeException("When check deviceId " + msg);
      }
  
      /**
       * When Dynamic Memory Control (DMC) is enabled - xenserver allows scaling
       * the guest memory while the guest is running
       *
       * By default this is disallowed, override the specific xenserver resource
       * if this is enabled
       */
      public boolean isDmcEnabled(final Connection conn, final Host host) throws XenAPIException, XmlRpcException {
          return false;
      }
  
      public boolean IsISCSI(final String type) {
          return SRType.LVMOHBA.equals(type) || SRType.LVMOISCSI.equals(type) || SRType.LVM.equals(type);
      }
  
      public boolean isNetworkSetupByName(final String nameTag) throws XenAPIException, XmlRpcException {
          if (nameTag != null) {
              if (logger.isDebugEnabled()) {
                  logger.debug("Looking for network setup by name " + nameTag);
              }
              final Connection conn = getConnection();
              final XsLocalNetwork network = getNetworkByName(conn, nameTag);
              return network != null;
          }
          return true;
      }
  
      public boolean isOvs() {
          return _isOvs;
      }
  
      public boolean isRefNull(final XenAPIObject object) {
          return object == null || object.toWireString().equals("OpaqueRef:NULL") || object.toWireString().equals("<not in database>");
      }
  
      public boolean isSecurityGroupEnabled() {
          return _securityGroupEnabled;
      }
  
      public boolean isXcp() {
          final Connection conn = getConnection();
          final String result = callHostPlugin(conn, "ovstunnel", "is_xcp");
          return result.equals("XCP");
      }
  
      boolean killCopyProcess(final Connection conn, final String nameLabel) {
          final String results = callHostPluginAsync(conn, "vmops", "kill_copy_process", 60, "namelabel", nameLabel);
          String errMsg;
          if (results == null || results.equals("false")) {
              errMsg = "kill_copy_process failed";
              logger.warn(errMsg);
              return false;
          } else {
              return true;
          }
      }
  
      public boolean launchHeartBeat(final Connection conn) {
          final String result = callHostPluginPremium(conn, "heartbeat", "host", _host.getUuid(), "timeout", Integer.toString(_heartbeatTimeout), "interval", Integer.toString(_heartbeatInterval));
          if (result == null || !result.contains("> DONE <")) {
              logger.warn("Unable to launch the heartbeat process on " + _host.getIp());
              return false;
          }
          return true;
      }
  
      protected String logX(final XenAPIObject obj, final String msg) {
          return "Host " + _host.getIp() + " " + obj.toWireString() + ": " + msg;
      }
  
      public void migrateVM(final Connection conn, final Host destHost, final VM vm, final String vmName) throws Exception {
          Task task = null;
          try {
              final Map<String, String> other = new HashMap<>();
              other.put("live", "true");
              task = vm.poolMigrateAsync(conn, destHost, other);
              try {
                  // poll every 1 seconds
                  final long timeout = _migratewait * 1000L;
                  waitForTask(conn, task, 1000, timeout);
                  checkForSuccess(conn, task);
              } catch (final Types.HandleInvalid e) {
                  if (vm.getResidentOn(conn).equals(destHost)) {
                      task = null;
                      return;
                  }
                  throw new CloudRuntimeException("migrate VM catch HandleInvalid and VM is not running on dest host");
              }
          } catch (final XenAPIException e) {
              final String msg = "Unable to migrate VM(" + vmName + ") from host(" + _host.getUuid() + ")";
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg);
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e1) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e1);
                  }
              }
          }
      }
  
      protected VDI mount(final Connection conn, final StoragePoolType poolType, final String volumeFolder, final String volumePath) {
          return getVDIbyUuid(conn, volumePath);
      }
  
      public VDI mount(final Connection conn, final String vmName, final DiskTO volume) throws XmlRpcException, XenAPIException {
          final DataTO data = volume.getData();
          final Volume.Type type = volume.getType();
          if (type == Volume.Type.ISO) {
              final TemplateObjectTO iso = (TemplateObjectTO)data;
              final DataStoreTO store = iso.getDataStore();
  
              if (store == null) {
                  // It's a fake iso
                  return null;
              }
  
              // corer case, xenserver pv driver iso
              final String templateName = iso.getName();
              if (templateName != null && templateName.startsWith("xs-tools")) {
                  try {
                      final String actualTemplateName = getActualIsoTemplate(conn);
                      final Set<VDI> vdis = VDI.getByNameLabel(conn, actualTemplateName);
                      if (vdis.isEmpty()) {
                          throw new CloudRuntimeException("Could not find ISO with URL: " + actualTemplateName);
                      }
                      return vdis.iterator().next();
                  } catch (final Exception e) {
                      throw new CloudRuntimeException("Unable to get pv iso: " + templateName + " due to " + e);
                  }
              }
  
              if (!(store instanceof NfsTO)) {
                  throw new CloudRuntimeException("only support mount iso on nfs");
              }
              final NfsTO nfsStore = (NfsTO)store;
              final String isoPath = nfsStore.getUrl() + File.separator + iso.getPath();
              final int index = isoPath.lastIndexOf("/");
  
              final String mountpoint = isoPath.substring(0, index);
              URI uri;
              try {
                  uri = new URI(mountpoint);
              } catch (final URISyntaxException e) {
                  throw new CloudRuntimeException("Incorrect uri " + mountpoint, e);
              }
              final SR isoSr = createIsoSRbyURI(conn, uri, vmName, true);
  
              final String isoname = isoPath.substring(index + 1);
  
              final VDI isoVdi = getVDIbyLocationandSR(conn, isoname, isoSr);
  
              if (isoVdi == null) {
                  throw new CloudRuntimeException("Unable to find ISO " + isoPath);
              }
              return isoVdi;
          } else {
              final VolumeObjectTO vol = (VolumeObjectTO)data;
              return VDI.getByUuid(conn, vol.getPath());
          }
      }
  
  
      public String networkUsage(final Connection conn, final String privateIpAddress, final String option, final String vif) {
          return networkUsage(conn, privateIpAddress, option, vif, null);
      }
  
      public String networkUsage(final Connection conn, final String privateIpAddress, final String option, final String vif, final String publicIp) {
          if (option.equals("get")) {
              return "0:0";
          }
          return null;
      }
  
      private List<Pair<String, Long>> ovsFullSyncStates() {
          final Connection conn = getConnection();
          final String result = callHostPlugin(conn, "ovsgre", "ovs_get_vm_log", "host_uuid", _host.getUuid());
          final String[] logs = result != null ? result.split(";") : new String[0];
          final List<Pair<String, Long>> states = new ArrayList<>();
          for (final String log : logs) {
              final String[] info = log.split(",");
              if (info.length != 5) {
                  logger.warn("Wrong element number in ovs log(" + log + ")");
                  continue;
              }
  
              // ','.join([bridge, vmName, vmId, seqno, tag])
              try {
                  states.add(new Pair<>(info[0], Long.parseLong(info[3])));
              } catch (final NumberFormatException nfe) {
                  states.add(new Pair<>(info[0], -1L));
              }
          }
          return states;
      }
  
      public HashMap<String, String> parseDefaultOvsRuleCommand(final String str) {
          final HashMap<String, String> cmd = new HashMap<>();
          final String[] sarr = str.split("/");
          for (String s : sarr) {
              String c = s;
              c = c.startsWith("/") ? c.substring(1) : c;
              c = c.endsWith("/") ? c.substring(0, c.length() - 1) : c;
              final String[] p = c.split(";");
              if (p.length != 2) {
                  continue;
              }
              if (p[0].equalsIgnoreCase("vlans")) {
                  p[1] = p[1].replace("@", "[");
                  p[1] = p[1].replace("#", "]");
              }
              cmd.put(p[0], p[1]);
          }
          return cmd;
      }
  
      protected Pair<Long, Integer> parseTimestamp(final String timeStampStr) {
          final String[] tokens = timeStampStr.split("-");
          if (tokens.length != 3) {
              logger.debug("timeStamp in network has wrong pattern: " + timeStampStr);
              return null;
          }
          if (!tokens[0].equals("CsCreateTime")) {
              logger.debug("timeStamp in network doesn't start with CsCreateTime: " + timeStampStr);
              return null;
          }
          return new Pair<>(Long.parseLong(tokens[1]), Integer.parseInt(tokens[2]));
      }
  
      private void pbdPlug(final Connection conn, final PBD pbd, final String uuid) {
          try {
              if (logger.isDebugEnabled()) {
                  logger.debug("Plugging in PBD " + uuid + " for " + _host);
              }
              pbd.plug(conn);
          } catch (final Exception e) {
              final String msg = "PBD " + uuid + " is not attached! and PBD plug failed due to " + e + ". Please check this PBD in " + _host;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg);
          }
      }
  
      protected boolean pingdomr(final Connection conn, final String host, final String port) {
          String status;
          status = callHostPlugin(conn, "vmops", "pingdomr", "host", host, "port", port);
  
          return status != null && !status.isEmpty();
  
      }
  
      public boolean pingXAPI() {
          final Connection conn = getConnection();
          try {
              final Host host = Host.getByUuid(conn, _host.getUuid());
              if (!host.getEnabled(conn)) {
                  logger.debug("Host " + _host.getIp() + " is not enabled!");
                  return false;
              }
          } catch (final Exception e) {
              logger.debug("cannot get host enabled status, host " + _host.getIp() + " due to " + e, e);
              return false;
          }
          try {
              callHostPlugin(conn, "echo", "main");
          } catch (final Exception e) {
              logger.debug("cannot ping host " + _host.getIp() + " due to " + e, e);
              return false;
          }
          return true;
      }
  
      protected void plugDom0Vif(final Connection conn, final VIF dom0Vif) throws XmlRpcException, XenAPIException {
          if (dom0Vif != null) {
              dom0Vif.plug(conn);
          }
      }
  
      protected boolean postCreatePrivateTemplate(final Connection conn, final String templatePath, final String tmpltFilename, final String templateName, String templateDescription, String checksum,
              final long size, final long virtualSize, final long templateId, final String nfsVersion) {
  
          if (templateDescription == null) {
              templateDescription = "";
          }
  
          if (checksum == null) {
              checksum = "";
          }
  
          final String result = callHostPlugin(conn, "vmopsSnapshot", "post_create_private_template", "templatePath", templatePath, "templateFilename", tmpltFilename, "templateName", templateName,
                  "templateDescription", templateDescription, "checksum", checksum, "size", String.valueOf(size), "virtualSize", String.valueOf(virtualSize), "templateId", String.valueOf(templateId), "nfsVersion", nfsVersion);
  
          boolean success = false;
          if (result != null && !result.isEmpty()) {
              // Else, command threw an exception which has already been logged.
  
              if (result.equalsIgnoreCase("1")) {
                  logger.debug("Successfully created template.properties file on secondary storage for " + tmpltFilename);
                  success = true;
              } else {
                  logger.warn("Could not create template.properties file on secondary storage for " + tmpltFilename + " for templateId: " + templateId);
              }
          }
  
          return success;
      }
  
      @Override
      public ExecutionResult prepareCommand(final NetworkElementCommand cmd) {
          // Update IP used to access router
          cmd.setRouterAccessIp(cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP));
          assert cmd.getRouterAccessIp() != null;
  
          if (cmd instanceof IpAssocVpcCommand) {
              return prepareNetworkElementCommand((IpAssocVpcCommand)cmd);
          } else if (cmd instanceof IpAssocCommand) {
              return prepareNetworkElementCommand((IpAssocCommand)cmd);
          } else if (cmd instanceof SetupGuestNetworkCommand) {
              return prepareNetworkElementCommand((SetupGuestNetworkCommand)cmd);
          } else if (cmd instanceof SetSourceNatCommand) {
              return prepareNetworkElementCommand((SetSourceNatCommand)cmd);
          } else if (cmd instanceof SetNetworkACLCommand) {
              return prepareNetworkElementCommand((SetNetworkACLCommand)cmd);
          }
          return new ExecutionResult(true, null);
      }
  
      public void prepareISO(final Connection conn, final String vmName, List<String[]> vmDataList, String configDriveLabel) throws XmlRpcException, XenAPIException {
  
          final Set<VM> vms = VM.getByNameLabel(conn, vmName);
          if (vms == null || vms.size() != 1) {
              throw new CloudRuntimeException("There are " + (vms == null ? "0" : vms.size()) + " VMs named " + vmName);
          }
          final VM vm = vms.iterator().next();
  
          final Set<VBD> vbds = vm.getVBDs(conn);
          for (final VBD vbd : vbds) {
              final VBD.Record vbdr = vbd.getRecord(conn);
              if (vbdr.type == Types.VbdType.CD && !vbdr.empty && vbdr.userdevice.equals(_attachIsoDeviceNum)) {
                  final VDI vdi = vbdr.VDI;
                  final SR sr = vdi.getSR(conn);
                  final Set<PBD> pbds = sr.getPBDs(conn);
                  if (pbds == null) {
                      throw new CloudRuntimeException("There is no pbd for sr " + sr);
                  }
                  for (final PBD pbd : pbds) {
                      final PBD.Record pbdr = pbd.getRecord(conn);
                      if (pbdr.host.getUuid(conn).equals(_host.getUuid())) {
                          return;
                      }
                  }
                  sr.setShared(conn, true);
                  final Host host = Host.getByUuid(conn, _host.getUuid());
                  final PBD.Record pbdr = pbds.iterator().next().getRecord(conn);
                  pbdr.host = host;
                  pbdr.uuid = "";
                  final PBD pbd = PBD.create(conn, pbdr);
                  pbdPlug(conn, pbd, pbd.getUuid(conn));
                  break;
              }
          }
      }
  
      // The idea here is to see if the DiskTO in question is from managed storage and does not yet have an SR.
      // If no SR, create it and create a VDI in it.
      public VDI prepareManagedDisk(final Connection conn, final DiskTO disk, final long vmId, final String vmName) throws Exception {
          final Map<String, String> details = disk.getDetails();
  
          if (details == null) {
              return null;
          }
  
          final boolean isManaged = Boolean.parseBoolean(details.get(DiskTO.MANAGED));
  
          if (!isManaged) {
              return null;
          }
  
          final String iqn = details.get(DiskTO.IQN);
  
          final Set<SR> srNameLabels = SR.getByNameLabel(conn, iqn);
  
          if (!srNameLabels.isEmpty()) {
              return null;
          }
  
          final String vdiNameLabel = Volume.Type.ROOT.equals(disk.getType()) ? ("ROOT-" + vmId) : (vmName + "-DATA");
  
          return prepareManagedStorage(conn, details, null, vdiNameLabel);
      }
  
      protected SR prepareManagedSr(final Connection conn, final Map<String, String> details) {
          final String iScsiName = details.get(DiskTO.IQN);
          final String storageHost = details.get(DiskTO.STORAGE_HOST);
          final String chapInitiatorUsername = details.get(DiskTO.CHAP_INITIATOR_USERNAME);
          final String chapInitiatorSecret = details.get(DiskTO.CHAP_INITIATOR_SECRET);
          final String mountpoint = details.get(DiskTO.MOUNT_POINT);
          final String protocoltype = details.get(DiskTO.PROTOCOL_TYPE);
  
          if (StoragePoolType.NetworkFilesystem.toString().equalsIgnoreCase(protocoltype)) {
              final String poolid = storageHost + ":" + mountpoint;
              final String volumedesc = storageHost + ":" + mountpoint;
  
              return getNfsSR(conn, poolid, mountpoint, storageHost, mountpoint, volumedesc);
          } else {
              return getIscsiSR(conn, iScsiName, storageHost, iScsiName, chapInitiatorUsername, chapInitiatorSecret, false, SRType.LVMOISCSI.toString(), true);
          }
      }
  
      protected VDI prepareManagedStorage(final Connection conn, final Map<String, String> details, final String path, final String vdiNameLabel) throws Exception {
          final SR sr = prepareManagedSr(conn, details);
  
          VDI vdi = getVDIbyUuid(conn, path, false);
          final Long volumeSize = Long.parseLong(details.get(DiskTO.VOLUME_SIZE));
  
          Set<VDI> vdisInSr = sr.getVDIs(conn);
  
          // If a VDI already exists in the SR (in case we cloned from a template cache), use that.
          if (vdisInSr.size() == 1) {
              vdi = vdisInSr.iterator().next();
          }
  
          if (vdi == null) {
              vdi = createVdi(sr, vdiNameLabel, volumeSize);
          } else {
              // If vdi is not null, it must have already been created, so check whether a resize of the volume was performed.
              // If true, resize the VDI to the volume size.
  
              logger.info("Checking for the resize of the datadisk");
  
              final long vdiVirtualSize = vdi.getVirtualSize(conn);
  
              if (vdiVirtualSize != volumeSize) {
                  logger.info("Resizing the data disk (VDI) from vdiVirtualSize: " + toHumanReadableSize(vdiVirtualSize) + " to volumeSize: " + toHumanReadableSize(volumeSize));
  
                  try {
                      vdi.resize(conn, volumeSize);
                  } catch (final Exception e) {
                      logger.warn("Unable to resize volume", e);
                  }
              }
  
              // change the name-label in case of a cloned VDI
              if (!Objects.equals(vdi.getNameLabel(conn), vdiNameLabel)) {
                  try {
                      vdi.setNameLabel(conn, vdiNameLabel);
                  } catch (final Exception e) {
                      logger.warn("Unable to rename volume", e);
                  }
              }
          }
  
          return vdi;
      }
  
      protected ExecutionResult prepareNetworkElementCommand(final IpAssocCommand cmd) {
          final Connection conn = getConnection();
          final String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
          final String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
  
          try {
              final IpAddressTO[] ips = cmd.getIpAddresses();
              for (final IpAddressTO ip : ips) {
  
                  final VM router = getVM(conn, routerName);
  
                  final NicTO nic = new NicTO();
                  nic.setMac(ip.getVifMacAddress());
                  nic.setType(ip.getTrafficType());
                  if (ip.getBroadcastUri() == null) {
                      nic.setBroadcastType(BroadcastDomainType.Native);
                  } else {
                      final URI uri = BroadcastDomainType.fromString(ip.getBroadcastUri());
                      nic.setBroadcastType(BroadcastDomainType.getSchemeValue(uri));
                      nic.setBroadcastUri(uri);
                  }
                  nic.setDeviceId(0);
                  nic.setNetworkRateMbps(ip.getNetworkRate());
                  nic.setName(ip.getNetworkName());
  
                  final Network network = getNetwork(conn, nic);
  
                  // Determine the correct VIF on DomR to associate/disassociate
                  // the
                  // IP address with
                  VIF correctVif = getCorrectVif(conn, router, network);
  
                  // If we are associating an IP address and DomR doesn't have a
                  // VIF
                  // for the specified vlan ID, we need to add a VIF
                  // If we are disassociating the last IP address in the VLAN, we
                  // need
                  // to remove a VIF
                  boolean addVif = ip.isAdd() && correctVif == null;
  
                  if (addVif) {
                      // Add a new VIF to DomR
                      final String vifDeviceNum = getLowestAvailableVIFDeviceNum(conn, router);
  
                      if (vifDeviceNum == null) {
                          throw new InternalErrorException("There were no more available slots for a new VIF on router: " + router.getNameLabel(conn));
                      }
  
                      nic.setDeviceId(Integer.parseInt(vifDeviceNum));
  
                      correctVif = createVif(conn, routerName, router, null, nic);
                      correctVif.plug(conn);
                      // Add iptables rule for network usage
                      networkUsage(conn, routerIp, "addVif", "eth" + correctVif.getDevice(conn));
                  }
  
                  if (ip.isAdd() && correctVif == null) {
                      throw new InternalErrorException("Failed to find DomR VIF to associate/disassociate IP with.");
                  }
                  if (correctVif != null) {
                      ip.setNicDevId(Integer.valueOf(correctVif.getDevice(conn)));
                      ip.setNewNic(addVif);
                  }
              }
          } catch (final InternalErrorException e) {
              logger.error("Ip Assoc failure on applying one ip due to exception:  ", e);
              return new ExecutionResult(false, e.getMessage());
          } catch (final Exception e) {
              return new ExecutionResult(false, e.getMessage());
          }
          return new ExecutionResult(true, null);
      }
  
      protected ExecutionResult prepareNetworkElementCommand(final IpAssocVpcCommand cmd) {
          final Connection conn = getConnection();
          final String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
          try {
              final IpAddressTO[] ips = cmd.getIpAddresses();
              for (final IpAddressTO ip : ips) {
  
                  final VM router = getVM(conn, routerName);
  
                  final VIF correctVif = getVifByMac(conn, router, ip.getVifMacAddress());
                  setNicDevIdIfCorrectVifIsNotNull(conn, ip, correctVif);
              }
          } catch (final Exception e) {
              logger.error("Ip Assoc failure on applying one ip due to exception:  ", e);
              return new ExecutionResult(false, e.getMessage());
          }
  
          return new ExecutionResult(true, null);
      }
  
      protected ExecutionResult prepareNetworkElementCommand(final SetNetworkACLCommand cmd) {
          final Connection conn = getConnection();
          final String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
  
          try {
              final VM router = getVM(conn, routerName);
  
              final NicTO nic = cmd.getNic();
              if (nic != null) {
                  final VIF vif = getVifByMac(conn, router, nic.getMac());
                  if (vif == null) {
                      final String msg = "Prepare SetNetworkACL failed due to VIF is null for : " + nic.getMac() + " with routername: " + routerName;
                      logger.error(msg);
                      return new ExecutionResult(false, msg);
                  }
                  nic.setDeviceId(Integer.parseInt(vif.getDevice(conn)));
              } else {
                  final String msg = "Prepare SetNetworkACL failed due to nic is null for : " + routerName;
                  logger.error(msg);
                  return new ExecutionResult(false, msg);
              }
          } catch (final Exception e) {
              final String msg = "Prepare SetNetworkACL failed due to " + e;
              logger.error(msg, e);
              return new ExecutionResult(false, msg);
          }
          return new ExecutionResult(true, null);
      }
  
      protected ExecutionResult prepareNetworkElementCommand(final SetSourceNatCommand cmd) {
          final Connection conn = getConnection();
          final String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
          final IpAddressTO pubIp = cmd.getIpAddress();
          try {
              final VM router = getVM(conn, routerName);
  
              final VIF correctVif = getCorrectVif(conn, router, pubIp);
  
              pubIp.setNicDevId(Integer.valueOf(correctVif.getDevice(conn)));
  
          } catch (final Exception e) {
              final String msg = "Ip SNAT failure due to " + e;
              logger.error(msg, e);
              return new ExecutionResult(false, msg);
          }
          return new ExecutionResult(true, null);
      }
  
      /**
       * @param cmd
       * @return
       */
      private ExecutionResult prepareNetworkElementCommand(final SetupGuestNetworkCommand cmd) {
          final Connection conn = getConnection();
          final NicTO nic = cmd.getNic();
          final String domrName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
          try {
              final Set<VM> vms = VM.getByNameLabel(conn, domrName);
              if (vms == null || vms.isEmpty()) {
                  return new ExecutionResult(false, "Can not find VM " + domrName);
              }
              final VM vm = vms.iterator().next();
              final String mac = nic.getMac();
              VIF domrVif = null;
              for (final VIF vif : vm.getVIFs(conn)) {
                  final String lmac = vif.getMAC(conn);
                  if (lmac.equals(mac)) {
                      domrVif = vif;
                      // Do not break it! We have 2 routers.
                      // break;
                  }
              }
              if (domrVif == null) {
                  return new ExecutionResult(false, "Can not find vif with mac " + mac + " for VM " + domrName);
              }
  
              nic.setDeviceId(Integer.parseInt(domrVif.getDevice(conn)));
          } catch (final Exception e) {
              final String msg = "Creating guest network failed due to " + e;
              logger.warn(msg, e);
              return new ExecutionResult(false, msg);
          }
          return new ExecutionResult(true, null);
      }
  
      public void rebootVM(final Connection conn, final VM vm, final String vmName) throws Exception {
          Task task = null;
          try {
              task = vm.cleanRebootAsync(conn);
              try {
                  // poll every 1 seconds , timeout after 10 minutes
                  waitForTask(conn, task, 1000, 10 * 60 * 1000);
                  checkForSuccess(conn, task);
              } catch (final Types.HandleInvalid e) {
                  if (vm.getPowerState(conn) == VmPowerState.RUNNING) {
                      task = null;
                      return;
                  }
                  throw new CloudRuntimeException("Reboot VM catch HandleInvalid and VM is not in RUNNING state");
              }
          } catch (final XenAPIException e) {
              logger.debug("Unable to Clean Reboot VM(" + vmName + ") on host(" + _host.getUuid() + ") due to " + e + ", try hard reboot");
              try {
                  vm.hardReboot(conn);
              } catch (final Exception e1) {
                  final String msg = "Unable to hard Reboot VM(" + vmName + ") on host(" + _host.getUuid() + ") due to " + e;
                  logger.warn(msg, e1);
                  throw new CloudRuntimeException(msg);
              }
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e1) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e1);
                  }
              }
          }
      }
  
      protected void skipOrRemoveSR(Connection conn, SR sr) {
          if (sr == null) {
              return;
          }
          if (logger.isDebugEnabled()) {
              logger.debug(logX(sr, "Removing SR"));
          }
          try {
              Set<VDI> vdis = sr.getVDIs(conn);
              for (VDI vdi : vdis) {
                  if (MapUtils.isEmpty(vdi.getCurrentOperations(conn))) {
                      continue;
                  }
                  return;
              }
              removeSR(conn, sr);
              return;
          } catch (XenAPIException | XmlRpcException e) {
              logger.warn(logX(sr, "Unable to get current operations " + e), e);
          }
          String msg = "Remove SR failed";
          logger.warn(msg);
      }
  
      public void removeSR(final Connection conn, final SR sr) {
          if (sr == null) {
              return;
          }
  
          if (logger.isDebugEnabled()) {
              logger.debug(logX(sr, "Removing SR"));
          }
  
          for (int i = 0; i < 2; i++) {
              try {
                  final Set<VDI> vdis = sr.getVDIs(conn);
                  for (final VDI vdi : vdis) {
                      vdi.forget(conn);
                  }
  
                  Set<PBD> pbds = sr.getPBDs(conn);
                  for (final PBD pbd : pbds) {
                      if (logger.isDebugEnabled()) {
                          logger.debug(logX(pbd, "Unplugging pbd"));
                      }
  
                      // if (pbd.getCurrentlyAttached(conn)) {
                      pbd.unplug(conn);
                      // }
  
                      pbd.destroy(conn);
                  }
  
                  pbds = sr.getPBDs(conn);
  
                  if (pbds.isEmpty()) {
                      if (logger.isDebugEnabled()) {
                          logger.debug(logX(sr, "Forgetting"));
                      }
  
                      sr.forget(conn);
  
                      return;
                  }
  
                  if (logger.isDebugEnabled()) {
                      logger.debug(logX(sr, "There is still one or more PBDs attached."));
  
                      if (logger.isTraceEnabled()) {
                          for (final PBD pbd : pbds) {
                              logger.trace(logX(pbd, " Still attached"));
                          }
                      }
                  }
              } catch (final XenAPIException e) {
                  logger.debug(logX(sr, "Catch XenAPIException: " + e));
              } catch (final XmlRpcException e) {
                  logger.debug(logX(sr, "Catch Exception: " + e.getMessage()));
              }
          }
  
          logger.warn(logX(sr, "Unable to remove SR"));
      }
  
      protected String removeSRSync(final Connection conn, final SR sr) {
          if (sr == null) {
              return null;
          }
          if (logger.isDebugEnabled()) {
              logger.debug(logX(sr, "Removing SR"));
          }
          long waittime = 0;
          try {
              final Set<VDI> vdis = sr.getVDIs(conn);
              for (final VDI vdi : vdis) {
                  final Map<java.lang.String, Types.VdiOperations> currentOperation = vdi.getCurrentOperations(conn);
                  if (currentOperation == null || currentOperation.isEmpty()) {
                      continue;
                  }
                  if (waittime >= 1800000) {
                      final String msg = "This template is being used, try late time";
                      logger.warn(msg);
                      return msg;
                  }
                  waittime += 30000;
                  try {
                      Thread.sleep(30000);
                  } catch (final InterruptedException ignored) {
                  }
              }
              removeSR(conn, sr);
              return null;
          } catch (final XenAPIException e) {
              logger.warn(logX(sr, "Unable to get current operations " + e), e);
          } catch (final XmlRpcException e) {
              logger.warn(logX(sr, "Unable to get current operations " + e.getMessage()), e);
          }
          final String msg = "Remove SR failed";
          logger.warn(msg);
          return msg;
  
      }
  
      public String revertToSnapshot(final Connection conn, final VM vmSnapshot, final String vmName, final String oldVmUuid, final Boolean snapshotMemory, final String hostUUID)
              throws XenAPIException, XmlRpcException {
  
          final String results = callHostPluginAsync(conn, "vmopsSnapshot", "revert_memory_snapshot", 10 * 60 * 1000, "snapshotUUID", vmSnapshot.getUuid(conn), "vmName", vmName, "oldVmUuid", oldVmUuid,
                  "snapshotMemory", snapshotMemory.toString(), "hostUUID", hostUUID);
          String errMsg;
          if (results == null || results.isEmpty()) {
              errMsg = "revert_memory_snapshot return null";
          } else {
              if (results.equals("0")) {
                  return results;
              } else {
                  errMsg = "revert_memory_snapshot exception";
              }
          }
          logger.warn(errMsg);
          throw new CloudRuntimeException(errMsg);
      }
  
      public void scaleVM(final Connection conn, final VM vm, final VirtualMachineTO vmSpec, final Host host) throws XenAPIException, XmlRpcException {
  
          final Long staticMemoryMax = vm.getMemoryStaticMax(conn);
          final Long staticMemoryMin = vm.getMemoryStaticMin(conn);
          final Long newDynamicMemoryMin = vmSpec.getMinRam();
          final Long newDynamicMemoryMax = vmSpec.getMaxRam();
          if (staticMemoryMin > newDynamicMemoryMin || newDynamicMemoryMax > staticMemoryMax) {
              throw new CloudRuntimeException("Cannot scale up the vm because of memory constraint violation: " + "0 <= memory-static-min(" + staticMemoryMin + ") <= memory-dynamic-min("
                      + newDynamicMemoryMin + ") <= memory-dynamic-max(" + newDynamicMemoryMax + ") <= memory-static-max(" + staticMemoryMax + ")");
          }
  
          vm.setMemoryDynamicRange(conn, newDynamicMemoryMin, newDynamicMemoryMax);
          vm.setVCPUsNumberLive(conn, (long)vmSpec.getCpus());
  
          final Integer speed = vmSpec.getMinSpeed();
          if (speed != null) {
  
              int cpuWeight; // cpu_weight
  
              // weight based allocation
  
              cpuWeight = (int)(speed * 0.99 / _host.getSpeed() * _maxWeight);
              if (cpuWeight > _maxWeight) {
                  cpuWeight = _maxWeight;
              }
  
              if (vmSpec.isLimitCpuUse()) {
                  long utilization; // max CPU cap, default is unlimited
                  utilization = (int)(vmSpec.getMaxSpeed() * 0.99 * vmSpec.getCpus() / _host.getSpeed() * 100);
                  // vm.addToVCPUsParamsLive(conn, "cap",
                  // Long.toString(utilization)); currently xenserver doesnot
                  // support Xapi to add VCPUs params live.
                  callHostPlugin(conn, "vmops", "add_to_VCPUs_params_live", "key", "cap", "value", Long.toString(utilization), "vmname", vmSpec.getName());
              }
              // vm.addToVCPUsParamsLive(conn, "weight",
              // Integer.toString(cpuWeight));
              callHostPlugin(conn, "vmops", "add_to_VCPUs_params_live", "key", "weight", "value", Integer.toString(cpuWeight), "vmname", vmSpec.getName());
          }
      }
  
      @Override
      public void setAgentControl(final IAgentControl agentControl) {
          _agentControl = agentControl;
      }
  
      public void setCanBridgeFirewall(final boolean canBridgeFirewall) {
          _canBridgeFirewall = canBridgeFirewall;
      }
  
      @Override
      public void setConfigParams(final Map<String, Object> params) {
      }
  
      public boolean setIptables(final Connection conn) {
          final String result = callHostPlugin(conn, "vmops", "setIptables");
          return result != null && !result.isEmpty();
      }
  
      public void setIsOvs(final boolean isOvs) {
          _isOvs = isOvs;
      }
  
      /**
       * WARN: static-min <= dynamic-min <= dynamic-max <= static-max
       *
       * @see XcpServerResource#setMemory(com.xensource.xenapi.Connection,
       *      com.xensource.xenapi.VM, long, long)
       * @param conn
       * @param vm
       * @param minMemsize
       * @param maxMemsize
       * @throws XmlRpcException
       * @throws XenAPIException
       */
      protected void setMemory(final Connection conn, final VM vm, final long minMemsize, final long maxMemsize) throws XmlRpcException, XenAPIException {
          vm.setMemoryLimits(conn, mem_128m, maxMemsize, minMemsize, maxMemsize);
      }
  
      @Override
      public void setName(final String name) {
      }
  
      protected void setNicDevIdIfCorrectVifIsNotNull(final Connection conn, final IpAddressTO ip, final VIF correctVif)
              throws InternalErrorException, XenAPIException, XmlRpcException {
          if (correctVif == null) {
              if (ip.isAdd()) {
                  throw new InternalErrorException("Failed to find DomR VIF to associate IP with.");
              } else {
                  logger.debug("VIF to deassociate IP with does not exist, return success");
              }
          } else {
              ip.setNicDevId(Integer.valueOf(correctVif.getDevice(conn)));
          }
      }
  
      @Override
      public void setRunLevel(final int level) {
      }
  
      public String setupHeartbeatSr(final Connection conn, final SR sr, final boolean force) throws XenAPIException, XmlRpcException {
          final SR.Record srRec = sr.getRecord(conn);
          final String srUuid = srRec.uuid;
          if (!srRec.shared || !SRType.LVMOHBA.equals(srRec.type) && !SRType.LVMOISCSI.equals(srRec.type) && !SRType.NFS.equals(srRec.type)) {
              return srUuid;
          }
          String result;
          final Host host = Host.getByUuid(conn, _host.getUuid());
          final Set<String> tags = host.getTags(conn);
          if (force || !tags.contains("cloud-heartbeat-" + srUuid)) {
              if (logger.isDebugEnabled()) {
                  logger.debug("Setting up the heartbeat sr for host " + _host.getIp() + " and sr " + srUuid);
              }
              final Set<PBD> pbds = sr.getPBDs(conn);
              for (final PBD pbd : pbds) {
                  final PBD.Record pbdr = pbd.getRecord(conn);
                  if (!pbdr.currentlyAttached && pbdr.host.getUuid(conn).equals(_host.getUuid())) {
                      pbd.plug(conn);
                      break;
                  }
              }
              result = callHostPluginThroughMaster(conn, "vmopspremium", "setup_heartbeat_sr", "host", _host.getUuid(), "sr", srUuid);
              if (result == null || !result.split("#")[1].equals("0")) {
                  throw new CloudRuntimeException("Unable to setup heartbeat sr on SR " + srUuid + " due to " + result);
              }
  
              if (!tags.contains("cloud-heartbeat-" + srUuid)) {
                  tags.add("cloud-heartbeat-" + srUuid);
                  host.setTags(conn, tags);
              }
          }
          result = callHostPluginPremium(conn, "setup_heartbeat_file", "host", _host.getUuid(), "sr", srUuid, "add", "true");
          if (result == null || !result.split("#")[1].equals("0")) {
              throw new CloudRuntimeException("Unable to setup heartbeat file entry on SR " + srUuid + " due to " + result);
          }
          return srUuid;
      }
  
      public void setupLinkLocalNetwork(final Connection conn) {
          try {
              final Network.Record rec = new Network.Record();
              final Set<Network> networks = Network.getByNameLabel(conn, _linkLocalPrivateNetworkName);
              Network linkLocal;
  
              if (networks.isEmpty()) {
                  rec.nameDescription = "link local network used by system vms";
                  rec.nameLabel = _linkLocalPrivateNetworkName;
                  final Map<String, String> configs = new HashMap<>();
                  configs.put("ip_begin", NetUtils.getLinkLocalGateway());
                  configs.put("ip_end", NetUtils.getLinkLocalIpEnd());
                  configs.put("netmask", NetUtils.getLinkLocalNetMask());
                  configs.put("vswitch-disable-in-band", "true");
                  rec.otherConfig = configs;
                  rec.managed = true;
                  linkLocal = Network.create(conn, rec);
              } else {
                  linkLocal = networks.iterator().next();
                  if (!linkLocal.getOtherConfig(conn).containsKey("vswitch-disable-in-band")) {
                      linkLocal.addToOtherConfig(conn, "vswitch-disable-in-band", "true");
                  }
              }
  
              /* Make sure there is a physical bridge on this network */
              VIF dom0vif = null;
              final Pair<VM, VM.Record> vm = getControlDomain(conn);
              final VM dom0 = vm.first();
              final Set<VIF> vifs = dom0.getVIFs(conn);
              if (!vifs.isEmpty()) {
                  for (final VIF vif : vifs) {
                      final Map<String, String> otherConfig = vif.getOtherConfig(conn);
                      if (otherConfig != null) {
                          final String nameLabel = otherConfig.get("nameLabel");
                          if (nameLabel != null && nameLabel.equalsIgnoreCase("link_local_network_vif")) {
                              dom0vif = vif;
                          }
                      }
                  }
              }
  
              /* create temp VIF0 */
              if (dom0vif == null) {
                  logger.debug("Can't find a vif on dom0 for link local, creating a new one");
                  final VIF.Record vifr = new VIF.Record();
                  vifr.VM = dom0;
                  vifr.device = getLowestAvailableVIFDeviceNum(conn, dom0);
                  if (vifr.device == null) {
                      logger.debug("Failed to create link local network, no vif available");
                      return;
                  }
                  final Map<String, String> config = new HashMap<>();
                  config.put("nameLabel", "link_local_network_vif");
                  vifr.otherConfig = config;
                  vifr.MAC = "FE:FF:FF:FF:FF:FF";
                  vifr.network = linkLocal;
                  vifr.lockingMode = Types.VifLockingMode.NETWORK_DEFAULT;
                  dom0vif = VIF.create(conn, vifr);
                  plugDom0Vif(conn, dom0vif);
              } else {
                  logger.debug("already have a vif on dom0 for link local network");
                  if (!dom0vif.getCurrentlyAttached(conn)) {
                      plugDom0Vif(conn, dom0vif);
                  }
              }
  
              final String brName = linkLocal.getBridge(conn);
              callHostPlugin(conn, "vmops", "setLinkLocalIP", "brName", brName);
              _host.setLinkLocalNetwork(linkLocal.getUuid(conn));
  
          } catch (final XenAPIException | XmlRpcException e) {
              logger.warn("Unable to create local link network", e);
              throw new CloudRuntimeException("Unable to create local link network due to " + e, e);
          }
      }
  
      /* return : if setup is needed */
      public boolean setupServer(final Connection conn, final Host host) {
          final String packageVersion = CitrixResourceBase.class.getPackage().getImplementationVersion();
          final String version = this.getClass().getName() + "-" + (packageVersion == null ? Long.toString(System.currentTimeMillis()) : packageVersion);
  
          try {
              /* push patches to XenServer */
              final Host.Record hr = host.getRecord(conn);
  
              final Iterator<String> it = hr.tags.iterator();
  
              while (it.hasNext()) {
                  final String tag = it.next();
                  if (tag.startsWith("vmops-version-")) {
                      if (tag.contains(version)) {
                          logger.info(logX(host, "Host " + hr.address + " is already setup."));
                          return false;
                      } else {
                          it.remove();
                      }
                  }
              }
  
              final com.trilead.ssh2.Connection sshConnection = new com.trilead.ssh2.Connection(hr.address, 22);
              try {
                  sshConnection.connect(null, 60000, 60000);
                  if (!sshConnection.authenticateWithPassword(_username, _password.peek())) {
                      throw new CloudRuntimeException("Unable to authenticate");
                  }
  
                  final String cmd = "mkdir -p /opt/cloud/bin /var/log/cloud /opt/xensource/packages/resources/";
                  if (!SSHCmdHelper.sshExecuteCmd(sshConnection, cmd)) {
                      throw new CloudRuntimeException("Cannot create directory /opt/cloud/bin on XenServer hosts");
                  }
  
                  final SCPClient scp = new SCPClient(sshConnection);
  
                  final List<File> files = getPatchFiles();
                  if (files == null || files.isEmpty()) {
                      throw new CloudRuntimeException("Can not find patch file");
                  }
                  for (final File file : files) {
                      final String path = file.getParentFile().getAbsolutePath() + "/";
                      final Properties props = PropertiesUtil.loadFromFile(file);
  
                      for (final Map.Entry<Object, Object> entry : props.entrySet()) {
                          final String k = (String)entry.getKey();
                          final String v = (String)entry.getValue();
  
                          assert k != null && !k.isEmpty() && v != null && !v.isEmpty() : "Problems with " + k + "=" + v;
  
                          final String[] tokens = v.split(",");
                          String f;
                          if (tokens.length == 3 && !tokens[0].isEmpty()) {
                              if (tokens[0].startsWith("/")) {
                                  f = tokens[0];
                              } else if (tokens[0].startsWith("~")) {
                                  final String homedir = System.getenv("HOME");
                                  f = homedir + tokens[0].substring(1) + k;
                              } else {
                                  f = path + tokens[0] + '/' + k;
                              }
                          } else {
                              f = path + k;
                          }
                          final String directoryPath = tokens[tokens.length - 1];
  
                          f = f.replace('/', File.separatorChar);
  
                          String permissions = "0755";
                          if (tokens.length == 3) {
                              permissions = tokens[1];
                          } else if (tokens.length == 2) {
                              permissions = tokens[0];
                          }
  
                          if (!new File(f).exists()) {
                              logger.warn("We cannot locate " + f);
                              continue;
                          }
                          if (logger.isDebugEnabled()) {
                              logger.debug("Copying " + f + " to " + directoryPath + " on " + hr.address + " with permission " + permissions);
                          }
  
                          if (!SSHCmdHelper.sshExecuteCmd(sshConnection, "mkdir -m 700 -p " + directoryPath)) {
                              logger.debug("Unable to create destination path: " + directoryPath + " on " + hr.address + ".");
                          }
  
                          try {
                              scp.put(f, directoryPath, permissions);
                          } catch (final IOException e) {
                              final String msg = "Unable to copy file " + f + " to path " + directoryPath + " with permissions  " + permissions;
                              logger.debug(msg);
                              throw new CloudRuntimeException("Unable to setup the server: " + msg, e);
                          }
                      }
                  }
  
              } catch (final IOException e) {
                  throw new CloudRuntimeException("Unable to setup the server correctly", e);
              } finally {
                  sshConnection.close();
              }
              hr.tags.add("vmops-version-" + version);
              host.setTags(conn, hr.tags);
              return true;
          } catch (final XenAPIException e) {
              final String msg = "XenServer setup failed due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException("Unable to get host information " + e, e);
          } catch (final XmlRpcException e) {
              final String msg = "XenServer setup failed due to " + e.getMessage();
              logger.warn(msg, e);
              throw new CloudRuntimeException("Unable to get host information ", e);
          }
      }
  
      public synchronized Network setupvSwitchNetwork(final Connection conn) {
          try {
              if (_host.getVswitchNetwork() == null) {
                  Network vswitchNw;
                  final Network.Record rec = new Network.Record();
                  final String nwName = Networks.BroadcastScheme.VSwitch.toString();
                  final Set<Network> networks = Network.getByNameLabel(conn, nwName);
  
                  if (networks.isEmpty()) {
                      rec.nameDescription = "vswitch network for " + nwName;
                      rec.nameLabel = nwName;
                      rec.managed = true;
                      vswitchNw = Network.create(conn, rec);
                  } else {
                      vswitchNw = networks.iterator().next();
                  }
                  _host.setVswitchNetwork(vswitchNw);
              }
              return _host.getVswitchNetwork();
          } catch (final XmlRpcException | XenAPIException e) {
              logger.error("Failed to setup vswitch network", e);
          }
  
          return null;
      }
  
      public void shutdownVM(final Connection conn, final VM vm, final String vmName, final boolean forcedStop) throws XmlRpcException {
          Task task = null;
          try {
              if (forcedStop) {
                  task = vm.hardShutdownAsync(conn);
              } else {
                  task = vm.cleanShutdownAsync(conn);
              }
  
              try {
                  // poll every 1 seconds , timeout after 10 minutes
                  waitForTask(conn, task, 1000, 10 * 60 * 1000);
                  checkForSuccess(conn, task);
              } catch (final TimeoutException e) {
                  if (vm.getPowerState(conn) == VmPowerState.HALTED) {
                      task = null;
                      return;
                  }
                  throw new CloudRuntimeException("Shutdown VM catch HandleInvalid and VM is not in HALTED state");
              }
          } catch (final XenAPIException e) {
              logger.debug("Unable to shutdown VM(" + vmName + ") with force=" + forcedStop + " on host(" + _host.getUuid() + ") due to " + e);
              try {
                  VmPowerState state = vm.getPowerState(conn);
                  if (state == VmPowerState.RUNNING) {
                      try {
                          vm.hardShutdown(conn);
                      } catch (final Exception e1) {
                          logger.debug("Unable to hardShutdown VM(" + vmName + ") on host(" + _host.getUuid() + ") due to " + e);
                          state = vm.getPowerState(conn);
                          if (state == VmPowerState.RUNNING) {
                              forceShutdownVM(conn, vm);
                          }
                      }
                  } else if (state == VmPowerState.HALTED) {
                      // do nothing more
                  } else {
                      final String msg = "After cleanShutdown the VM status is " + state.toString() + ", that is not expected";
                      logger.warn(msg);
                      throw new CloudRuntimeException(msg);
                  }
              } catch (final Exception e1) {
                  final String msg = "Unable to hardShutdown VM(" + vmName + ") on host(" + _host.getUuid() + ") due to " + e;
                  logger.warn(msg, e1);
                  throw new CloudRuntimeException(msg);
              }
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e1) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e1);
                  }
              }
          }
      }
  
      @Override
      public boolean start() {
          return true;
      }
  
      public void startVM(final Connection conn, final Host host, final VM vm, final String vmName) throws Exception {
          Task task = null;
          try {
              task = vm.startOnAsync(conn, host, false, true);
              try {
                  // poll every 1 seconds , timeout after 10 minutes
                  waitForTask(conn, task, 1000, 10 * 60 * 1000);
                  checkForSuccess(conn, task);
              } catch (final Types.HandleInvalid e) {
                  if (vm.getPowerState(conn) == VmPowerState.RUNNING) {
                      logger.debug("VM " + vmName + " is in Running status", e);
                      task = null;
                      return;
                  }
                  throw new CloudRuntimeException("Start VM " + vmName + " catch HandleInvalid and VM is not in RUNNING state");
              } catch (final TimeoutException e) {
                  if (vm.getPowerState(conn) == VmPowerState.RUNNING) {
                      logger.debug("VM " + vmName + " is in Running status", e);
                      task = null;
                      return;
                  }
                  throw new CloudRuntimeException("Start VM " + vmName + " catch BadAsyncResult and VM is not in RUNNING state");
              }
          } catch (final XenAPIException e) {
              final String msg = "Unable to start VM(" + vmName + ") on host(" + _host.getUuid() + ") due to " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg);
          } finally {
              if (task != null) {
                  try {
                      task.destroy(conn);
                  } catch (final Exception e1) {
                      logger.debug("unable to destroy task(" + task + ") on host(" + _host.getUuid() + ") due to " + e1);
                  }
              }
          }
      }
  
      protected void startvmfailhandle(final Connection conn, final VM vm, final List<Ternary<SR, VDI, VolumeVO>> mounts) {
          if (vm != null) {
              try {
  
                  if (vm.getPowerState(conn) == VmPowerState.RUNNING) {
                      try {
                          vm.hardShutdown(conn);
                      } catch (final Exception e) {
                          final String msg = "VM hardshutdown failed due to " + e;
                          logger.warn(msg, e);
                      }
                  }
                  if (vm.getPowerState(conn) == VmPowerState.HALTED) {
                      try {
                          destroyVm(vm, conn, true);
                      } catch (final Exception e) {
                          final String msg = "VM destroy failed due to " + e;
                          logger.warn(msg, e);
                      }
                  }
              } catch (final Exception e) {
                  final String msg = "VM getPowerState failed due to " + e;
                  logger.warn(msg, e);
              }
          }
          if (mounts != null) {
              for (final Ternary<SR, VDI, VolumeVO> mount : mounts) {
                  final VDI vdi = mount.second();
                  Set<VBD> vbds;
                  try {
                      vbds = vdi.getVBDs(conn);
                  } catch (final Exception e) {
                      final String msg = "VDI getVBDS failed due to " + e;
                      logger.warn(msg, e);
                      continue;
                  }
                  for (final VBD vbd : vbds) {
                      try {
                          vbd.unplug(conn);
                          vbd.destroy(conn);
                      } catch (final Exception e) {
                          final String msg = "VBD destroy failed due to " + e;
                          logger.warn(msg, e);
                      }
                  }
              }
          }
      }
  
      @Override
      public boolean stop() {
          disconnected();
          return true;
      }
  
      private HashMap<String, Pair<Long, Long>> syncNetworkGroups(final Connection conn, final long id) {
          final HashMap<String, Pair<Long, Long>> states = new HashMap<>();
  
          final String result = callHostPlugin(conn, "vmops", "get_rule_logs_for_vms", "host_uuid", _host.getUuid());
          logger.trace("syncNetworkGroups: id=" + id + " got: " + result);
          final String[] rulelogs = result != null ? result.split(";") : new String[0];
          for (final String rulesforvm : rulelogs) {
              final String[] log = rulesforvm.split(",");
              if (log.length != 6) {
                  continue;
              }
              // output = ','.join([vmName, vmID, vmIP, domID, signature, seqno])
              try {
                  states.put(log[0], new Pair<>(Long.parseLong(log[1]), Long.parseLong(log[5])));
              } catch (final NumberFormatException nfe) {
                  states.put(log[0], new Pair<>(-1L, -1L));
              }
          }
          return states;
      }
  
      public boolean transferManagementNetwork(final Connection conn, final Host host, final PIF src, final PIF.Record spr, final PIF dest) throws XmlRpcException, XenAPIException {
          dest.reconfigureIp(conn, spr.ipConfigurationMode, spr.IP, spr.netmask, spr.gateway, spr.DNS);
          Host.managementReconfigure(conn, dest);
          String hostUuid = null;
          int count = 0;
          while (count < 10) {
              try {
                  Thread.sleep(10000);
                  hostUuid = host.getUuid(conn);
                  if (hostUuid != null) {
                      break;
                  }
                  ++count;
              } catch (final XmlRpcException | XenAPIException e) {
                  logger.debug("Waiting for host to come back: " + e.getMessage());
              } catch (final InterruptedException e) {
                  logger.debug("Gotta run");
                  return false;
              }
          }
          if (hostUuid == null) {
              logger.warn("Unable to transfer the management network from " + spr.uuid);
              return false;
          }
  
          src.reconfigureIp(conn, Types.IpConfigurationMode.NONE, null, null, null, null);
          return true;
      }
  
      protected void umount(final Connection conn, final VDI vdi) {
  
      }
  
      public void umountSnapshotDir(final Connection conn, final Long dcId) {
          try {
              callHostPlugin(conn, "vmopsSnapshot", "unmountSnapshotsDir", "dcId", dcId.toString());
          } catch (final Exception e) {
              logger.debug("Failed to umount snapshot dir", e);
          }
      }
  
      public String upgradeSnapshot(final Connection conn, final String templatePath, final String snapshotPath) {
          final String results = callHostPluginAsync(conn, "vmopspremium", "upgrade_snapshot", 2 * 60 * 60, "templatePath", templatePath, "snapshotPath", snapshotPath);
  
          if (results == null || results.isEmpty()) {
              final String msg = "upgrade_snapshot return null";
              logger.warn(msg);
              throw new CloudRuntimeException(msg);
          }
          final String[] tmp = results.split("#");
          final String status = tmp[0];
          if (status.equals("0")) {
              return results;
          } else {
              logger.warn(results);
              throw new CloudRuntimeException(results);
          }
      }
  
      public void waitForTask(final Connection c, final Task task, final long pollInterval, final long timeout) throws XenAPIException, XmlRpcException, TimeoutException {
          final long beginTime = System.currentTimeMillis();
          if (logger.isTraceEnabled()) {
              logger.trace("Task " + task.getNameLabel(c) + " (" + task.getUuid(c) + ") sent to " + c.getSessionReference() + " is pending completion with a " + timeout + "ms timeout");
          }
          while (task.getStatus(c) == Types.TaskStatusType.PENDING) {
              try {
                  if (logger.isTraceEnabled()) {
                      logger.trace("Task " + task.getNameLabel(c) + " (" + task.getUuid(c) + ") is pending, sleeping for " + pollInterval + "ms");
                  }
                  Thread.sleep(pollInterval);
              } catch (final InterruptedException ignored) {
              }
              if (System.currentTimeMillis() - beginTime > timeout) {
                  final String msg = "Async " + timeout / 1000 + " seconds timeout for task " + task;
                  logger.warn(msg);
                  task.cancel(c);
                  task.destroy(c);
                  throw new TimeoutException(msg);
              }
          }
      }
  
      public boolean createAndAttachConfigDriveIsoForVM(final Connection conn, final VM vm, final List<String[]> vmDataList, final String configDriveLabel) throws XenAPIException, XmlRpcException {
  
          final String vmName = vm.getNameLabel(conn);
  
          // create SR
          final SR sr = createLocalIsoSR(conn, _configDriveSRName + _host.getIp());
          if (sr == null) {
              logger.debug("Failed to create local SR for the config drive");
              return false;
          }
  
          logger.debug("Creating vm data files in config drive for vm " + vmName);
          // 1. create vm data files
          if (!createVmdataFiles(vmName, vmDataList, configDriveLabel)) {
              logger.debug("Failed to create vm data files in config drive for vm " + vmName);
              return false;
          }
  
          // 2. copy config drive iso to host
          if (!copyConfigDriveIsoToHost(conn, sr, vmName)) {
              return false;
          }
  
          // 3. attachIsoToVM
          return attachConfigDriveIsoToVm(conn, vm);
      }
  
      public boolean createVmdataFiles(final String vmName, final List<String[]> vmDataList, final String configDriveLabel) {
  
          // add vm iso to the isolibrary
          final String isoPath = "/tmp/" + vmName + "/configDrive/";
          final String configDriveName = "cloudstack/";
  
          //create folder for the VM
          //Remove the folder before creating it.
  
          try {
              deleteLocalFolder("/tmp/" + isoPath);
          } catch (final Exception e) {
              logger.debug("Failed to delete the exiting config drive for vm " + vmName + " " + e.getMessage());
          }
  
          if (vmDataList != null) {
              for (final String[] item : vmDataList) {
                  final String dataType = item[0];
                  final String fileName = item[1];
                  final String content = item[2];
  
                  // create file with content in folder
  
                  if (dataType != null && !dataType.isEmpty()) {
                      //create folder
                      final String folder = isoPath + configDriveName + dataType;
                      if (folder != null && !folder.isEmpty()) {
                          final File dir = new File(folder);
                          final boolean result = true;
  
                          try {
                              if (!dir.exists()) {
                                  dir.mkdirs();
                              }
                          } catch (final SecurityException ex) {
                              logger.debug("Failed to create dir " + ex.getMessage());
                              return false;
                          }
  
                          if (result && content != null && !content.isEmpty()) {
                              File file = new File(folder + "/" + fileName + ".txt");
                              try (OutputStreamWriter fw = new OutputStreamWriter(new FileOutputStream(file.getAbsoluteFile()), StringUtils.getPreferredCharset());
                                   BufferedWriter bw = new BufferedWriter(fw)) {
                                  bw.write(content);
                                  logger.debug("created file: " + file + " in folder:" + folder);
                              } catch (final IOException ex) {
                                  logger.debug("Failed to create file " + ex.getMessage());
                                  return false;
                              }
                          }
                      }
                  }
              }
              logger.debug("Created the vm data in " + isoPath);
          }
  
          String s;
          try {
  
              final String cmd = "mkisofs -iso-level 3 -V " + configDriveLabel + " -o " + isoPath + vmName + ".iso " + isoPath;
              final Process p = Runtime.getRuntime().exec(cmd);
  
              final BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.defaultCharset()));
  
              final BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream(), Charset.defaultCharset()));
  
              // read the output from the command
              while ((s = stdInput.readLine()) != null) {
                  logger.debug(s);
              }
  
              // read any errors from the attempted command
              while ((s = stdError.readLine()) != null) {
                  logger.debug(s);
              }
              logger.debug(" Created config drive ISO using the command " + cmd + " in the host " + _host.getIp());
          } catch (final IOException e) {
              logger.debug(e.getMessage());
              return false;
          }
  
          return true;
      }
  
      public boolean copyConfigDriveIsoToHost(final Connection conn, final SR sr, final String vmName) {
  
          final String vmIso = "/tmp/" + vmName + "/configDrive/" + vmName + ".iso";
          //scp file into the host
          final com.trilead.ssh2.Connection sshConnection = new com.trilead.ssh2.Connection(_host.getIp(), 22);
  
          try {
              sshConnection.connect(null, 60000, 60000);
              if (!sshConnection.authenticateWithPassword(_username, _password.peek())) {
                  throw new CloudRuntimeException("Unable to authenticate");
              }
  
              logger.debug("scp config drive iso file " + vmIso + " to host " + _host.getIp() + " path " + _configDriveIsopath);
              final SCPClient scp = new SCPClient(sshConnection);
              final String p = "0755";
  
              scp.put(vmIso, _configDriveIsopath, p);
              sr.scan(conn);
              logger.debug("copied config drive iso to host " + _host);
          } catch (final IOException e) {
              logger.debug("failed to copy configdrive iso " + vmIso + " to host " + _host, e);
              return false;
          } catch (final XmlRpcException e) {
              logger.debug("Failed to scan config drive iso SR " + _configDriveSRName + _host.getIp() + " in host " + _host, e);
              return false;
          } finally {
              sshConnection.close();
              //clean up the config drive files
  
              final String configDir = "/tmp/" + vmName;
              try {
                  deleteLocalFolder(configDir);
                  logger.debug("Successfully cleaned up config drive directory " + configDir + " after copying it to host ");
              } catch (final Exception e) {
                  logger.debug("Failed to delete config drive folder :" + configDir + " for VM " + vmName + " " + e.getMessage());
              }
          }
  
          return true;
      }
  
      public boolean attachConfigDriveIsoToVm(final Connection conn, final VM vm) throws XenAPIException, XmlRpcException {
  
          final String vmName = vm.getNameLabel(conn);
          final String isoURL = _configDriveIsopath + vmName + ".iso";
          VDI srVdi;
  
          //1. find the vdi of the iso
          //2. find the vbd for the vdi
          //3. attach iso to vm
  
          try {
              final Set<VDI> vdis = VDI.getByNameLabel(conn, vmName + ".iso");
              if (vdis.isEmpty()) {
                  throw new CloudRuntimeException("Could not find ISO with URL: " + isoURL);
              }
              srVdi = vdis.iterator().next();
  
          } catch (final Exception e) {
              logger.debug("Unable to get config drive iso: " + isoURL + " due to " + e);
              return false;
          }
  
          VBD isoVBD = null;
  
          // Find the VM's CD-ROM VBD
          final Set<VBD> vbds = vm.getVBDs(conn);
          for (final VBD vbd : vbds) {
              final Types.VbdType type = vbd.getType(conn);
  
              final VBD.Record vbdr = vbd.getRecord(conn);
  
              // if the device exists then attach it
              if (!vbdr.userdevice.equals(_attachIsoDeviceNum) && type == Types.VbdType.CD) {
                  isoVBD = vbd;
                  break;
              }
          }
  
          if (isoVBD == null) {
              //create vbd
              final VBD.Record cfgDriveVbdr = new VBD.Record();
              cfgDriveVbdr.VM = vm;
              cfgDriveVbdr.empty = true;
              cfgDriveVbdr.bootable = false;
              cfgDriveVbdr.userdevice = "autodetect";
              cfgDriveVbdr.mode = Types.VbdMode.RO;
              cfgDriveVbdr.type = Types.VbdType.CD;
              isoVBD = VBD.create(conn, cfgDriveVbdr);
  
              logger.debug("Created CD-ROM VBD for VM: " + vm);
          }
  
          if (isoVBD != null) {
              // If an ISO is already inserted, eject it
              if (isoVBD.getEmpty(conn) == false) {
                  isoVBD.eject(conn);
              }
  
              try {
                  // Insert the new ISO
                  isoVBD.insert(conn, srVdi);
                  logger.debug("Attached config drive iso to vm " + vmName);
              } catch (final XmlRpcException ex) {
                  logger.debug("Failed to attach config drive iso to vm " + vmName);
                  return false;
              }
          }
  
          return true;
      }
  
      public SR createLocalIsoSR(final Connection conn, final String srName) throws XenAPIException, XmlRpcException {
  
          // if config drive sr already exists then return
          SR sr = getSRByNameLabelandHost(conn, srName);
  
          if (sr != null) {
              logger.debug("Config drive SR already exist, returing it");
              return sr;
          }
  
          try {
              final Map<String, String> deviceConfig = new HashMap<>();
  
              final com.trilead.ssh2.Connection sshConnection = new com.trilead.ssh2.Connection(_host.getIp(), 22);
              try {
                  sshConnection.connect(null, 60000, 60000);
                  if (!sshConnection.authenticateWithPassword(_username, _password.peek())) {
                      throw new CloudRuntimeException("Unable to authenticate");
                  }
  
                  final String cmd = "mkdir -p " + _configDriveIsopath;
                  if (!SSHCmdHelper.sshExecuteCmd(sshConnection, cmd)) {
                      throw new CloudRuntimeException("Cannot create directory configdrive_iso on XenServer hosts");
                  }
              } catch (final IOException e) {
                  throw new CloudRuntimeException("Unable to create iso folder", e);
              } finally {
                  sshConnection.close();
              }
              logger.debug("Created the config drive SR " + srName + " folder path " + _configDriveIsopath);
  
              deviceConfig.put("location", _configDriveIsopath);
              deviceConfig.put("legacy_mode", "true");
              final Host host = Host.getByUuid(conn, _host.getUuid());
              final String type = SRType.ISO.toString();
              sr = SR.create(conn, host, deviceConfig, 0L, _configDriveIsopath, "iso", type, "iso", false, new HashMap<>());
  
              sr.setNameLabel(conn, srName);
              sr.setNameDescription(conn, deviceConfig.get("location"));
  
              sr.scan(conn);
              logger.debug("Config drive ISO SR at the path " + _configDriveIsopath + " got created in host " + _host);
              return sr;
          } catch (final XenAPIException e) {
              final String msg = "createLocalIsoSR failed! mountpoint " + e;
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          } catch (final Exception e) {
              final String msg = "createLocalIsoSR failed! mountpoint:  due to " + e.getMessage();
              logger.warn(msg, e);
              throw new CloudRuntimeException(msg, e);
          }
  
      }
  
      public void deleteLocalFolder(final String directory) throws Exception {
          if (directory == null || directory.isEmpty()) {
              final String msg = "Invalid directory path (null/empty) detected. Cannot delete specified directory.";
              logger.debug(msg);
              throw new Exception(msg);
          }
  
          try {
              FileUtils.deleteDirectory(new File(directory));
          } catch (final IOException e) {
              // IOException here means failure to delete. Not swallowing it here to
              // let the caller handle with appropriate contextual log message.
              throw e;
          }
      }
  
      protected SR getSRByNameLabel(Connection conn, String name) throws XenAPIException, XmlRpcException {
          Set<SR> srs = SR.getByNameLabel(conn, name);
          SR ressr = null;
          for (SR sr : srs) {
              Set<PBD> pbds;
              pbds = sr.getPBDs(conn);
              for (PBD pbd : pbds) {
                  PBD.Record pbdr = pbd.getRecord(conn);
                  if (pbdr.host != null) {
                      ressr = sr;
                      break;
                  }
              }
          }
          return ressr;
      }
  
      public boolean attachConfigDriveToMigratedVm(Connection conn, String vmName, String ipAddr) {
  
          // attach the config drive in destination host
  
          try {
              logger.debug("Attaching config drive iso device for the VM " + vmName + " In host " + ipAddr);
              Set<VM> vms = VM.getByNameLabel(conn, vmName);
  
              SR sr = getSRByNameLabel(conn, vmName + VM_NAME_CONFIGDRIVE_ISO_SUFFIX);
              //Here you will find only two vdis with the <vmname>.iso.
              //one is from source host and second from dest host
              Set<VDI> vdis = VDI.getByNameLabel(conn, vmName + VM_FILE_ISO_SUFFIX);
              if (vdis.isEmpty()) {
                  logger.debug("Could not find config drive ISO: " + vmName);
                  return false;
              }
  
              VDI configdriveVdi = null;
              for (VDI vdi : vdis) {
                  SR vdiSr = vdi.getSR(conn);
                  if (vdiSr.getUuid(conn).equals(sr.getUuid(conn))) {
                      //get this vdi to attach to vbd
                      configdriveVdi = vdi;
                      logger.debug("VDI for the config drive ISO  " + vdi);
                  } else {
                      // delete the vdi in source host so that the <vmname>.iso file is get removed
                      logger.debug("Removing the source host VDI for the config drive ISO  " + vdi);
                      vdi.destroy(conn);
                  }
              }
  
              if (configdriveVdi == null) {
                  logger.debug("Config drive ISO VDI is not found ");
                  return false;
              }
  
              for (VM vm : vms) {
  
                  //create vbd
                  VBD.Record cfgDriveVbdr = new VBD.Record();
                  cfgDriveVbdr.VM = vm;
                  cfgDriveVbdr.empty = true;
                  cfgDriveVbdr.bootable = false;
                  cfgDriveVbdr.userdevice = "autodetect";
                  cfgDriveVbdr.mode = Types.VbdMode.RO;
                  cfgDriveVbdr.type = Types.VbdType.CD;
  
                  VBD cfgDriveVBD = VBD.create(conn, cfgDriveVbdr);
  
                  logger.debug("Inserting vbd " + configdriveVdi);
                  cfgDriveVBD.insert(conn, configdriveVdi);
                  break;
  
              }
  
              return true;
  
          } catch (BadServerResponse e) {
              logger.warn("Failed to attach config drive ISO to the VM  " + vmName + " In host " + ipAddr + " due to a bad server response.", e);
              return false;
          } catch (XenAPIException e) {
              logger.warn("Failed to attach config drive ISO to the VM  " + vmName + " In host " + ipAddr + " due to a xapi problem.", e);
              return false;
          } catch (XmlRpcException e) {
              logger.warn("Failed to attach config drive ISO to the VM  " + vmName + " In host " + ipAddr + " due to a problem in a remote call.", e);
              return false;
          }
  
      }
  
      public Answer listFilesAtPath(ListDataStoreObjectsCommand command) throws IOException, XmlRpcException {
          DataStoreTO store = command.getStore();
          int startIndex = command.getStartIndex();
          int pageSize = command.getPageSize();
          String relativePath = command.getPath();
          if (relativePath.endsWith("/")) {
              relativePath = relativePath.substring(0, relativePath.length() - 1);
          }
  
          final Connection conn = getConnection();
  
          final SR sr = getStorageRepository(conn, store.getUuid());
          final com.trilead.ssh2.Connection sshConnection = new com.trilead.ssh2.Connection(_host.getIp(), 22);
          try {
              sshConnection.connect(null, 60000, 60000);
              if (!sshConnection.authenticateWithPassword(_username, _password.peek())) {
                  throw new CloudRuntimeException("Unable to authenticate");
              }
              String mountPoint = "/var/run/sr-mount/" + sr.getUuid(conn);
              boolean pathExists = true;
              SFTPv3FileAttributes fileAttr;
              int count = 0;
              List<String> names = new ArrayList<>();
              List<String> paths = new ArrayList<>();
              List<String> absPaths = new ArrayList<>();
              List<Boolean> isDirs = new ArrayList<>();
              List<Long> sizes = new ArrayList<>();
              List<Long> modifiedList = new ArrayList<>();
              SFTPv3Client client = new SFTPv3Client(sshConnection);
              try {
                  fileAttr = client._stat(mountPoint + "/" + relativePath);
  
                  // Path doesn't exist
                  if (fileAttr == null) {
                      return new ListDataStoreObjectsAnswer(false, count, names, paths, absPaths, isDirs, sizes, modifiedList);
                  }
  
                  try {
                      Vector fileList = client.ls(mountPoint + "/" + relativePath);
                      count = fileList.size() - 2; // -2 for . and ..
                      for (int i = startIndex + 2; i < startIndex + pageSize + 2 && i < fileList.size(); i++) {
                          SFTPv3DirectoryEntry entry = (SFTPv3DirectoryEntry) fileList.get(i);
                          names.add(entry.filename);
                          paths.add(relativePath + "/" + entry.filename);
                          isDirs.add(entry.attributes.isDirectory());
                          sizes.add(entry.attributes.size);
                          modifiedList.add(entry.attributes.mtime * 1000L);
                      }
                  } catch (SFTPException e) {
                      // Path is a file
                      count = 1;
                      names.add(relativePath.substring(relativePath.lastIndexOf("/") + 1));
                      paths.add(relativePath);
                      isDirs.add(false);
                      sizes.add(fileAttr.size);
                      modifiedList.add(fileAttr.mtime * 1000L);
                  }
              } finally {
                  client.close();
              }
              return new ListDataStoreObjectsAnswer(pathExists, count, names, paths, absPaths, isDirs, sizes, modifiedList);
          } finally {
              sshConnection.close();
          }
      }
  
      /**
       * Get Diagnostics Data API
       * Copy zip file from system vm and copy file directly to secondary storage
       */
      public Answer copyDiagnosticsFileToSecondaryStorage(Connection conn, CopyToSecondaryStorageCommand cmd) {
          String secondaryStorageUrl = cmd.getSecondaryStorageUrl();
          String vmIP = cmd.getSystemVmIp();
          String diagnosticsZipFile = cmd.getFileName();
          String nfsVersion = cmd.getNfsVersion();
  
          String localDir = null;
  
          // Mount Secondary storage
          String secondaryStorageMountPath = null;
          try {
              URI uri = new URI(secondaryStorageUrl);
              secondaryStorageMountPath = uri.getHost() + ":" + uri.getPath();
              localDir = BASE_MOUNT_POINT_ON_REMOTE + UuidUtils.nameUUIDFromBytes(secondaryStorageMountPath.getBytes());
              String mountPoint = mountNfs(conn, secondaryStorageMountPath, localDir, nfsVersion);
              if (StringUtils.isBlank(mountPoint)) {
                  return new CopyToSecondaryStorageAnswer(cmd, false, "Could not mount secondary storage " + secondaryStorageMountPath + " on host " + localDir);
              }
  
              String dataDirectoryInSecondaryStore = localDir + File.separator + DiagnosticsService.DIAGNOSTICS_DIRECTORY;
              final CopyToSecondaryStorageAnswer answer;
              final String scpResult = callHostPlugin(conn, "vmops", "secureCopyToHost", "hostfilepath", dataDirectoryInSecondaryStore,
                      "srcip", vmIP, "srcfilepath", cmd.getFileName()).toLowerCase();
  
              if (scpResult.contains("success")) {
                  answer = new CopyToSecondaryStorageAnswer(cmd, true, "File copied to secondary storage successfully.");
              } else {
                  answer = new CopyToSecondaryStorageAnswer(cmd, false, "Zip file " + diagnosticsZipFile.replace("/root/", "") + "could not be copied to secondary storage due to " + scpResult);
              }
              umountNfs(conn, secondaryStorageMountPath, localDir);
              localDir = null;
              return answer;
          } catch (Exception e) {
              String msg = "Exception caught zip file copy to secondary storage URI: " + secondaryStorageUrl + "Exception : " + e;
              logger.error(msg, e);
              return new CopyToSecondaryStorageAnswer(cmd, false, msg);
          } finally {
              if (localDir != null) umountNfs(conn, secondaryStorageMountPath, localDir);
          }
      }
  
      private String mountNfs(Connection conn, String remoteDir, String localDir, String nfsVersion) {
          if (localDir == null) {
              localDir = BASE_MOUNT_POINT_ON_REMOTE + UuidUtils.nameUUIDFromBytes(remoteDir.getBytes());
          }
          return callHostPlugin(conn, "cloud-plugin-storage", "mountNfsSecondaryStorage", "localDir", localDir, "remoteDir", remoteDir, "nfsVersion", nfsVersion);
      }
  
      // Unmount secondary storage from host
      private void umountNfs(Connection conn, String remoteDir, String localDir) {
          if (localDir == null) {
              localDir = BASE_MOUNT_POINT_ON_REMOTE + UuidUtils.nameUUIDFromBytes(remoteDir.getBytes());
          }
          String result = callHostPlugin(conn, "cloud-plugin-storage", "umountNfsSecondaryStorage", "localDir", localDir, "remoteDir", remoteDir);
          if (StringUtils.isBlank(result)) {
              String errMsg = "Could not umount secondary storage " + remoteDir + " on host " + localDir;
              logger.warn(errMsg);
          }
      }
  
      public boolean isDestroyHaltedVms() {
          ComparableVersion version = new ComparableVersion(getHost().getProductVersion());
          return version.compareTo(new ComparableVersion("8.0")) < 0;
      }
  
      public void destroyVm(VM vm, Connection connection, boolean forced) throws XenAPIException, XmlRpcException {
          if (!isDestroyHaltedVms() && !forced) {
              return;
          }
          vm.destroy(connection);
      }
  
      public void destroyVm(VM vm, Connection connection) throws XenAPIException, XmlRpcException {
          destroyVm(vm, connection, false);
      }
  }
  