예제 #1
0
 @Override
 public void updateVolumeIds(long oldVolId, long newVolId) {
   SearchCriteria<SnapshotVO> sc = VolumeIdSearch.create();
   sc.setParameters("volumeId", oldVolId);
   SnapshotVO snapshot = createForUpdate();
   snapshot.setVolumeId(newVolId);
   UpdateBuilder ub = getUpdateBuilder(snapshot);
   update(ub, sc, null);
 }
예제 #2
0
 @Override
 public boolean updateState(
     State currentState, Event event, State nextState, SnapshotVO snapshot, Object data) {
   TransactionLegacy txn = TransactionLegacy.currentTxn();
   txn.start();
   SnapshotVO snapshotVO = snapshot;
   snapshotVO.setState(nextState);
   super.update(snapshotVO.getId(), snapshotVO);
   txn.commit();
   return true;
 }
  private void checkStatusOfCurrentlyExecutingSnapshots() {
    SearchCriteria<SnapshotScheduleVO> sc = _snapshotScheduleDao.createSearchCriteria();
    sc.addAnd("asyncJobId", SearchCriteria.Op.NNULL);
    List<SnapshotScheduleVO> snapshotSchedules = _snapshotScheduleDao.search(sc, null);
    for (SnapshotScheduleVO snapshotSchedule : snapshotSchedules) {
      Long asyncJobId = snapshotSchedule.getAsyncJobId();
      AsyncJobVO asyncJob = _asyncJobDao.findById(asyncJobId);
      switch (asyncJob.getStatus()) {
        case AsyncJobResult.STATUS_SUCCEEDED:
          // The snapshot has been successfully backed up.
          // The snapshot state has also been cleaned up.
          // We can schedule the next job for this snapshot.
          // Remove the existing entry in the snapshot_schedule table.
          scheduleNextSnapshotJob(snapshotSchedule);
          break;
        case AsyncJobResult.STATUS_FAILED:
          // Check the snapshot status.
          Long snapshotId = snapshotSchedule.getSnapshotId();
          if (snapshotId == null) {
            // createSnapshotAsync exited, successfully or unsuccessfully,
            // even before creating a snapshot record
            // No cleanup needs to be done.
            // Schedule the next snapshot.
            scheduleNextSnapshotJob(snapshotSchedule);
          } else {
            SnapshotVO snapshot = _snapshotDao.findById(snapshotId);
            if (snapshot == null || snapshot.getRemoved() != null) {
              // This snapshot has been deleted successfully from the primary storage
              // Again no cleanup needs to be done.
              // Schedule the next snapshot.
              // There's very little probability that the code reaches this point.
              // The snapshotId is a foreign key for the snapshot_schedule table
              // set to ON DELETE CASCADE. So if the snapshot entry is deleted, the
              // snapshot_schedule entry will be too.
              // But what if it has only been marked as removed?
              scheduleNextSnapshotJob(snapshotSchedule);
            } else {
              // The management server executing this snapshot job appears to have crashed
              // while creating the snapshot on primary storage/or backing it up.
              // We have no idea whether the snapshot was successfully taken on the primary or not.
              // Schedule the next snapshot job.
              // The ValidatePreviousSnapshotCommand will take appropriate action on this snapshot
              // If the snapshot was taken successfully on primary, it will retry backing it up.
              // and cleanup the previous snapshot
              // Set the userId to that of system.
              // _snapshotManager.validateSnapshot(1L, snapshot);
              // In all cases, schedule the next snapshot job
              scheduleNextSnapshotJob(snapshotSchedule);
            }
          }

          break;
        case AsyncJobResult.STATUS_IN_PROGRESS:
          // There is no way of knowing from here whether
          // 1) Another management server is processing this snapshot job
          // 2) The management server has crashed and this snapshot is lying
          // around in an inconsistent state.
          // Hopefully, this can be resolved at the backend when the current snapshot gets executed.
          // But if it remains in this state, the current snapshot will not get executed.
          // And it will remain in stasis.
          break;
      }
    }
  }