Exemplo n.º 1
0
  @Test
  public void test() throws ApiSenderException {
    EipInventory eip = deployer.eips.get("eip");
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    VmNicInventory nic = vm.getVmNics().get(0);
    IpRangeInventory ipr = deployer.ipRanges.get("GuestIpRange");

    String newIp = null;
    long s = NetworkUtils.ipv4StringToLong(ipr.getStartIp());
    long e = NetworkUtils.ipv4StringToLong(ipr.getEndIp());

    for (long l = s; s < e; s++) {
      String ip = NetworkUtils.longToIpv4String(l);
      if (!ip.equals(nic.getIp())) {
        newIp = ip;
        break;
      }
    }
    Assert.assertNotNull(newIp);

    api.stopVmInstance(vm.getUuid());
    api.setStaticIp(vm.getUuid(), nic.getL3NetworkUuid(), newIp);
    EipVO eipvo = dbf.findByUuid(eip.getUuid(), EipVO.class);
    Assert.assertEquals(newIp, eipvo.getGuestIp());
  }
Exemplo n.º 2
0
  @Test
  public void test() throws ApiSenderException, InterruptedException {
    ImageInventory img = deployer.images.get("TestImage");
    VmInstanceInventory vm = deployer.vms.get("TestVm");

    api.deleteImage(img.getUuid());

    api.stopVmInstance(vm.getUuid());
    api.startVmInstance(vm.getUuid());
    api.rebootVmInstance(vm.getUuid());
    api.destroyVmInstance(vm.getUuid());
  }
Exemplo n.º 3
0
  @Test
  public void test() throws ApiSenderException, InterruptedException {
    VmInstanceInventory vm1 = deployer.vms.get("TestVm1");
    VmInstanceInventory vm2 = deployer.vms.get("TestVm2");
    api.setVmHaLevel(vm1.getUuid(), VmHaLevel.NeverStop, null);
    api.setVmHaLevel(vm2.getUuid(), VmHaLevel.OnHostFailure, null);

    api.maintainHost(vm1.getHostUuid());

    HostInventory host2 = deployer.hosts.get("host2");
    VmInstanceVO vmvo1 = dbf.findByUuid(vm1.getUuid(), VmInstanceVO.class);
    VmInstanceVO vmvo2 = dbf.findByUuid(vm2.getUuid(), VmInstanceVO.class);
    Assert.assertEquals(VmInstanceState.Running, vmvo1.getState());
    Assert.assertEquals(host2.getUuid(), vmvo1.getHostUuid());
    Assert.assertEquals(VmInstanceState.Stopped, vmvo2.getState());
  }
Exemplo n.º 4
0
  @Override
  @Transactional(
      readOnly = true,
      noRollbackForClassName = {"org.zstack.header.errorcode.OperationFailureException"})
  public void preVmMigration(VmInstanceInventory vm) {
    List<String> volUuids =
        CollectionUtils.transformToList(
            vm.getAllVolumes(),
            new Function<String, VolumeInventory>() {
              @Override
              public String call(VolumeInventory arg) {
                return arg.getUuid();
              }
            });

    String sql =
        "select count(ps) from PrimaryStorageVO ps, VolumeVO vol where ps.uuid = vol.primaryStorageUuid and"
            + " vol.uuid in (:volUuids) and ps.type = :ptype";
    TypedQuery<Long> q = dbf.getEntityManager().createQuery(sql, Long.class);
    q.setParameter("volUuids", volUuids);
    q.setParameter("ptype", LocalStorageConstants.LOCAL_STORAGE_TYPE);
    q.setMaxResults(1);
    Long count = q.getSingleResult();
    if (count > 0) {
      throw new OperationFailureException(
          errf.stringToOperationError(
              String.format(
                  "unable to live migrate with local storage. The vm[uuid:%s] has volumes on local storage,"
                      + "to protect your data, please stop the vm and do the volume migration",
                  vm.getUuid())));
    }
  }
Exemplo n.º 5
0
  @Override
  @Transactional(readOnly = true)
  public void preRecoverVm(VmInstanceInventory vm) {
    String rootVolUuid = vm.getRootVolumeUuid();

    String sql =
        "select ps.uuid from PrimaryStorageVO ps, VolumeVO vol where ps.uuid = vol.primaryStorageUuid"
            + " and vol.uuid = :uuid and ps.type = :pstype";
    TypedQuery<String> q = dbf.getEntityManager().createQuery(sql, String.class);
    q.setParameter("uuid", rootVolUuid);
    q.setParameter("pstype", LocalStorageConstants.LOCAL_STORAGE_TYPE);
    String psuuid = dbf.find(q);
    if (psuuid == null) {
      return;
    }

    sql =
        "select count(ref) from LocalStorageResourceRefVO ref where ref.resourceUuid = :uuid and ref.resourceType = :rtype";
    TypedQuery<Long> rq = dbf.getEntityManager().createQuery(sql, Long.class);
    rq.setParameter("uuid", rootVolUuid);
    rq.setParameter("rtype", VolumeVO.class.getSimpleName());
    long count = rq.getSingleResult();
    if (count == 0) {
      throw new OperationFailureException(
          errf.stringToOperationError(
              String.format(
                  "unable to recover the vm[uuid:%s, name:%s]. The vm's root volume is on the local"
                      + " storage[uuid:%s]; however, the host on which the root volume is has been deleted",
                  vm.getUuid(), vm.getName(), psuuid)));
    }
  }
Exemplo n.º 6
0
  @Test
  public void test() throws ApiSenderException {
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    api.stopVmInstance(vm.getUuid());
    PrimaryStorageInventory local = deployer.primaryStorages.get("local");

    VolumeSnapshotInventory sp = api.createSnapshot(vm.getRootVolumeUuid());
    Assert.assertFalse(kconfig.snapshotCmds.isEmpty());
    LocalStorageResourceRefVO ref = dbf.findByUuid(sp.getUuid(), LocalStorageResourceRefVO.class);
    Assert.assertNotNull(ref);
    Assert.assertEquals(vm.getHostUuid(), ref.getHostUuid());

    sp = api.createSnapshot(vm.getRootVolumeUuid());
    ref = dbf.findByUuid(sp.getUuid(), LocalStorageResourceRefVO.class);
    Assert.assertNotNull(ref);
    Assert.assertEquals(vm.getHostUuid(), ref.getHostUuid());

    sp = api.createSnapshot(vm.getRootVolumeUuid());
    ref = dbf.findByUuid(sp.getUuid(), LocalStorageResourceRefVO.class);
    Assert.assertNotNull(ref);
    Assert.assertEquals(vm.getHostUuid(), ref.getHostUuid());

    PrimaryStorageVO localvo = dbf.findByUuid(local.getUuid(), PrimaryStorageVO.class);
    long avail = localvo.getCapacity().getAvailableCapacity();

    ImageInventory img = api.createTemplateFromSnapshot(sp.getUuid());
    Assert.assertTrue(img.getSize() != 0);

    localvo = dbf.findByUuid(local.getUuid(), PrimaryStorageVO.class);
    Assert.assertEquals(avail, localvo.getCapacity().getAvailableCapacity());
  }
Exemplo n.º 7
0
  @Override
  protected FlowChain getStartVmWorkFlowChain(VmInstanceInventory inv) {
    FlowChain chain = super.getStartVmWorkFlowChain(inv);
    chain.setName(String.format("start-appliancevm-%s", inv.getUuid()));
    chain.insert(
        new Flow() {
          String __name__ = "change-appliancevm-status-to-connecting";
          ApplianceVmStatus originStatus = getSelf().getStatus();

          @Override
          public void run(FlowTrigger trigger, Map data) {
            getSelf().setStatus(ApplianceVmStatus.Connecting);
            self = dbf.updateAndRefresh(self);
            trigger.next();
          }

          @Override
          public void rollback(FlowTrigger trigger, Map data) {
            self = dbf.reload(self);
            getSelf().setStatus(originStatus);
            self = dbf.updateAndRefresh(self);
            trigger.rollback();
          }
        });

    prepareLifeCycleInfo(chain);
    prepareFirewallInfo(chain);

    addBootstrapFlows(chain, HypervisorType.valueOf(inv.getHypervisorType()));

    List<Flow> subStartFlows = getPostStartFlows();
    if (subStartFlows != null) {
      for (Flow f : subStartFlows) {
        chain.then(f);
      }
    }

    chain.then(
        new NoRollbackFlow() {
          String __name__ = "change-appliancevm-status-to-connected";

          @Override
          public void run(FlowTrigger trigger, Map data) {
            getSelf().setStatus(ApplianceVmStatus.Connected);
            self = dbf.updateAndRefresh(self);
            trigger.next();
          }
        });

    boolean noRollbackOnFailure = ApplianceVmGlobalProperty.NO_ROLLBACK_ON_POST_FAILURE;
    chain.noRollback(noRollbackOnFailure);
    return chain;
  }
Exemplo n.º 8
0
  @Test
  public void test() throws ApiSenderException {
    PrimaryStorageInventory local = deployer.primaryStorages.get("local");
    VmInstanceInventory vm1 = deployer.vms.get("TestVm");
    VmInstanceInventory vm2 = deployer.vms.get("TestVm1");
    DiskOfferingInventory dof = deployer.diskOfferings.get("TestDiskOffering1");
    VolumeInventory data = api.createDataVolume("data", dof.getUuid());
    data = api.attachVolumeToVm(vm1.getUuid(), data.getUuid());
    data = api.detachVolumeFromVm(data.getUuid());

    List<VmInstanceInventory> vms = api.getDataVolumeCandidateVmForAttaching(data.getUuid());
    Assert.assertEquals(1, vms.size());

    api.localStorageMigrateVolume(data.getUuid(), vm2.getHostUuid(), null);

    vms = api.getDataVolumeCandidateVmForAttaching(data.getUuid());
    Assert.assertEquals(1, vms.size());
    Assert.assertEquals(vm2.getUuid(), vms.get(0).getUuid());

    List<VolumeInventory> vols = api.getVmAttachableVolume(vm2.getUuid());
    Assert.assertEquals(1, vols.size());
    Assert.assertEquals(data.getUuid(), vols.get(0).getUuid());

    vols = api.getVmAttachableVolume(vm1.getUuid());
    Assert.assertEquals(0, vols.size());

    api.localStorageMigrateVolume(data.getUuid(), vm1.getHostUuid(), null);

    vols = api.getVmAttachableVolume(vm1.getUuid());
    Assert.assertEquals(1, vols.size());
    Assert.assertEquals(data.getUuid(), vols.get(0).getUuid());

    vols = api.getVmAttachableVolume(vm2.getUuid());
    Assert.assertEquals(0, vols.size());
  }
Exemplo n.º 9
0
  @Test
  public void test() throws ApiSenderException {
    final L3NetworkInventory l3 = deployer.l3Networks.get("TestL3Network4");
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    vm = api.attachNic(vm.getUuid(), l3.getUuid());
    Assert.assertEquals(4, vm.getVmNics().size());

    VmNicInventory nic = vm.getVmNics().get(0);
    vm = api.detachNic(nic.getUuid());
    Assert.assertEquals(3, vm.getVmNics().size());
    Assert.assertFalse(config.detachNicCommands.isEmpty());

    String l3Uuid = nic.getL3NetworkUuid();
    nic = vm.findNic(l3Uuid);
    Assert.assertNull(nic);

    api.stopVmInstance(vm.getUuid());
    vm = api.startVmInstance(vm.getUuid());
    Assert.assertEquals(3, vm.getVmNics().size());
    nic = vm.findNic(l3Uuid);
    Assert.assertNull(nic);
  }
Exemplo n.º 10
0
  @Test
  public void test() throws ApiSenderException {
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    ClusterInventory cluster1 = deployer.clusters.get("Cluster1");
    HostInventory host1 = deployer.hosts.get("host1");
    ClusterInventory cluster2 = deployer.clusters.get("Cluster2");
    HostInventory host2 = deployer.hosts.get("host2");

    boolean s = false;
    try {
      // vm is running, failure
      api.getVmStartingCandidateHosts(vm.getUuid(), null);
    } catch (ApiSenderException e) {
      s = true;
    }
    Assert.assertTrue(s);

    api.stopVmInstance(vm.getUuid());
    APIGetVmStartingCandidateClustersHostsReply reply =
        api.getVmStartingCandidateHosts(vm.getUuid(), null);
    Assert.assertEquals(2, reply.getClusterInventories().size());
    Assert.assertEquals(2, reply.getHostInventories().size());
  }
Exemplo n.º 11
0
  @Override
  protected FlowChain getMigrateVmWorkFlowChain(VmInstanceInventory inv) {
    FlowChain chain = super.getMigrateVmWorkFlowChain(inv);
    chain.setName(String.format("migrate-appliancevm-%s", inv.getUuid()));
    prepareLifeCycleInfo(chain);
    prepareFirewallInfo(chain);

    List<Flow> subMigrateFlows = getPostMigrateFlows();
    if (subMigrateFlows != null) {
      for (Flow f : subMigrateFlows) {
        chain.then(f);
      }
    }

    boolean noRollbackOnFailure = ApplianceVmGlobalProperty.NO_ROLLBACK_ON_POST_FAILURE;
    chain.noRollback(noRollbackOnFailure);
    return chain;
  }
  @Test
  public void test() throws ApiSenderException {
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    api.stopVmInstance(vm.getUuid());
    String rootVolumeUuid = vm.getRootVolumeUuid();
    VolumeVO vol = dbf.findByUuid(rootVolumeUuid, VolumeVO.class);

    BackupStorageInventory sftp = deployer.backupStorages.get("sftp");
    ImageInventory image =
        api.createTemplateFromRootVolume("testImage", rootVolumeUuid, (List) null);
    Assert.assertEquals(sftp.getUuid(), image.getBackupStorageRefs().get(0).getBackupStorageUuid());
    Assert.assertEquals(ImageStatus.Ready.toString(), image.getStatus());
    Assert.assertEquals(vol.getSize(), image.getSize());
    Assert.assertEquals(String.format("volume://%s", vol.getUuid()), image.getUrl());

    ImageVO ivo = dbf.findByUuid(image.getUuid(), ImageVO.class);
    Assert.assertNotNull(ivo);
  }
Exemplo n.º 13
0
  @Test
  public void test() throws ApiSenderException, InterruptedException {
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    final L3NetworkInventory l31 = deployer.l3Networks.get("TestL3Network1");
    final L3NetworkInventory l32 = deployer.l3Networks.get("TestL3Network2");

    VmNicInventory nic1 =
        CollectionUtils.find(
            vm.getVmNics(),
            new Function<VmNicInventory, VmNicInventory>() {
              @Override
              public VmNicInventory call(VmNicInventory arg) {
                return arg.getL3NetworkUuid().equals(l31.getUuid()) ? arg : null;
              }
            });
    VmNicInventory nic2 =
        CollectionUtils.find(
            vm.getVmNics(),
            new Function<VmNicInventory, VmNicInventory>() {
              @Override
              public VmNicInventory call(VmNicInventory arg) {
                return arg.getL3NetworkUuid().equals(l32.getUuid()) ? arg : null;
              }
            });

    VmInstanceInventory update = new VmInstanceInventory();
    update.setUuid(vm.getUuid());
    update.setDefaultL3NetworkUuid(l32.getUuid());
    api.updateVm(update);
    TimeUnit.SECONDS.sleep(2);
    Assert.assertEquals(1, fconfig.resetDefaultGatewayCmds.size());
    ResetDefaultGatewayCmd cmd = fconfig.resetDefaultGatewayCmds.get(0);
    Assert.assertEquals(nic1.getMac(), cmd.macOfGatewayToRemove);
    Assert.assertEquals(nic1.getGateway(), cmd.gatewayToRemove);
    Assert.assertEquals(
        new BridgeNameFinder().findByL3Uuid(l31.getUuid()), cmd.bridgeNameOfGatewayToRemove);

    Assert.assertEquals(nic2.getMac(), cmd.macOfGatewayToAdd);
    Assert.assertEquals(nic2.getGateway(), cmd.gatewayToAdd);
    Assert.assertEquals(
        new BridgeNameFinder().findByL3Uuid(l32.getUuid()), cmd.bridgeNameOfGatewayToAdd);
  }
Exemplo n.º 14
0
  @Test
  public void test() throws ApiSenderException {
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    ImageInventory iso = deployer.images.get("TestIso");
    PrimaryStorageInventory ps = deployer.primaryStorages.get("ceph-pri");

    restf.installBeforeAsyncJsonPostInterceptor(
        new BeforeAsyncJsonPostInterceptor() {
          @Override
          public void beforeAsyncJsonPost(String url, Object body, TimeUnit unit, long timeout) {
            if (body instanceof AttachIsoCmd) {
              AttachIsoCmd cmd = (AttachIsoCmd) body;
              isoto = (KvmCephIsoTO) cmd.iso;
            }
          }

          @Override
          public void beforeAsyncJsonPost(String url, String body, TimeUnit unit, long timeout) {}
        });

    api.attachIso(vm.getUuid(), iso.getUuid(), null);
    Assert.assertNotNull(isoto);
    Assert.assertFalse(isoto.getMonInfo().isEmpty());

    CephPrimaryStorageVO ceph = dbf.findByUuid(ps.getUuid(), CephPrimaryStorageVO.class);
    Assert.assertEquals(ceph.getMons().size(), isoto.getMonInfo().size());

    for (final CephPrimaryStorageMonVO mon : ceph.getMons()) {
      MonInfo info =
          CollectionUtils.find(
              isoto.getMonInfo(),
              new Function<MonInfo, MonInfo>() {
                @Override
                public MonInfo call(MonInfo arg) {
                  return arg.getHostname().equals(mon.getHostname()) ? arg : null;
                }
              });

      Assert.assertNotNull(info);
    }
  }
Exemplo n.º 15
0
  @Override
  public void preAttachVolume(VmInstanceInventory vm, final VolumeInventory volume) {
    SimpleQuery<LocalStorageResourceRefVO> q = dbf.createQuery(LocalStorageResourceRefVO.class);
    q.add(
        LocalStorageResourceRefVO_.resourceUuid,
        Op.IN,
        list(vm.getRootVolumeUuid(), volume.getUuid()));
    q.groupBy(LocalStorageResourceRefVO_.hostUuid);
    long count = q.count();

    if (count < 2) {
      return;
    }

    q = dbf.createQuery(LocalStorageResourceRefVO.class);
    q.select(LocalStorageResourceRefVO_.hostUuid);
    q.add(LocalStorageResourceRefVO_.resourceUuid, Op.EQ, vm.getRootVolumeUuid());
    String rootHost = q.findValue();

    q = dbf.createQuery(LocalStorageResourceRefVO.class);
    q.select(LocalStorageResourceRefVO_.hostUuid);
    q.add(LocalStorageResourceRefVO_.resourceUuid, Op.EQ, volume.getUuid());
    String dataHost = q.findValue();

    if (!rootHost.equals(dataHost)) {
      throw new OperationFailureException(
          errf.stringToOperationError(
              String.format(
                  "cannot attach the data volume[uuid:%s] to the vm[uuid:%s]. Both vm's root volume and the data volume are"
                      + " on local primary storage, but they are on different hosts. The root volume[uuid:%s] is on the host[uuid:%s] but the data volume[uuid: %s]"
                      + " is on the host[uuid: %s]",
                  volume.getUuid(),
                  vm.getUuid(),
                  vm.getRootVolumeUuid(),
                  rootHost,
                  volume.getUuid(),
                  dataHost)));
    }
  }
  @Test
  public void test() throws ApiSenderException, InterruptedException {
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    VolumeInventory root =
        CollectionUtils.find(
            vm.getAllVolumes(),
            new Function<VolumeInventory, VolumeInventory>() {
              @Override
              public VolumeInventory call(VolumeInventory arg) {
                return VolumeType.Root.toString().equals(arg.getType()) ? arg : null;
              }
            });

    assert root != null;
    VolumeSnapshotInventory sp = api.createSnapshot(root.getUuid());
    IscsiBtrfsSnapshotValidator validator = new IscsiBtrfsSnapshotValidator();
    validator.validate(sp);
    Assert.assertEquals(1, iconfig.createSubVolumeCmds.size());
    api.destroyVmInstance(vm.getUuid());
    api.deleteSnapshot(sp.getUuid());

    VolumeSnapshotVO spvo = dbf.findByUuid(sp.getUuid(), VolumeSnapshotVO.class);
    Assert.assertNull(spvo);
  }
Exemplo n.º 17
0
  @Test
  public void test() throws ApiSenderException, InterruptedException {
    HostInventory host2 = deployer.hosts.get("host2");
    HostInventory host1 = deployer.hosts.get("host1");
    VmInstanceInventory vm = deployer.vms.get("TestVm");
    PrimaryStorageInventory local = deployer.primaryStorages.get("local");

    List<VolumeVO> vols = dbf.listAll(VolumeVO.class);
    List<VolumeVO> volumesOnLocal = new ArrayList<VolumeVO>();

    ImageCacheVO cacheVO = dbf.listAll(ImageCacheVO.class).get(0);
    long imageSize = cacheVO.getSize();
    long usedVolumeSize = 0;
    for (VolumeVO vol : vols) {
      if (vol.getPrimaryStorageUuid().equals(local.getUuid())) {
        volumesOnLocal.add(vol);
        usedVolumeSize += ratioMgr.calculateByRatio(vol.getPrimaryStorageUuid(), vol.getSize());
      }
    }

    config.createEmptyVolumeCmds.clear();
    config.deleteBitsCmds.clear();
    vm = api.migrateVmInstance(vm.getUuid(), host2.getUuid());
    TimeUnit.SECONDS.sleep(5);
    LocalStorageHostRefVO ref1 = dbf.findByUuid(host1.getUuid(), LocalStorageHostRefVO.class);
    Assert.assertEquals(ref1.getTotalCapacity() - imageSize, ref1.getAvailableCapacity());
    LocalStorageHostRefVO ref2 = dbf.findByUuid(host2.getUuid(), LocalStorageHostRefVO.class);
    Assert.assertEquals(
        ref2.getTotalCapacity() - imageSize - usedVolumeSize, ref2.getAvailableCapacity());

    Assert.assertEquals(volumesOnLocal.size(), config.createEmptyVolumeCmds.size());
    for (final VolumeVO vol : volumesOnLocal) {
      // volumes are created on dst host
      CreateEmptyVolumeCmd cmd =
          CollectionUtils.find(
              config.createEmptyVolumeCmds,
              new Function<CreateEmptyVolumeCmd, CreateEmptyVolumeCmd>() {
                @Override
                public CreateEmptyVolumeCmd call(CreateEmptyVolumeCmd arg) {
                  return arg.getVolumeUuid().equals(vol.getUuid()) ? arg : null;
                }
              });
      Assert.assertNotNull(cmd);
      Assert.assertEquals(vol.getInstallPath(), cmd.getInstallUrl());

      LocalStorageResourceRefVO r = dbf.findByUuid(vol.getUuid(), LocalStorageResourceRefVO.class);
      Assert.assertEquals(host2.getUuid(), r.getHostUuid());

      // volumes are deleted on src host
      DeleteBitsCmd dcmd =
          CollectionUtils.find(
              config.deleteBitsCmds,
              new Function<DeleteBitsCmd, DeleteBitsCmd>() {
                @Override
                public DeleteBitsCmd call(DeleteBitsCmd arg) {
                  return arg.getPath().equals(vol.getInstallPath()) ? arg : null;
                }
              });
      Assert.assertNotNull(
          String.format(
              "no delete command for volume[uuid:%s, path:%s]",
              vol.getUuid(), vol.getInstallPath()),
          dcmd);
    }

    Assert.assertFalse(kconfig.migrateVmCmds.isEmpty());
    MigrateVmCmd mcmd = kconfig.migrateVmCmds.get(0);
    Assert.assertEquals(host2.getManagementIp(), mcmd.getDestHostIp());
    Assert.assertEquals(vm.getUuid(), mcmd.getVmUuid());
    Assert.assertEquals(
        StorageMigrationPolicy.IncCopy.toString(), mcmd.getStorageMigrationPolicy());
  }
Exemplo n.º 18
0
  @Test
  public void test() throws ApiSenderException, InterruptedException {
    final L3NetworkInventory l3 = deployer.l3Networks.get("TestL3Network4");
    VmInstanceInventory vm = deployer.vms.get("TestVm");

    APIGetIpAddressCapacityReply ipcap = api.getIpAddressCapacityByAll();
    long avail1 = ipcap.getAvailableCapacity();

    int num = 50;
    final CountDownLatch latch = new CountDownLatch(num);
    final String vmUuid = vm.getUuid();

    class Ret {
      int count;
    }

    final Ret ret = new Ret();
    for (int i = 0; i < num; i++) {
      new Runnable() {
        @Override
        @AsyncThread
        public void run() {
          try {
            VmInstanceInventory v = api.attachNic(vmUuid, l3.getUuid());
            ret.count += 1;
          } catch (Exception e) {
            logger.warn(e.getMessage(), e);
          } finally {
            latch.countDown();
          }
        }
      }.run();
    }

    latch.await(120, TimeUnit.SECONDS);

    VmInstanceVO vmvo = dbf.findByUuid(vmUuid, VmInstanceVO.class);
    final CountDownLatch latch1 = new CountDownLatch(vmvo.getVmNics().size());
    for (final VmNicVO nic : vmvo.getVmNics()) {
      new Runnable() {
        @Override
        @AsyncThread
        public void run() {
          try {
            api.detachNic(nic.getUuid());
          } catch (Exception e) {
            logger.warn(e.getMessage(), e);
          } finally {
            latch1.countDown();
          }
        }
      }.run();
    }

    latch1.await(120, TimeUnit.SECONDS);

    TimeUnit.SECONDS.sleep(5);
    ipcap = api.getIpAddressCapacityByAll();
    long avail2 = ipcap.getAvailableCapacity();

    Assert.assertEquals(avail1, avail2 - 3);
  }
Exemplo n.º 19
0
  @Test
  public void test() throws ApiSenderException {
    StartVmCmd scmd = config.startVmCmd;
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.cdrom.toString()));

    VmInstanceInventory vm = deployer.vms.get("TestVm");
    List<String> order = api.getVmBootOrder(vm.getUuid(), null);
    Assert.assertEquals(1, order.size());
    Assert.assertEquals(VmBootDevice.HardDisk.toString(), order.get(0));

    vm =
        api.setVmBootOrder(
            vm.getUuid(),
            list(VmBootDevice.CdRom.toString(), VmBootDevice.HardDisk.toString()),
            null);
    Assert.assertTrue(VmSystemTags.BOOT_ORDER.hasTag(vm.getUuid()));
    vm = api.rebootVmInstance(vm.getUuid());
    scmd = config.startVmCmd;
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.cdrom.toString()));
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.hd.toString()));

    order = api.getVmBootOrder(vm.getUuid(), null);
    Assert.assertEquals(2, order.size());
    Assert.assertTrue(order.contains(VmBootDevice.CdRom.toString()));
    Assert.assertTrue(order.contains(VmBootDevice.HardDisk.toString()));

    api.stopVmInstance(vm.getUuid());
    api.startVmInstance(vm.getUuid());
    scmd = config.startVmCmd;
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.cdrom.toString()));
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.hd.toString()));

    config.rebootVmCmds.clear();
    vm = api.setVmBootOrder(vm.getUuid(), null, null);
    Assert.assertFalse(VmSystemTags.BOOT_ORDER.hasTag(vm.getUuid()));
    order = api.getVmBootOrder(vm.getUuid(), null);
    Assert.assertEquals(1, order.size());
    Assert.assertEquals(VmBootDevice.HardDisk.toString(), order.get(0));
    api.rebootVmInstance(vm.getUuid());
    scmd = config.startVmCmd;
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.hd.toString()));

    api.stopVmInstance(vm.getUuid());
    api.startVmInstance(vm.getUuid());
    scmd = config.startVmCmd;
    Assert.assertTrue(scmd.getBootDev().contains(BootDev.hd.toString()));
  }
Exemplo n.º 20
0
  private void handleDeletion(final CascadeAction action, final Completion completion) {
    int op = toDeletionOpCode(action);
    if (op == OP_NOPE) {
      completion.success();
      return;
    }

    if (op == OP_REMOVE_INSTANCE_OFFERING) {
      if (VmGlobalConfig.UPDATE_INSTANCE_OFFERING_TO_NULL_WHEN_DELETING.value(Boolean.class)) {
        new Runnable() {
          @Override
          @Transactional
          public void run() {
            List<InstanceOfferingInventory> offerings = action.getParentIssuerContext();
            List<String> offeringUuids =
                CollectionUtils.transformToList(
                    offerings,
                    new Function<String, InstanceOfferingInventory>() {
                      @Override
                      public String call(InstanceOfferingInventory arg) {
                        return arg.getUuid();
                      }
                    });

            String sql =
                "update VmInstanceVO vm set vm.instanceOfferingUuid = null where vm.instanceOfferingUuid in (:offeringUuids)";
            Query q = dbf.getEntityManager().createQuery(sql);
            q.setParameter("offeringUuids", offeringUuids);
            q.executeUpdate();
          }
        }.run();
      }

      completion.success();
      return;
    }

    final List<VmInstanceInventory> vminvs = vmFromDeleteAction(action);
    if (vminvs == null) {
      completion.success();
      return;
    }

    if (op == OP_STOP) {
      List<StopVmInstanceMsg> msgs = new ArrayList<StopVmInstanceMsg>();
      for (VmInstanceInventory inv : vminvs) {
        StopVmInstanceMsg msg = new StopVmInstanceMsg();
        msg.setVmInstanceUuid(inv.getUuid());
        bus.makeTargetServiceIdByResourceUuid(msg, VmInstanceConstant.SERVICE_ID, inv.getUuid());
        msgs.add(msg);
      }

      bus.send(
          msgs,
          20,
          new CloudBusListCallBack(completion) {
            @Override
            public void run(List<MessageReply> replies) {
              if (!action.isActionCode(CascadeConstant.DELETION_FORCE_DELETE_CODE)) {
                for (MessageReply r : replies) {
                  if (!r.isSuccess()) {
                    completion.fail(r.getError());
                    return;
                  }
                }
              }

              completion.success();
            }
          });
    } else if (op == OP_DELETION) {
      List<VmInstanceDeletionMsg> msgs = new ArrayList<VmInstanceDeletionMsg>();
      for (VmInstanceInventory inv : vminvs) {
        VmInstanceDeletionMsg msg = new VmInstanceDeletionMsg();
        msg.setForceDelete(action.isActionCode(CascadeConstant.DELETION_FORCE_DELETE_CODE));
        msg.setVmInstanceUuid(inv.getUuid());
        bus.makeTargetServiceIdByResourceUuid(msg, VmInstanceConstant.SERVICE_ID, inv.getUuid());
        msgs.add(msg);
      }

      bus.send(
          msgs,
          20,
          new CloudBusListCallBack(completion) {
            @Override
            public void run(List<MessageReply> replies) {
              if (!action.isActionCode(CascadeConstant.DELETION_FORCE_DELETE_CODE)) {
                for (MessageReply r : replies) {
                  if (!r.isSuccess()) {
                    completion.fail(r.getError());
                    return;
                  }
                }
              }

              completion.success();
            }
          });
    } else if (op == OP_DETACH_NIC) {
      List<DetachNicFromVmMsg> msgs = new ArrayList<DetachNicFromVmMsg>();
      List<L3NetworkInventory> l3s = action.getParentIssuerContext();
      for (VmInstanceInventory vm : vminvs) {
        for (L3NetworkInventory l3 : l3s) {
          DetachNicFromVmMsg msg = new DetachNicFromVmMsg();
          msg.setVmInstanceUuid(vm.getUuid());
          msg.setVmNicUuid(vm.findNic(l3.getUuid()).getUuid());
          bus.makeTargetServiceIdByResourceUuid(msg, VmInstanceConstant.SERVICE_ID, vm.getUuid());
          msgs.add(msg);
        }
      }

      bus.send(
          msgs,
          new CloudBusListCallBack(completion) {
            @Override
            public void run(List<MessageReply> replies) {
              if (!action.isActionCode(CascadeConstant.DELETION_FORCE_DELETE_CODE)) {
                for (MessageReply r : replies) {
                  if (!r.isSuccess()) {
                    completion.fail(r.getError());
                    return;
                  }
                }
              }

              completion.success();
            }
          });
    }
  }