@Override
  protected boolean canDoAction() {
    if (!super.canDoAction()) {
      return false;
    }

    VDSGroup cluster = getVdsGroup();
    if (cluster == null) {
      addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_CLUSTER_IS_NOT_VALID);
      return false;
    }

    if (!cluster.supportsGlusterService()) {
      addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_CLUSTER_DOES_NOT_SUPPORT_GLUSTER);
      return false;
    }

    if (volumeNameExists(volume.getName())) {
      addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_GLUSTER_VOLUME_NAME_ALREADY_EXISTS);
      addCanDoActionMessage(String.format("$volumeName %1$s", volume.getName()));
      return false;
    }

    return validateBricks(volume);
  }
  private void onSetParameter() {
    if (getEntity() == null) {
      return;
    }

    GlusterVolumeEntity volume = getEntity();

    VolumeParameterModel model = (VolumeParameterModel) getWindow();

    if (!model.validate()) {
      return;
    }

    GlusterVolumeOptionEntity option = new GlusterVolumeOptionEntity();
    option.setVolumeId(volume.getId());
    option.setKey(model.getSelectedKey().getEntity());
    option.setValue(model.getValue().getEntity());

    model.startProgress();

    Frontend.getInstance()
        .runAction(
            VdcActionType.SetGlusterVolumeOption,
            new GlusterVolumeOptionParameters(option),
            new IFrontendActionAsyncCallback() {

              @Override
              public void executed(FrontendActionAsyncResult result) {
                VolumeParameterListModel localModel = (VolumeParameterListModel) result.getState();
                localModel.postOnSetParameter(result.getReturnValue());
              }
            },
            this);
  }
  private void onResetAllParameters() {
    ConfirmationModel model = (ConfirmationModel) getWindow();

    if (model.getProgress() != null) {
      return;
    }

    if (getEntity() == null) {
      return;
    }
    GlusterVolumeEntity volume = getEntity();

    ResetGlusterVolumeOptionsParameters parameters =
        new ResetGlusterVolumeOptionsParameters(volume.getId(), null, false);

    model.startProgress();

    Frontend.getInstance()
        .runAction(
            VdcActionType.ResetGlusterVolumeOptions,
            parameters,
            new IFrontendActionAsyncCallback() {

              @Override
              public void executed(FrontendActionAsyncResult result) {
                ConfirmationModel localModel = (ConfirmationModel) result.getState();
                localModel.stopProgress();
                cancel();
              }
            },
            model);
  }
  private GlusterVolumeAdvancedDetails getVolumeAdvancedDetails(GlusterVolumeEntity volume) {
    GlusterVolumeAdvancedDetails volDetails = new GlusterVolumeAdvancedDetails();
    GlusterVolumeSizeInfo capacityInfo = new GlusterVolumeSizeInfo();
    capacityInfo.setVolumeId(volume.getId());
    capacityInfo.setTotalSize(600000L);
    capacityInfo.setFreeSize(200000L);
    capacityInfo.setUsedSize(400000L);
    volDetails.setCapacityInfo(capacityInfo);

    List<BrickDetails> brickDetailsList = new ArrayList<>();
    for (GlusterBrickEntity brick : volume.getBricks()) {
      BrickDetails brickDetails = new BrickDetails();
      BrickProperties properties = new BrickProperties();
      properties.setBrickId(brick.getId());
      brickDetails.setBrickProperties(properties);
      properties.setStatus(brick.getStatus());
      if (volume == existingReplVol) {
        if (brick.getServerId().equals(SERVER_ID_1)
            && (brick.getBrickDirectory().equals(REPL_BRICK_R1D1)
                || brick.getBrickDirectory().equals(REPL_BRICK_R2D1))) {
          properties.setStatus(GlusterStatus.DOWN);
          bricksWithChangedStatus.add(brick);
        }
      }
      brickDetailsList.add(brickDetails);
    }
    volDetails.setBrickDetails(brickDetailsList);

    return volDetails;
  }
  /**
   * Returns the list of volumes as if they were fetched from glusterfs. Changes from existing
   * volumes are:<br>
   * - existingDistVol not fetched (means it was removed from gluster cli, and should be removed
   * from db<br>
   * - option 'auth.allow' removed from the existingReplVol<br>
   * - new option 'auth.reject' added to existingReplVol<br>
   * - value of option 'nfs.disable' changed from 'off' ot 'on' in existingReplVol<br>
   * - new volume test-new-vol fetched from gluster (means it was added from gluster cli, and should
   * be added to db<br>
   */
  private Map<Guid, GlusterVolumeEntity> getFetchedVolumesList() {
    Map<Guid, GlusterVolumeEntity> volumes = new HashMap<>();

    GlusterVolumeEntity fetchedReplVol = createReplVol();
    fetchedReplVol.removeOption(OPTION_AUTH_ALLOW); // option removed
    fetchedReplVol.setOption(OPTION_AUTH_REJECT, AUTH_REJECT_IP); // added
    fetchedReplVol.setOption(OPTION_NFS_DISABLE, OPTION_VALUE_ON); // changed

    // brick changes
    removedBrickIds.add(
        GlusterCoreUtil.findBrick(existingReplVol.getBricks(), SERVER_ID_1, REPL_BRICK_R1D1)
            .getId());
    removedBrickIds.add(
        GlusterCoreUtil.findBrick(existingReplVol.getBricks(), SERVER_ID_1, REPL_BRICK_R2D1)
            .getId());

    GlusterBrickEntity brickToReplace =
        GlusterCoreUtil.findBrick(fetchedReplVol.getBricks(), SERVER_ID_1, REPL_BRICK_R1D1);
    replaceBrick(brickToReplace, SERVER_ID_1, REPL_BRICK_R1D1_NEW);

    brickToReplace =
        GlusterCoreUtil.findBrick(fetchedReplVol.getBricks(), SERVER_ID_1, REPL_BRICK_R2D1);
    replaceBrick(brickToReplace, SERVER_ID_1, REPL_BRICK_R2D1_NEW);
    volumes.put(fetchedReplVol.getId(), fetchedReplVol);

    // add a new volume
    newVolume = getNewVolume();
    volumes.put(newVolume.getId(), newVolume);

    return volumes;
  }
  /**
   * Validates the the number of bricks against the replica count or stripe count based on volume
   * type
   *
   * @param volume
   * @return
   */
  private boolean validateBricks(GlusterVolumeEntity volume) {
    List<GlusterBrickEntity> bricks = volume.getBricks();
    if (bricks.isEmpty()) {
      addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_BRICKS_REQUIRED);
      return false;
    }

    int brickCount = bricks.size();
    int replicaCount = volume.getReplicaCount();
    int stripeCount = volume.getStripeCount();

    switch (volume.getVolumeType()) {
      case REPLICATE:
        if (replicaCount < 2) {
          addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_REPLICA_COUNT_MIN_2);
          return false;
        }

        if (brickCount != replicaCount) {
          addCanDoActionMessage(
              VdcBllMessages.ACTION_TYPE_FAILED_INVALID_BRICK_COUNT_FOR_REPLICATE);
          return false;
        }
        break;
      case DISTRIBUTED_REPLICATE:
        if (replicaCount < 2) {
          addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_REPLICA_COUNT_MIN_2);
          return false;
        }
        if (brickCount < replicaCount || Math.IEEEremainder(brickCount, replicaCount) != 0) {
          addCanDoActionMessage(
              VdcBllMessages.ACTION_TYPE_FAILED_INVALID_BRICK_COUNT_FOR_DISTRIBUTED_REPLICATE);
          return false;
        }
        break;
      case STRIPE:
        if (stripeCount < 4) {
          addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_STRIPE_COUNT_MIN_4);
          return false;
        }
        if (brickCount != stripeCount) {
          addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_INVALID_BRICK_COUNT_FOR_STRIPE);
          return false;
        }
        break;
      case DISTRIBUTED_STRIPE:
        if (stripeCount < 4) {
          addCanDoActionMessage(VdcBllMessages.ACTION_TYPE_FAILED_STRIPE_COUNT_MIN_4);
          return false;
        }
        if (brickCount < stripeCount || Math.IEEEremainder(brickCount, stripeCount) != 0) {
          addCanDoActionMessage(
              VdcBllMessages.ACTION_TYPE_FAILED_INVALID_BRICK_COUNT_FOR_DISTRIBUTED_STRIPE);
          return false;
        }
        break;
    }

    return updateBrickServerNames(bricks, true);
  }
 private GlusterVolumeEntity getMultiBrickVolume(Guid volumeId) {
   GlusterVolumeEntity volume = getGlusterVolume(volumeId);
   volume.setStatus(GlusterStatus.UP);
   volume.setBricks(getBricks(volumeId, 2));
   volume.setClusterId(CLUSTER_ID);
   return volume;
 }
  private void addParameter() {
    if (getWindow() != null) {
      return;
    }

    GlusterVolumeEntity volume = getEntity();
    if (volume == null) {
      return;
    }

    VolumeParameterModel volumeParameterModel = new VolumeParameterModel();
    volumeParameterModel.setTitle(ConstantsManager.getInstance().getConstants().addOptionVolume());
    volumeParameterModel.setHelpTag(HelpTag.add_option);
    volumeParameterModel.setHashName("add_option"); // $NON-NLS-1$
    setWindow(volumeParameterModel);
    volumeParameterModel.startProgress();

    AsyncQuery _asyncQuery = new AsyncQuery();
    _asyncQuery.setModel(this);
    _asyncQuery.setHandleFailure(true);
    _asyncQuery.asyncCallback =
        new INewAsyncCallback() {
          @Override
          public void onSuccess(Object model, Object result) {
            VolumeParameterListModel volumeParameterListModel = (VolumeParameterListModel) model;
            VolumeParameterModel innerParameterModel = (VolumeParameterModel) getWindow();

            ArrayList<GlusterVolumeOptionInfo> optionInfoList =
                new ArrayList<GlusterVolumeOptionInfo>();

            VdcQueryReturnValue returnValue = (VdcQueryReturnValue) result;

            if (!returnValue.getSucceeded()) {
              innerParameterModel.setMessage(
                  ConstantsManager.getInstance().getConstants().errorInFetchingVolumeOptionList());
            } else {
              optionInfoList =
                  new ArrayList<GlusterVolumeOptionInfo>(
                      (Set<GlusterVolumeOptionInfo>) returnValue.getReturnValue());
              optionInfoList.add(getCifsVolumeOption());
            }

            innerParameterModel.getKeyList().setItems(optionInfoList);
            innerParameterModel.stopProgress();

            UICommand command =
                UICommand.createDefaultOkUiCommand(
                    "OnSetParameter", volumeParameterListModel); // $NON-NLS-1$
            innerParameterModel.getCommands().add(command);
            innerParameterModel
                .getCommands()
                .add(
                    UICommand.createCancelUiCommand(
                        "OnCancel", volumeParameterListModel)); // $NON-NLS-1$
          }
        };
    AsyncDataProvider.getInstance()
        .getGlusterVolumeOptionInfoList(_asyncQuery, volume.getClusterId());
  }
 private GlusterVolumeEntity getVolume(Guid id) {
   GlusterVolumeEntity volumeEntity = new GlusterVolumeEntity();
   volumeEntity.setId(id);
   volumeEntity.setName("test-vol");
   volumeEntity.addAccessProtocol(AccessProtocol.GLUSTER);
   volumeEntity.addTransportType(TransportType.TCP);
   return volumeEntity;
 }
 private GlusterVolumeEntity getDistributedVolume(Guid volumeId) {
   GlusterVolumeEntity volume = getVolume(volumeId);
   volume.setStatus((volumeId == volumeId1) ? GlusterStatus.UP : GlusterStatus.DOWN);
   volume.setBricks(getBricks(volumeId, "distrib", 2));
   volume.setVolumeType(GlusterVolumeType.DISTRIBUTED_REPLICATE);
   volume.setClusterId(clusterId);
   return volume;
 }
 private GlusterVolumeEntity createVolume(String volName, Guid id) {
   GlusterVolumeEntity vol = new GlusterVolumeEntity();
   vol.setId(id);
   vol.setName(volName);
   vol.setClusterId(CLUSTER_ID);
   vol.setStatus(GlusterStatus.UP);
   return vol;
 }
 private GlusterVolumeEntity createDistVol(String volName, Guid volId) {
   GlusterVolumeEntity vol = createVolume(volName, volId);
   vol.getAdvancedDetails().setCapacityInfo(getCapacityInfo(volId));
   vol.addBrick(createBrick(volId, existingServer1, DIST_BRICK_D1));
   vol.addBrick(createBrick(volId, existingServer1, DIST_BRICK_D2));
   existingVolumes.add(vol);
   return vol;
 }
 private GlusterVolumeEntity createReplVol() {
   GlusterVolumeEntity vol = createVolume(REPL_VOL_NAME, EXISTING_VOL_REPL_ID);
   vol.addBrick(createBrick(EXISTING_VOL_REPL_ID, existingServer1, REPL_BRICK_R1D1));
   vol.addBrick(createBrick(EXISTING_VOL_REPL_ID, existingServer2, REPL_BRICK_R1D2));
   vol.addBrick(createBrick(EXISTING_VOL_REPL_ID, existingServer1, REPL_BRICK_R2D1));
   vol.addBrick(createBrick(EXISTING_VOL_REPL_ID, existingServer2, REPL_BRICK_R2D2));
   vol.setOption(OPTION_AUTH_ALLOW, "*");
   vol.setOption(OPTION_NFS_DISABLE, OPTION_VALUE_OFF);
   existingVolumes.add(vol);
   return vol;
 }
 @Override
 protected void syncSearch() {
   if (getEntity() == null) {
     return;
   }
   GlusterVolumeEntity glusterVolumeEntity = getEntity();
   ArrayList<GlusterVolumeOptionEntity> list = new ArrayList<GlusterVolumeOptionEntity>();
   for (GlusterVolumeOptionEntity glusterVolumeOption : glusterVolumeEntity.getOptions()) {
     list.add(glusterVolumeOption);
   }
   setItems(list);
 }
  @SuppressWarnings("unchecked")
  private void setupMocks() throws Exception {
    logUtil = spy(GlusterAuditLogUtil.getInstance());
    glusterManager.setLogUtil(logUtil);
    mockDaos();

    doReturn(glusterUtil).when(glusterManager).getGlusterUtil();
    doReturn(existingServer1).when(glusterUtil).getUpServer(any(Guid.class));
    doReturn(existingServer1).when(glusterUtil).getRandomUpServer(any(Guid.class));

    doNothing().when(logUtil).logServerMessage(any(VDS.class), any(AuditLogType.class));
    doNothing()
        .when(logUtil)
        .logVolumeMessage(any(GlusterVolumeEntity.class), any(AuditLogType.class));
    doNothing()
        .when(logUtil)
        .logAuditMessage(
            any(Guid.class),
            any(GlusterVolumeEntity.class),
            any(VDS.class),
            any(AuditLogType.class),
            any(HashMap.class));
    doNothing()
        .when(logUtil)
        .logAuditMessage(
            any(Guid.class),
            any(GlusterVolumeEntity.class),
            any(VDS.class),
            any(AuditLogType.class),
            any(Guid.class),
            any(String.class));
    doReturn(getFetchedServersList()).when(glusterManager).fetchServers(any(VDS.class));
    doReturn(getFetchedVolumesList()).when(glusterManager).fetchVolumes(any(VDS.class));
    doReturn(getVolumeAdvancedDetails(existingDistVol))
        .when(glusterManager)
        .getVolumeAdvancedDetails(existingServer1, CLUSTER_ID, existingDistVol.getName());
    doReturn(getVolumeAdvancedDetails(existingReplVol))
        .when(glusterManager)
        .getVolumeAdvancedDetails(existingServer1, CLUSTER_ID, existingReplVol.getName());
    doReturn(new VDSReturnValue())
        .when(glusterManager)
        .runVdsCommand(eq(VDSCommandType.RemoveVds), argThat(isRemovedServer()));
    doReturn(mockVdcReturn())
        .when(backend)
        .runInternalAction(
            any(VdcActionType.class),
            any(VdcActionParametersBase.class),
            any(CommandContext.class));

    doNothing().when(glusterManager).acquireLock(CLUSTER_ID);
    doNothing().when(glusterManager).releaseLock(CLUSTER_ID);
    doReturn(glusterUtil).when(glusterManager).getGlusterUtil();
  }
  private void verifyMocksForHeavyWeight() {
    InOrder inOrder = inOrder(clusterDao, glusterUtil, volumeDao, glusterManager, brickDao);

    // all clusters fetched from db
    inOrder.verify(clusterDao, times(1)).getAll();

    VerificationMode mode = times(1);

    // get the UP server from cluster
    inOrder.verify(glusterUtil, mode).getRandomUpServer(CLUSTER_ID);

    // get volumes of the cluster
    inOrder.verify(volumeDao, mode).getByClusterId(CLUSTER_ID);

    // acquire lock on the cluster
    inOrder.verify(glusterManager, mode).acquireLock(CLUSTER_ID);

    // get volume advance details
    inOrder
        .verify(glusterManager, mode)
        .getVolumeAdvancedDetails(existingServer1, CLUSTER_ID, existingDistVol.getName());

    // Update capacity info
    inOrder
        .verify(volumeDao, mode)
        .updateVolumeCapacityInfo(getVolumeAdvancedDetails(existingDistVol).getCapacityInfo());
    // release lock on the cluster
    inOrder.verify(glusterManager, mode).releaseLock(CLUSTER_ID);

    // acquire lock on the cluster for repl volume
    inOrder.verify(glusterManager, mode).acquireLock(CLUSTER_ID);

    // get volume advance details of repl volume
    inOrder
        .verify(glusterManager, mode)
        .getVolumeAdvancedDetails(existingServer1, CLUSTER_ID, existingReplVol.getName());

    // Add Capacity Info
    inOrder
        .verify(volumeDao, mode)
        .addVolumeCapacityInfo(getVolumeAdvancedDetails(existingReplVol).getCapacityInfo());

    // Add Capacity Info
    inOrder.verify(brickDao, mode).addBrickProperties(any(List.class));

    // update brick status
    inOrder.verify(brickDao, mode).updateBrickStatuses(argThat(hasBricksWithChangedStatus()));

    // release lock on the cluster
    inOrder.verify(glusterManager, mode).releaseLock(CLUSTER_ID);
  }
  /**
   * Sets all options of a volume by invoking the action {@link
   * VdcActionType#SetGlusterVolumeOption} in a loop. <br>
   * Errors if any are collected and added to "executeFailedMessages"
   *
   * @param volume
   */
  private void setVolumeOptions(GlusterVolumeEntity volume) {
    List<String> errors = new ArrayList<String>();
    for (GlusterVolumeOptionEntity option : volume.getOptions()) {
      // make sure that volume id is set
      option.setVolumeId(volume.getId());
      VdcReturnValueBase setOptionReturnValue =
          runBllAction(
              VdcActionType.SetGlusterVolumeOption, new GlusterVolumeOptionParameters(option));
      if (!getSucceeded()) {
        errors.addAll(setOptionReturnValue.getCanDoActionMessages());
        errors.addAll(setOptionReturnValue.getExecuteFailedMessages());
      }
    }

    if (!errors.isEmpty()) {
      handleVdsErrors(AuditLogType.GLUSTER_VOLUME_OPTION_SET_FAILED, errors);
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see org.ovirt.engine.core.bll.CommandBase#executeCommand()
   */
  @Override
  protected void executeCommand() {
    // set the gluster volume name for audit purpose
    setGlusterVolumeName(volume.getName());

    if (volume.getTransportTypes() == null || volume.getTransportTypes().isEmpty()) {
      volume.addTransportType(TransportType.TCP);
    }

    // GLUSTER access protocol is enabled by default
    volume.addAccessProtocol(AccessProtocol.GLUSTER);
    if (!volume.getAccessProtocols().contains(AccessProtocol.NFS)) {
      volume.disableNFS();
    }

    VDSReturnValue returnValue =
        runVdsCommand(
            VDSCommandType.CreateGlusterVolume,
            new CreateGlusterVolumeVDSParameters(upServer.getId(), volume));
    setSucceeded(returnValue.getSucceeded());

    if (!getSucceeded()) {
      handleVdsError(
          AuditLogType.GLUSTER_VOLUME_CREATE_FAILED, returnValue.getVdsError().getMessage());
      return;
    }

    // Volume created successfully. Insert it to database.
    GlusterVolumeEntity createdVolume = (GlusterVolumeEntity) returnValue.getReturnValue();
    setVolumeType(createdVolume);
    setBrickOrder(createdVolume.getBricks());
    addVolumeToDb(createdVolume);

    // set all options of the volume
    setVolumeOptions(createdVolume);

    getReturnValue().setActionReturnValue(createdVolume.getId());
  }
 private GlusterVolumeEntity getReplicatedVolume(Guid volumeId, int brickCount) {
   GlusterVolumeEntity volume = getVolume(volumeId);
   volume.setStatus(GlusterStatus.UP);
   volume.setBricks(getBricks(volumeId, "repl", brickCount));
   volume.setVolumeType(GlusterVolumeType.REPLICATE);
   volume.setReplicaCount(brickCount);
   volume.setClusterId(clusterId);
   return volume;
 }
 @Override
 protected List<Class<?>> getValidationGroups() {
   switch (volume.getVolumeType()) {
     case REPLICATE:
     case DISTRIBUTED_REPLICATE:
       addValidationGroup(CreateReplicatedVolume.class);
       break;
     case STRIPE:
     case DISTRIBUTED_STRIPE:
       addValidationGroup(CreateStripedVolume.class);
       break;
     default:
       addValidationGroup(CreateEntity.class);
   }
   return super.getValidationGroups();
 }
 @Override
 public void render(Context context, GlusterVolumeEntity object, SafeHtmlBuilder sb, String id) {
   GlusterVolumeAdvancedDetails advancedDetails = object.getAdvancedDetails();
   GlusterVolumeSizeInfo sizeInfo = null;
   if (advancedDetails != null) {
     sizeInfo = advancedDetails.getCapacityInfo();
     if (sizeInfo != null) {
       setFreeSize(sizeInfo.getFreeSize().doubleValue());
       setTotalSize(sizeInfo.getTotalSize().doubleValue());
       setUsedSize(sizeInfo.getUsedSize().doubleValue());
       setInUnit(SizeUnit.BYTES);
     }
   }
   super.render(
       context, advancedDetails == null ? null : sizeInfo == null ? null : sizeInfo, sb, id);
 }
  private GlusterVolumeEntity getNewVolume() {
    GlusterVolumeEntity volume = new GlusterVolumeEntity();
    volume.setName(NEW_VOL_NAME);
    volume.setClusterId(CLUSTER_ID);
    volume.setId(NEW_VOL_ID);
    volume.setVolumeType(GlusterVolumeType.DISTRIBUTE);
    volume.addTransportType(TransportType.TCP);
    volume.setReplicaCount(0);
    volume.setStripeCount(0);
    volume.setStatus(GlusterStatus.UP);
    volume.setOption("auth.allow", "*");
    volume.addAccessProtocol(AccessProtocol.GLUSTER);
    volume.addAccessProtocol(AccessProtocol.NFS);

    GlusterBrickEntity brick = new GlusterBrickEntity();
    brick.setVolumeId(NEW_VOL_ID);
    brick.setServerId(existingServer1.getId());
    brick.setServerName(existingServer1.getHostName());
    brick.setBrickDirectory("/export/testvol1");
    brick.setStatus(GlusterStatus.UP);
    brick.setBrickOrder(0);
    volume.addBrick(brick);

    return volume;
  }
 private void addVolumeToDb(final GlusterVolumeEntity createdVolume) {
   // volume fetched from VDSM doesn't contain cluster id as
   // GlusterFS is not aware of multiple clusters
   createdVolume.setClusterId(getVdsGroupId());
   DbFacade.getInstance().getGlusterVolumeDao().save(createdVolume);
 }
  private void verifyMocksForLightWeight() {
    InOrder inOrder =
        inOrder(
            clusterDao,
            vdsDao,
            glusterUtil,
            glusterManager,
            vdsStatisticsDao,
            vdsDynamicDao,
            vdsStaticDao,
            volumeDao,
            brickDao,
            optionDao);

    // all clusters fetched from db
    inOrder.verify(clusterDao, times(1)).getAll();

    // get servers of the cluster from db
    inOrder.verify(vdsDao, times(1)).getAllForCluster(CLUSTER_ID);

    // get the UP server from cluster
    inOrder.verify(glusterUtil, times(1)).getUpServer(CLUSTER_ID);

    // acquire lock on the cluster
    inOrder.verify(glusterManager, times(1)).acquireLock(CLUSTER_ID);

    // servers are fetched from glusterfs
    inOrder.verify(glusterManager, times(1)).fetchServers(existingServer1);

    // detached server SERVER_ID_3 is deleted from DB
    inOrder.verify(vdsStatisticsDao, times(1)).remove(SERVER_ID_3);
    inOrder.verify(vdsDynamicDao, times(1)).remove(SERVER_ID_3);
    inOrder.verify(vdsStaticDao, times(1)).remove(SERVER_ID_3);

    // detached server SERVER_ID_3 is removed from resource manager
    inOrder
        .verify(glusterManager, times(1))
        .runVdsCommand(eq(VDSCommandType.RemoveVds), any(RemoveVdsVDSCommandParameters.class));

    // release lock on the cluster
    inOrder.verify(glusterManager, times(1)).releaseLock(CLUSTER_ID);

    // acquire lock on the cluster for next operation (refresh volumes)
    inOrder.verify(glusterManager, times(1)).acquireLock(CLUSTER_ID);

    // volumes are fetched from glusterfs
    inOrder.verify(glusterManager, times(1)).fetchVolumes(any(VDS.class));

    // get volumes by cluster id to identify those that need to be removed
    inOrder.verify(volumeDao, times(1)).getByClusterId(CLUSTER_ID);
    // remove deleted volumes
    inOrder.verify(volumeDao, times(1)).removeAll(argThat(areRemovedVolumes()));

    // create new volume
    inOrder.verify(volumeDao, times(1)).save(newVolume);

    // remove detached bricks
    inOrder.verify(brickDao, times(1)).removeAll(argThat(containsRemovedBricks()));
    // add new bricks
    inOrder.verify(brickDao, times(2)).save(argThat(isAddedBrick()));

    // add new options
    inOrder.verify(optionDao, times(1)).saveAll(argThat(areAddedOptions()));

    // update modified options
    Map<String, GlusterVolumeOptionEntity> existingOptions = new HashMap<>();
    existingReplVol.getOption(OPTION_NFS_DISABLE).setValue(OPTION_VALUE_ON);
    existingOptions.put(OPTION_NFS_DISABLE, existingReplVol.getOption(OPTION_NFS_DISABLE));
    List<GlusterVolumeOptionEntity> list = new ArrayList<>(existingOptions.values());
    Collections.sort(list);
    inOrder.verify(optionDao, times(1)).updateAll("UpdateGlusterVolumeOption", list);

    // delete removed options
    inOrder.verify(optionDao, times(1)).removeAll(argThat(areRemovedOptions()));

    // release lock on the cluster
    inOrder.verify(glusterManager, times(1)).releaseLock(CLUSTER_ID);
  }
 public CreateGlusterVolumeCommand(CreateGlusterVolumeParameters params) {
   super(params);
   volume = getParameters().getVolume();
   setVdsGroupId(volume.getClusterId());
 }
 private void setVolumeType(GlusterVolumeEntity createdVolume) {
   if (createdVolume.getVolumeType() == GlusterVolumeType.REPLICATE
       && createdVolume.getBricks().size() > createdVolume.getReplicaCount()) {
     createdVolume.setVolumeType(GlusterVolumeType.DISTRIBUTED_REPLICATE);
   } else if (createdVolume.getVolumeType() == GlusterVolumeType.DISTRIBUTED_REPLICATE
       && createdVolume.getBricks().size() == createdVolume.getReplicaCount()) {
     createdVolume.setVolumeType(GlusterVolumeType.REPLICATE);
   } else if (createdVolume.getVolumeType() == GlusterVolumeType.STRIPE
       && createdVolume.getBricks().size() > createdVolume.getStripeCount()) {
     createdVolume.setVolumeType(GlusterVolumeType.DISTRIBUTED_STRIPE);
   } else if (createdVolume.getVolumeType() == GlusterVolumeType.DISTRIBUTED_STRIPE
       && createdVolume.getBricks().size() == createdVolume.getStripeCount()) {
     createdVolume.setVolumeType(GlusterVolumeType.STRIPE);
   }
 }