// 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.

    private static final Logger s_logger = Logger.getLogger(VirtualMachineMO.class);

    private static final ExecutorService _monitorServiceExecutor = Executors.newCachedThreadPool(new NamedThreadFactory("VM-Question-Monitor"));

    private ManagedObjectReference _vmEnvironmentBrowser = null;

  public VirtualMachineMO(VmwareContext context, ManagedObjectReference morVm) {

    super(context, morVm);

  }

  public VirtualMachineMO(VmwareContext context, String morType, String morValue) {

    super(context, morType, morValue);

  }

  public Pair<DatacenterMO, String> getOwnerDatacenter() throws Exception {

    return DatacenterMO.getOwnerDatacenter(getContext(), getMor());

  }

  public Pair<DatastoreMO, String> getOwnerDatastore(String dsFullPath) throws Exception {

    String dsName = DatastoreFile.getDatastoreNameFromPath(dsFullPath);

    PropertySpec pSpec = new PropertySpec();

    pSpec.setType("Datastore");

    pSpec.getPathSet().add("name");

      TraversalSpec vmDatastoreTraversal = new TraversalSpec();

      vmDatastoreTraversal.setType("VirtualMachine");

      vmDatastoreTraversal.setPath("datastore");

      vmDatastoreTraversal.setName("vmDatastoreTraversal");

      ObjectSpec oSpec = new ObjectSpec();

      oSpec.setObj(_mor);

      oSpec.setSkip(Boolean.TRUE);

      oSpec.getSelectSet().add(vmDatastoreTraversal);

      PropertyFilterSpec pfSpec = new PropertyFilterSpec();

      pfSpec.getPropSet().add(pSpec);

      pfSpec.getObjectSet().add(oSpec);

        List<PropertyFilterSpec> pfSpecArr = new ArrayList<PropertyFilterSpec>();

        pfSpecArr.add(pfSpec);

      List<ObjectContent> ocs = _context.getService().retrieveProperties(

        _context.getPropertyCollector(), pfSpecArr);

      if(ocs != null) {

        for(ObjectContent oc : ocs) {

          DynamicProperty prop = oc.getPropSet().get(0);

          if(prop.getVal().toString().equals(dsName)) {

            return new Pair<DatastoreMO, String>(new DatastoreMO(_context, oc.getObj()), dsName);

          }

        }

      }

    return null;

  }

  public HostMO getRunningHost() throws Exception {

    VirtualMachineRuntimeInfo runtimeInfo = getRuntimeInfo();

    return new HostMO(_context, runtimeInfo.getHost());

  }

  public String getVmName() throws Exception {

    return (String)getContext().getVimClient().getDynamicProperty(_mor, "name");

  }

  public GuestInfo getVmGuestInfo() throws Exception {

    return (GuestInfo)getContext().getVimClient().getDynamicProperty(_mor, "guest");

  }

    public void answerVM(String questionId, String choice) throws Exception {

        getContext().getService().answerVM(_mor, questionId, choice);

    }

  public boolean isVMwareToolsRunning() throws Exception {

    GuestInfo guestInfo = getVmGuestInfo();

    if(guestInfo != null) {

      if("guestToolsRunning".equalsIgnoreCase(guestInfo.getToolsRunningStatus()))

        return true;

    }

    return false;

  }

  public boolean powerOn() throws Exception {

    if(getPowerState() == VirtualMachinePowerState.POWERED_ON)

      return true;

    ManagedObjectReference morTask = _context.getService().powerOnVMTask(_mor, null);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      return true;

    } else {

          s_logger.error("VMware powerOnVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

  public boolean powerOff() throws Exception {

    if(getPowerState() == VirtualMachinePowerState.POWERED_OFF)

      return true;

    return powerOffNoCheck();

  }

  public boolean safePowerOff(int shutdownWaitMs) throws Exception {

    if(getPowerState() == VirtualMachinePowerState.POWERED_OFF)

      return true;

    if(isVMwareToolsRunning()) {

      try {

        String vmName = getName();

        s_logger.info("Try gracefully shut down VM " + vmName);

        shutdown();

        long startTick = System.currentTimeMillis();

        while(getPowerState() != VirtualMachinePowerState.POWERED_OFF && System.currentTimeMillis() - startTick < shutdownWaitMs) {

          try {

            Thread.sleep(1000);

          } catch(InterruptedException e) {

          }

        }

        if(getPowerState() != VirtualMachinePowerState.POWERED_OFF) {

          s_logger.info("can not gracefully shutdown VM within " + (shutdownWaitMs/1000) + " seconds, we will perform force power off on VM " + vmName);

          return powerOffNoCheck();

        }

        return true;

      } catch(Exception e) {

        s_logger.warn("Failed to do guest-os graceful shutdown due to " + VmwareHelper.getExceptionMessage(e));

      }

    }

    return powerOffNoCheck();

  }

  private boolean powerOffNoCheck() throws Exception {

    ManagedObjectReference morTask = _context.getService().powerOffVMTask(_mor);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

       // It seems that even if a power-off task is returned done, VM state may still not be marked,

      // wait up to 5 seconds to make sure to avoid race conditioning for immediate following on operations

      // that relies on a powered-off VM

      long startTick = System.currentTimeMillis();

      while(getPowerState() != VirtualMachinePowerState.POWERED_OFF && System.currentTimeMillis() - startTick < 5000) {

        try {

          Thread.sleep(1000);

        } catch(InterruptedException e) {

        }

      }

      return true;

    } else {

       if(getPowerState() == VirtualMachinePowerState.POWERED_OFF) {

         // to help deal with possible race-condition

         s_logger.info("Current power-off task failed. However, VM has been switched to the state we are expecting for");

         return true;

       }

          s_logger.error("VMware powerOffVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

  public VirtualMachinePowerState getPowerState() throws Exception {

      VirtualMachinePowerState powerState = VirtualMachinePowerState.POWERED_OFF;

      // This is really ugly, there is a case that when windows guest VM is doing sysprep, the temporary

      // rebooting process may let us pick up a "poweredOff" state during VMsync process, this can trigger

      // a series actions. Unfortunately, from VMware API we can not distinguish power state into such details.

      // We hope by giving it 3 second to re-read the state can cover this as a short-term solution.

      //

      // In the future, VMsync should not kick off CloudStack action (this is not a HA case) based on VM

      // state report, until then we can remove this hacking fix

      for(int i = 0; i < 3; i++) {

          powerState = (VirtualMachinePowerState)getContext().getVimClient().getDynamicProperty(_mor, "runtime.powerState");

          if(powerState == VirtualMachinePowerState.POWERED_OFF) {

              try {

                  Thread.sleep(1000);

              } catch(InterruptedException e) {

              }

          } else {

              break;

          }

      }

      return powerState;

  }

  public boolean reset() throws Exception {

    ManagedObjectReference morTask = _context.getService().resetVMTask(_mor);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      return true;

    } else {

          s_logger.error("VMware resetVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

  public void shutdown() throws Exception {

    _context.getService().shutdownGuest(_mor);

  }

  public void rebootGuest() throws Exception {

    _context.getService().rebootGuest(_mor);

  }

  public void markAsTemplate() throws Exception {

    _context.getService().markAsTemplate(_mor);

  }

  public boolean isTemplate() throws Exception {

    VirtualMachineConfigInfo configInfo = getConfigInfo();

    return configInfo.isTemplate();

  }

  public boolean migrate(ManagedObjectReference morRp, ManagedObjectReference morTargetHost) throws Exception {

    ManagedObjectReference morTask = _context.getService().migrateVMTask(_mor,

      morRp, morTargetHost, VirtualMachineMovePriority.DEFAULT_PRIORITY, null);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      return true;

    } else {

          s_logger.error("VMware migrateVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

    public boolean changeDatastore(VirtualMachineRelocateSpec relocateSpec) throws Exception {

        ManagedObjectReference morTask = _context.getVimClient().getService().relocateVMTask(_mor, relocateSpec, VirtualMachineMovePriority.DEFAULT_PRIORITY);

        boolean result = _context.getVimClient().waitForTask(morTask);

        if(result) {

            _context.waitForTaskProgressDone(morTask);

            return true;

        } else {

            s_logger.error("VMware RelocateVM_Task to change datastore failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

        }

        return false;

    }

    public boolean changeHost(VirtualMachineRelocateSpec relocateSpec) throws Exception {

        ManagedObjectReference morTask = _context.getService().relocateVMTask(_mor, relocateSpec, VirtualMachineMovePriority.DEFAULT_PRIORITY);

        boolean result = _context.getVimClient().waitForTask(morTask);

        if (result) {

            _context.waitForTaskProgressDone(morTask);

            return true;

        } else {

            s_logger.error("VMware RelocateVM_Task to change host failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

        }

        return false;

    }

  public boolean relocate(ManagedObjectReference morTargetHost) throws Exception {

      VirtualMachineRelocateSpec relocateSpec = new VirtualMachineRelocateSpec();

      relocateSpec.setHost(morTargetHost);

        ManagedObjectReference morTask = _context.getService().relocateVMTask(_mor,

            relocateSpec, null);

        boolean result = _context.getVimClient().waitForTask(morTask);

        if(result) {

            _context.waitForTaskProgressDone(morTask);

            return true;

        } else {

          s_logger.error("VMware relocateVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

        }

        return false;

  }

  public VirtualMachineSnapshotInfo getSnapshotInfo() throws Exception {

    return (VirtualMachineSnapshotInfo)_context.getVimClient().getDynamicProperty(_mor, "snapshot");

  }

  public boolean createSnapshot(String snapshotName, String snapshotDescription,

    boolean dumpMemory, boolean quiesce) throws Exception {

    ManagedObjectReference morTask = _context.getService().createSnapshotTask(_mor, snapshotName,

      snapshotDescription, dumpMemory, quiesce);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      ManagedObjectReference morSnapshot = null;

      // We still need to wait until the object appear in vCenter

      long startTick = System.currentTimeMillis();

      while(System.currentTimeMillis() - startTick < 10000) {

        morSnapshot = getSnapshotMor(snapshotName);

        if(morSnapshot != null) {

          break;

        }

        try { Thread.sleep(1000); } catch(InterruptedException e) {}

      }

      if(morSnapshot == null)

        s_logger.error("We've been waiting for over 10 seconds for snapshot MOR to be appearing in vCenter after CreateSnapshot task is done, but it is still not there?!");

      return true;

    } else {

          s_logger.error("VMware createSnapshot_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

  public boolean removeSnapshot(String snapshotName, boolean removeChildren) throws Exception {

    ManagedObjectReference morSnapshot = getSnapshotMor(snapshotName);

    if(morSnapshot == null) {

      s_logger.warn("Unable to find snapshot: " + snapshotName);

      return false;

    }

    ManagedObjectReference morTask = _context.getService().removeSnapshotTask(morSnapshot, removeChildren, true);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      return true;

    } else {

          s_logger.error("VMware removeSnapshot_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

    public boolean revertToSnapshot(String snapshotName) throws Exception {

        ManagedObjectReference morSnapshot = getSnapshotMor(snapshotName);

        if (morSnapshot == null) {

            s_logger.warn("Unable to find snapshot: " + snapshotName);

            return false;

        }

        ManagedObjectReference morTask = _context.getService()

                .revertToSnapshotTask(morSnapshot, _mor, null);

        boolean result = _context.getVimClient().waitForTask(morTask);

        if (result) {

            _context.waitForTaskProgressDone(morTask);

            return true;

        } else {

            s_logger.error("VMware revert to snapshot failed due to "

                    + TaskMO.getTaskFailureInfo(_context, morTask));

        }

        return false;

    }

  public boolean removeAllSnapshots() throws Exception {

    VirtualMachineSnapshotInfo snapshotInfo = getSnapshotInfo();

    if(snapshotInfo != null && snapshotInfo.getRootSnapshotList() != null) {

      List<VirtualMachineSnapshotTree> tree = snapshotInfo.getRootSnapshotList();

      for(VirtualMachineSnapshotTree treeNode : tree) {

        ManagedObjectReference morTask = _context.getService().removeSnapshotTask(treeNode.getSnapshot(), true, true);

        boolean result = _context.getVimClient().waitForTask(morTask);

        if(result) {

          _context.waitForTaskProgressDone(morTask);

        } else {

              s_logger.error("VMware removeSnapshot_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

              return false;

        }

      }

    }

    return true;

  }

  public String getSnapshotDiskFileDatastorePath(VirtualMachineFileInfo vmFileInfo,

    List<Pair<ManagedObjectReference, String>> datastoreMounts,

    String snapshotDiskFile) throws Exception {

    // if file path start with "/", need to search all datastore mounts on the host in order

    // to form fully qualified datastore path

    if(snapshotDiskFile.startsWith("/")) {

      for(Pair<ManagedObjectReference, String> mount: datastoreMounts) {

        if(snapshotDiskFile.startsWith(mount.second())) {

          DatastoreMO dsMo = new DatastoreMO(_context, mount.first());

          String dsFullPath = String.format("[%s] %s", dsMo.getName(), snapshotDiskFile.substring(mount.second().length() + 1));

          s_logger.info("Convert snapshot disk file name to datastore path. " + snapshotDiskFile + "->" + dsFullPath);

          return dsFullPath;

        }

      }

      s_logger.info("Convert snapshot disk file name to datastore path. " + snapshotDiskFile + "->" + snapshotDiskFile);

      return snapshotDiskFile;

    } else {

      // snapshot directory string from VirtualMachineFileInfo ends with /

      String dsFullPath = vmFileInfo.getSnapshotDirectory() + snapshotDiskFile;

      s_logger.info("Convert snapshot disk file name to datastore path. " + snapshotDiskFile + "->" + dsFullPath);

      return dsFullPath;

    }

  }

  public SnapshotDescriptor getSnapshotDescriptor() throws Exception {

    Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();

    String dsPath = getSnapshotDescriptorDatastorePath();

    assert(dsPath != null);

    String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), dsPath);

    byte[] content = getContext().getResourceContent(url);

    if(content == null || content.length < 1) {

      s_logger.warn("Snapshot descriptor file (vsd) does not exist anymore?");

    }

    SnapshotDescriptor descriptor = new SnapshotDescriptor();

    descriptor.parse(content);

    return descriptor;

  }

  public String getSnapshotDescriptorDatastorePath() throws Exception {

    PropertySpec pSpec = new PropertySpec();

    pSpec.setType("VirtualMachine");

    pSpec.getPathSet().add("name");

    pSpec.getPathSet().add("config.files");

      ObjectSpec oSpec = new ObjectSpec();

      oSpec.setObj(_mor);

      oSpec.setSkip(Boolean.FALSE);

      PropertyFilterSpec pfSpec = new PropertyFilterSpec();

      pfSpec.getPropSet().add(pSpec);

      pfSpec.getObjectSet().add(oSpec);

        List<PropertyFilterSpec> pfSpecArr = new ArrayList<PropertyFilterSpec>();

        pfSpecArr.add(pfSpec);

      List<ObjectContent> ocs = _context.getService().retrieveProperties(

        _context.getPropertyCollector(), pfSpecArr);

      assert(ocs != null);

      String vmName = null;

      VirtualMachineFileInfo fileInfo = null;

      assert(ocs.size() == 1);

      for(ObjectContent oc : ocs) {

        List<DynamicProperty> props = oc.getPropSet();

        if(props != null) {

          assert(props.size() == 2);

          for(DynamicProperty prop : props) {

            if(prop.getName().equals("name")) {

              vmName = prop.getVal().toString();

            } else {

              fileInfo = (VirtualMachineFileInfo)prop.getVal();

            }

          }

        }

      }

      assert(vmName != null);

      assert(fileInfo != null);

      // .vmsd file exists at the same directory of .vmx file

      DatastoreFile vmxFile = new DatastoreFile(fileInfo.getVmPathName());

      return vmxFile.getCompanionPath(vmName + ".vmsd");

  }

  public ManagedObjectReference getSnapshotMor(String snapshotName) throws Exception {

    VirtualMachineSnapshotInfo info = getSnapshotInfo();

    if(info != null) {

           List<VirtualMachineSnapshotTree> snapTree = info.getRootSnapshotList();

           return VmwareHelper.findSnapshotInTree(snapTree, snapshotName);

    }

    return null;

  }

 

  public boolean hasSnapshot() throws Exception {

    VirtualMachineSnapshotInfo info = getSnapshotInfo();

    if(info != null) {

      return info.getCurrentSnapshot() != null;

    }

    return false;

  }

  public boolean createFullClone(String cloneName, ManagedObjectReference morFolder, ManagedObjectReference morResourcePool,

    ManagedObjectReference morDs) throws Exception {

       VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();

       VirtualMachineRelocateSpec relocSpec = new VirtualMachineRelocateSpec();

       cloneSpec.setLocation(relocSpec);

       cloneSpec.setPowerOn(false);

       cloneSpec.setTemplate(false);

       relocSpec.setDatastore(morDs);

       relocSpec.setPool(morResourcePool);

        ManagedObjectReference morTask = _context.getService().cloneVMTask(_mor, morFolder, cloneName, cloneSpec);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      return true;

    } else {

          s_logger.error("VMware cloneVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));

    }

    return false;

  }

  public boolean createLinkedClone(String cloneName, ManagedObjectReference morBaseSnapshot,

    ManagedObjectReference morFolder, ManagedObjectReference morResourcePool,

    ManagedObjectReference morDs) throws Exception {

    assert(morBaseSnapshot != null);

    assert(morFolder != null);

    assert(morResourcePool != null);

    assert(morDs != null);

    VirtualDisk[] independentDisks = getAllIndependentDiskDevice();

        VirtualMachineRelocateSpec rSpec = new VirtualMachineRelocateSpec();

        if(independentDisks.length > 0) {

            List<VirtualMachineRelocateSpecDiskLocator> diskLocator = new ArrayList<VirtualMachineRelocateSpecDiskLocator>(independentDisks.length);

            for(int i = 0; i < independentDisks.length; i++) {

                VirtualMachineRelocateSpecDiskLocator loc = new VirtualMachineRelocateSpecDiskLocator();

              loc.setDatastore(morDs);

              loc.setDiskId(independentDisks[i].getKey());

              loc.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions.MOVE_ALL_DISK_BACKINGS_AND_DISALLOW_SHARING.value());

              diskLocator.add(loc);

            }

            rSpec.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions.CREATE_NEW_CHILD_DISK_BACKING.value());

            rSpec.getDisk().addAll(diskLocator);

        } else {

          rSpec.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions.CREATE_NEW_CHILD_DISK_BACKING.value());

        }

        rSpec.setPool(morResourcePool);

        VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();

        cloneSpec.setPowerOn(false);

        cloneSpec.setTemplate(false);

        cloneSpec.setLocation(rSpec);

        cloneSpec.setSnapshot(morBaseSnapshot);

        ManagedObjectReference morTask = _context.getService().cloneVMTask(_mor, morFolder, cloneName, cloneSpec);

    boolean result = _context.getVimClient().waitForTask(morTask);

    if(result) {

      _context.waitForTaskProgressDone(morTask);

      return true;

    } else {