Best code snippets using org.ovirt.engine.core.common.businessentities.storage.StorageServerConnectionExtension(Showing top 15 results out of 315)

@Override
protected MapSqlParameterSource createFullParametersMapper(StorageServerConnectionExtension entity) {
  return createIdParameterMapper(entity.getId())
      .addValue("vds_id", entity.getHostId())
      .addValue("iqn", entity.getIqn())
      .addValue("user_name", entity.getUserName())
      .addValue("password", DbFacadeUtils.encryptPassword(entity.getPassword()));
}

@Override
protected boolean validate() {
  StorageServerConnectionExtension conn = getParameters().getStorageServerConnectionExtension();
  return validate(getConnectionExtensionValidator().isConnectionExtensionExists(conn.getId())) &&
      validate(getConnectionExtensionValidator().isConnectionDoesNotExistForHostAndTarget(conn));
}

  @Override
  protected Map<String, Pair<String, String>> getExclusiveLocks() {
    StorageServerConnectionExtension connExt = getParameters().getStorageServerConnectionExtension();
    String lock = connExt.getHostId().toString() + connExt.getIqn();
    return Collections.singletonMap(lock,
        LockMessagesMatchUtil.makeLockingPair(LockingGroup.STORAGE_CONNECTION_EXTENSION,
            EngineMessage.ACTION_TYPE_FAILED_OBJECT_LOCKED));
  }
}

public ValidationResult isConnectionDoesNotExistForHostAndTarget(StorageServerConnectionExtension connExt) {
  StorageServerConnectionExtension existingConnExt = getDbFacade().getStorageServerConnectionExtensionDao().getByHostIdAndTarget(
      connExt.getHostId(),
      connExt.getIqn());
  if (existingConnExt != null && !existingConnExt.getId().equals(connExt.getId())) {
    VDS host = getDbFacade().getVdsDao().get(connExt.getHostId());
    return new ValidationResult(EngineMessage.ACTION_TYPE_FAILED_STORAGE_CONNECTION_EXTENSION_ALREADY_EXISTS,
        String.format("$target %s", connExt.getIqn()),
        String.format("$vdsName %s", host.getName()));
  }
  return ValidationResult.VALID;
}

@Override
protected void executeCommand() {
  storageServerConnectionExtensionDao.save(getParameters().getStorageServerConnectionExtension());
  getReturnValue().setActionReturnValue(getParameters().getStorageServerConnectionExtension().getId());
  getReturnValue().setSucceeded(true);
}

protected static StorageServerConnectionExtension getEntity(Guid extensionID, Guid hostID, String pass, String username, String iqn) {
  StorageServerConnectionExtension extension = new StorageServerConnectionExtension();
  extension.setId(extensionID);
  extension.setHostId(hostID);
  extension.setPassword(pass);
  extension.setUserName(username);
  extension.setIqn(iqn);
  return extension;
}

@Override
public Response add(StorageConnectionExtension storageConnectionExtension) {
  StorageServerConnectionExtension connExt = StorageServerConnectionExtensionMapper.map(storageConnectionExtension, null);
  connExt.setHostId(hostId);
  StorageServerConnectionExtensionParameters params = new StorageServerConnectionExtensionParameters(connExt);
  return performCreate(ActionType.AddStorageServerConnectionExtension, params,
      new QueryIdResolver<Guid>(QueryType.GetStorageServerConnectionExtensionById,
          IdQueryParameters.class));
}

  @Override
  public String toString() {
    return ToStringBuilder.forInstance(this)
        .append("hostId", getHostId())
        .append("target", getIqn())
        .append("username", getUserName())
        .build();
  }
}

  public Pair<String, String> getStorageConnectionCredentialsForhost(Guid hostId, StorageServerConnections connection) {
    Pair<String, String> credentials;
    StorageServerConnectionExtension connExt = storageServerConnectionExtensionDao.getByHostIdAndTarget(hostId, connection.getIqn());
    if (connExt == null) {
      credentials = new Pair<>(connection.getUserName(), connection.getPassword());
    }
    else {
      credentials = new Pair<>(connExt.getUserName(), connExt.getPassword());
    }
    return credentials;
  }
}

@Test
public void testCredentialsWithConnectionExtensionDifferentHostSameTarget() {
  StorageServerConnections conn = createConnectionWithCredentials("target1");
  StorageServerConnectionExtension connExt = createConnectionExtension(Guid.newGuid());
  Pair<String, String> credentials = helper.getStorageConnectionCredentialsForhost(connExt.getHostId(), conn);
  assertCredentials(credentials, conn.getUserName(), conn.getPassword());
}

private static StorageServerConnectionExtension createConnectionExtension(Guid hostId) {
  StorageServerConnectionExtension connExt = new StorageServerConnectionExtension();
  connExt.setHostId(hostId);
  connExt.setIqn("target1");
  connExt.setUserName("userConnExt");
  connExt.setPassword("pwdConnExt");
  return connExt;
}

@Override
protected void init() {
  super.init();
  setVdsId(getParameters().getStorageServerConnectionExtension().getHostId());
}

protected Map<String, Pair<String, String>> createIdAndHostTargetLockMap(StorageServerConnectionExtension connExt) {
  Map<String, Pair<String, String>> lockMap = new HashMap<>();
  Pair<String, String> lockingPair = LockMessagesMatchUtil.makeLockingPair(LockingGroup.STORAGE_CONNECTION_EXTENSION,
      EngineMessage.ACTION_TYPE_FAILED_OBJECT_LOCKED);
  String idLock = connExt.getId().toString();
  String hostTargetLock = connExt.getHostId().toString() + connExt.getIqn();
  lockMap.put(idLock, lockingPair);
  lockMap.put(hostTargetLock, lockingPair);
  return lockMap;
}

@Test
public void testCredentialsWithConnectionExtension() {
  StorageServerConnections conn = createConnectionWithCredentials("target1");
  StorageServerConnectionExtension connExt = createConnectionExtension(Guid.newGuid());
  when(connExtDaoMock.getByHostIdAndTarget(connExt.getHostId(), connExt.getIqn())).thenReturn(connExt);
  Pair<String, String> credentials = helper.getStorageConnectionCredentialsForhost(connExt.getHostId(), conn);
  assertCredentials(credentials, connExt.getUserName(), connExt.getPassword());
}

@Test
public void testCredentialsWithConnectionExtensionSameHostDifferentTarget() {
  StorageServerConnections conn = createConnectionWithCredentials("target2");
  StorageServerConnectionExtension connExt = createConnectionExtension(Guid.newGuid());
  Pair<String, String> credentials = helper.getStorageConnectionCredentialsForhost(connExt.getHostId(), conn);
  assertCredentials(credentials, conn.getUserName(), conn.getPassword());
}