@Override public void protect(VolumeSnapshotInventory snapshot, Completion completion) { if (!snapshot.getPrimaryStorageInstallPath().contains(snapshot.getVolumeUuid())) { completion.fail(inerr("the snapshot[name:%s, uuid:%s, path: %s] seems not belong to the volume[uuid:%s]", snapshot.getName(), snapshot.getUuid(), snapshot.getPrimaryStorageInstallPath(), snapshot.getVolumeUuid())); return; } completion.success(); } }
public static APICreateVolumeSnapshotEvent __example__() { APICreateVolumeSnapshotEvent event = new APICreateVolumeSnapshotEvent(); String volumeUuid= uuid(); String snapshotUuid = uuid(); VolumeSnapshotInventory inv = new VolumeSnapshotInventory(); inv.setName("Snapshot-1"); inv.setCreateDate(new Timestamp(org.zstack.header.message.DocUtils.date)); inv.setLastOpDate(new Timestamp(org.zstack.header.message.DocUtils.date)); inv.setParentUuid(uuid()); inv.setDescription("create-snapshot-from-volume"); inv.setState(VolumeState.Enabled.toString()); inv.setType("Hypervisor"); inv.setVolumeUuid(volumeUuid); inv.setFormat("qcow2"); inv.setUuid(snapshotUuid); inv.setStatus("Ready"); inv.setPrimaryStorageUuid(uuid()); inv.setPrimaryStorageInstallPath(String.format("/zstack_ps/rootVolumes/acct-36c27e8ff05c4780bf6d2fa65700f22e/vol-%s/snapshots/%s.qcow2", volumeUuid, snapshotUuid)); inv.setLatest(true); inv.setSize(SizeUnit.GIGABYTE.toByte(1)); inv.setVolumeType(VolumeType.Root.toString()); inv.setTreeUuid(uuid()); event.setInventory(inv); return event; }
@Override public String getPrimaryStorageUuid() { return from.getPrimaryStorageUuid(); } }
public static APIUpdateVolumeSnapshotEvent __example__() { APIUpdateVolumeSnapshotEvent event = new APIUpdateVolumeSnapshotEvent(); VolumeSnapshotInventory inv = new VolumeSnapshotInventory(); inv.setUuid(uuid()); inv.setName("My Snapshot 2"); inv.setPrimaryStorageUuid(uuid()); inv.setFormat("qcow2"); inv.setLatest(false); inv.setPrimaryStorageUuid("/zstack_ps/rootVolumes/acct-e77f16d460ea46e18262547b56972273/vol-13c66bb52d0949398e520183b917f813/snapshots/2fa6979af5c6479fa98f37d316f44b5f.qcow2"); inv.setSize(1310720); inv.setStatus(VolumeSnapshotStatus.Ready.toString()); inv.setState(VolumeSnapshotState.Enabled.toString()); inv.setVolumeType(VolumeType.Root.toString()); event.setInventory(inv); return event; }
@Override public SnapshotTO call(final VolumeSnapshotInventory s) { SnapshotTO to = new SnapshotTO(); to.path = s.getPrimaryStorageInstallPath(); to.snapshotUuid = s.getUuid(); if (s.getParentUuid() != null) { to.parentPath = CollectionUtils.find(children, new Function<String, VolumeSnapshotInventory>() { @Override public String call(VolumeSnapshotInventory arg) { return arg.getUuid().equals(s.getParentUuid()) ? arg.getPrimaryStorageInstallPath() : null; } }); } return to; } });
@Override void handle(CreateVolumeFromVolumeSnapshotOnPrimaryStorageMsg msg, final ReturnValueCompletion<CreateVolumeFromVolumeSnapshotOnPrimaryStorageReply> completion) { final String installPath = makeDataVolumeInstallUrl(msg.getVolumeUuid()); VolumeSnapshotInventory latest = msg.getSnapshot(); MergeSnapshotCmd cmd = new MergeSnapshotCmd(); cmd.volumeUuid = latest.getVolumeUuid(); cmd.snapshotInstallPath = latest.getPrimaryStorageInstallPath(); cmd.workspaceInstallPath = installPath; new Do().go(MERGE_SNAPSHOT_PATH, cmd, MergeSnapshotRsp.class, new ReturnValueCompletion<AgentRsp>(completion) { @Override public void success(AgentRsp returnValue) { MergeSnapshotRsp rsp = (MergeSnapshotRsp) returnValue; CreateVolumeFromVolumeSnapshotOnPrimaryStorageReply reply = new CreateVolumeFromVolumeSnapshotOnPrimaryStorageReply(); reply.setActualSize(rsp.actualSize); reply.setInstallPath(installPath); reply.setSize(rsp.size); completion.success(reply); } @Override public void fail(ErrorCode errorCode) { completion.fail(errorCode); } }); }
@Override public void success(CreateSnapshotRsp rsp) { // current fusionstor has no way to get actual size long asize = rsp.getActualSize() == null ? 0 : rsp.getActualSize(); sp.setSize(asize); sp.setPrimaryStorageUuid(self.getUuid()); sp.setPrimaryStorageInstallPath(spPath); sp.setType(VolumeSnapshotConstant.STORAGE_SNAPSHOT_TYPE.toString()); sp.setFormat(VolumeConstant.VOLUME_FORMAT_RAW); reply.setInventory(sp); bus.reply(msg, reply); }
@Override public String call(VolumeSnapshotInventory arg) { return arg.getPrimaryStorageInstallPath(); } });
SimpleQuery<VolumeVO> q = dbf.createQuery(VolumeVO.class); q.select(VolumeVO_.installPath); q.add(VolumeVO_.uuid, Op.EQ, sp.getVolumeUuid()); String volumePath = q.findValue(); final String spPath = String.format("%s@%s", volumePath, sp.getUuid()); CreateSnapshotCmd cmd = new CreateSnapshotCmd(); cmd.volumeUuid = sp.getVolumeUuid(); cmd.snapshotPath = spPath; httpCall(CREATE_SNAPSHOT_PATH, cmd, CreateSnapshotRsp.class, new ReturnValueCompletion<CreateSnapshotRsp>(msg) {
public String getUuid() { return inventory.getUuid(); }
public void validate(VolumeSnapshotInventory root) { logger.debug(String.format("validating volume snapshot chain starting with root[uuid:%s, installPath:%s]", root.getUuid(), root.getPrimaryStorageInstallPath())); SnapshotLeaf leaf = buildRootLeaf(root.getUuid()); validate(leaf); }
@Override protected void scripts() { String type = Q.New(PrimaryStorageVO.class).eq(PrimaryStorageVO_.uuid, snapshot.getPrimaryStorageUuid()).select(PrimaryStorageVO_.type).findValue(); if(!type.equals(LocalStorageConstants.LOCAL_STORAGE_TYPE)){ return; } LocalStorageResourceRefVO ref = new LocalStorageResourceRefVO(); ref.setPrimaryStorageUuid(snapshot.getPrimaryStorageUuid()); ref.setSize(snapshot.getSize()); ref.setResourceType(VolumeSnapshotVO.class.getSimpleName()); ref.setResourceUuid(snapshot.getUuid()); ref.setHostUuid(Q.New(LocalStorageResourceRefVO.class) .select(LocalStorageResourceRefVO_.hostUuid) .eq(LocalStorageResourceRefVO_.resourceUuid, snapshot.getVolumeUuid()).findValue()); persist(ref); } }.execute();
public static VolumeSnapshotTree fromInventories(List<VolumeSnapshotInventory> invs) { VolumeSnapshotTree tree = new VolumeSnapshotTree(); Map<String, SnapshotLeaf> map = new HashMap<String, SnapshotLeaf>(); for (VolumeSnapshotInventory inv : invs) { SnapshotLeaf leaf = map.get(inv.getUuid()); if (leaf == null) { leaf = new SnapshotLeaf(); leaf.inventory = inv; map.put(inv.getUuid(), leaf); } else { leaf.inventory = inv; } if (inv.getParentUuid() != null) { SnapshotLeaf parent = map.get(inv.getParentUuid()); if (parent == null) { parent = new SnapshotLeaf(); parent.setUuid(inv.getParentUuid()); map.put(parent.getUuid(), parent); } parent.children.add(leaf); leaf.parent = parent; } else { tree.root = leaf; } tree.volumeUuid = inv.getVolumeUuid(); } DebugUtils.Assert(tree.root != null, "why tree root is null???"); return tree; }
private void handle(final BackupVolumeSnapshotFromPrimaryStorageToBackupStorageMsg msg) { BackupStorageInventory bs = msg.getBackupStorage(); VolumeSnapshotInventory sinv = msg.getSnapshot(); NfsPrimaryToBackupStorageMediator mediator = factory.getPrimaryToBackupStorageMediator( BackupStorageType.valueOf(bs.getType()), nfsMgr.findHypervisorTypeByImageFormatAndPrimaryStorageUuid(sinv.getFormat(), self.getUuid()) ); final BackupVolumeSnapshotFromPrimaryStorageToBackupStorageReply reply = new BackupVolumeSnapshotFromPrimaryStorageToBackupStorageReply(); final String installPath = mediator.makeVolumeSnapshotInstallPath(bs.getUuid(), sinv.getUuid()); mediator.uploadBits(null, getSelfInventory(), bs, installPath, sinv.getPrimaryStorageInstallPath(), new ReturnValueCompletion<String>(msg) { @Override public void success(String installPath) { reply.setBackupStorageInstallPath(installPath); bus.reply(msg, reply); } @Override public void fail(ErrorCode errorCode) { reply.setError(errorCode); bus.reply(msg, reply); } }); }
public VolumeSnapshotTree toSubTree() { VolumeSnapshotTree tree = new VolumeSnapshotTree(); tree.root = this; tree.volumeUuid = inventory.getVolumeUuid(); return tree; }
protected void handle(final RevertVolumeFromSnapshotOnPrimaryStorageMsg msg) { final RevertVolumeFromSnapshotOnPrimaryStorageReply reply = new RevertVolumeFromSnapshotOnPrimaryStorageReply(); HostInventory destHost; try { destHost = factory.getConnectedHostForOperation(PrimaryStorageInventory.valueOf(self)).get(0); }catch (OperationFailureException e){ reply.setError(operr("no host in Connected status to which nfs primary storage[uuid:%s, name:%s] attached" + " found to revert volume[uuid:%s] to snapshot[uuid:%s, name:%s]", self.getUuid(), self.getName(), msg.getVolume().getUuid(), msg.getSnapshot().getUuid(), msg.getSnapshot().getName())); bus.reply(msg, reply); return; } NfsPrimaryStorageBackend bkd = getBackend(nfsMgr.findHypervisorTypeByImageFormatAndPrimaryStorageUuid(msg.getSnapshot().getFormat(), self.getUuid())); bkd.revertVolumeFromSnapshot(msg.getSnapshot(), msg.getVolume(), destHost, new ReturnValueCompletion<RevertVolumeFromSnapshotOnPrimaryStorageReply>(msg) { @Override public void success(RevertVolumeFromSnapshotOnPrimaryStorageReply returnValue) { reply.setNewVolumeInstallPath(returnValue.getNewVolumeInstallPath()); reply.setSize(returnValue.getSize()); bus.reply(msg, reply); } @Override public void fail(ErrorCode errorCode) { reply.setError(errorCode); bus.reply(msg, reply); } }); }
@Override public void run(List<MessageReply> replies) { ErrorCode err = null; VolumeSnapshotInventory failSnapshot = null; for (MessageReply r : replies) { if (!r.isSuccess()) { err = r.getError(); failSnapshot = snapshots.get(replies.indexOf(r)); break; } } if (err != null) { completion.fail(operr("failed to change status of volume snapshot[uuid:%s, name:%s] by status event[%s]", failSnapshot.getUuid(), failSnapshot.getName(), evt).causedBy(err)); } else { completion.success(); } } });
@Override public void revertVolumeFromSnapshot(VolumeSnapshotInventory sinv, VolumeInventory vol, HostInventory host, ReturnValueCompletion<RevertVolumeFromSnapshotOnPrimaryStorageReply> completion) { RevertVolumeFromSnapshotCmd cmd = new RevertVolumeFromSnapshotCmd(); cmd.setSnapshotInstallPath(sinv.getPrimaryStorageInstallPath()); cmd.setUuid(sinv.getPrimaryStorageUuid()); KVMHostAsyncHttpCallMsg msg = new KVMHostAsyncHttpCallMsg(); msg.setCommand(cmd); msg.setPath(REVERT_VOLUME_FROM_SNAPSHOT_PATH); msg.setHostUuid(host.getUuid()); bus.makeTargetServiceIdByResourceUuid(msg, HostConstant.SERVICE_ID, host.getUuid()); bus.send(msg, new CloudBusCallBack(completion) { @Override public void run(MessageReply reply) { if (!reply.isSuccess()) { completion.fail(reply.getError()); return; } RevertVolumeFromSnapshotResponse rsp = ((KVMHostAsyncHttpCallReply) reply).toResponse(RevertVolumeFromSnapshotResponse.class); if (!rsp.isSuccess()) { completion.fail(operr("failed to revert volume[uuid:%s] to snapshot[uuid:%s] on kvm host[uuid:%s, ip:%s], %s", vol.getUuid(), sinv.getUuid(), host.getUuid(), host.getManagementIp(), rsp.getError())); return; } RevertVolumeFromSnapshotOnPrimaryStorageReply r = new RevertVolumeFromSnapshotOnPrimaryStorageReply(); r.setNewVolumeInstallPath(rsp.getNewVolumeInstallPath()); r.setSize(rsp.getSize()); completion.success(r); } }); }
@Override public Boolean call(VolumeSnapshotInventory arg) { Info info = new Info(); info.snapshot = arg; if (arg.getUuid().equals(currentRoot.getUuid()) && requiredBsUuid != null) { info.backupStorageUuid = requiredBsUuid; needBackup.add(info); return false; } if (arg.getBackupStorageRefs().isEmpty()) { needBackup.add(info); } return false; } });