/**
 * If so throws an error if the workspace type is USER and the workspaceId and userID do not
 * match. Is a NO-OP if userinfo is null.
 */
public static void checkPersonalWorkspace(
    UserInfo userInfo,
    WorkspaceType workspaceType,
    String workspaceId,
    String resourceNameString) {
  if (userInfo != null
      && workspaceType == WorkspaceType.USER
      && !workspaceId.equals(userInfo.getVertaInfo().getUserId())) {
    Status status =
        Status.newBuilder()
            .setCode(Code.PERMISSION_DENIED_VALUE)
            .setMessage(
                "Creation of "
                    + resourceNameString
                    + " in other user's workspace is not permitted")
            .addDetails(Any.pack(UpdateProjectName.Response.getDefaultInstance()))
            .build();
    throw StatusProto.toStatusRuntimeException(status);
  }
}
 

private UserInfo getUnsignedUser(boolean retry) {
  try (AuthServiceChannel authServiceChannel = new AuthServiceChannel()) {
    LOGGER.info(ModelDBMessages.AUTH_SERVICE_REQ_SENT_MSG);
    GetUser getUserRequest =
        GetUser.newBuilder().setUsername(ModelDBConstants.UNSIGNED_USER).build();
    // Get the user info by vertaId form the AuthService
    UserInfo userInfo = authServiceChannel.getUacServiceBlockingStub().getUser(getUserRequest);
    LOGGER.info(ModelDBMessages.AUTH_SERVICE_RES_RECEIVED_MSG);

    if (userInfo == null || userInfo.getVertaInfo() == null) {
      LOGGER.warn("unsigned user not found {}", userInfo);
      Status status =
          Status.newBuilder()
              .setCode(Code.NOT_FOUND_VALUE)
              .setMessage("Unsigned user not found with the provided metadata")
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    } else {
      return userInfo;
    }
  } catch (StatusRuntimeException ex) {
    return (UserInfo)
        ModelDBUtils.retryOrThrowException(
            ex, retry, (ModelDBUtils.RetryCallInterface<UserInfo>) this::getUnsignedUser);
  }
}
 

public AuthServiceChannel() {
  App app = App.getInstance();
  String host = app.getAuthServerHost();
  Integer port = app.getAuthServerPort();
  LOGGER.trace(ModelDBMessages.HOST_PORT_INFO_STR, host, port);
  if (host != null && port != null) { // AuthService not available.
    authServiceChannel =
        ManagedChannelBuilder.forTarget(host + ModelDBConstants.STRING_COLON + port)
            .usePlaintext()
            .build();

    this.serviceUserEmail = app.getServiceUserEmail();
    this.serviceUserDevKey = app.getServiceUserDevKey();
  } else {
    Status status =
        Status.newBuilder()
            .setCode(Code.UNAVAILABLE_VALUE)
            .setMessage("Host OR Port not found for contacting authentication service")
            .build();
    throw StatusProto.toStatusRuntimeException(status);
  }
}
 

@Override
public Project getProjectByID(String id) throws InvalidProtocolBufferException {
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    Query query = session.createQuery(GET_PROJECT_BY_ID_HQL);
    query.setParameter("id", id);
    ProjectEntity projectEntity = (ProjectEntity) query.uniqueResult();
    if (projectEntity == null) {
      String errorMessage = ModelDBMessages.PROJECT_NOT_FOUND_FOR_ID;
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder().setCode(Code.NOT_FOUND_VALUE).setMessage(errorMessage).build();
      throw StatusProto.toStatusRuntimeException(status);
    }
    LOGGER.debug(ModelDBMessages.GETTING_PROJECT_BY_ID_MSG_STR);
    return projectEntity.getProtoObject();
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return getProjectByID(id);
    } else {
      throw ex;
    }
  }
}
 

private UserInfo getCurrentLoginUserInfo(boolean retry) {
  try (AuthServiceChannel authServiceChannel = new AuthServiceChannel()) {
    LOGGER.info(ModelDBMessages.AUTH_SERVICE_REQ_SENT_MSG);
    UserInfo userInfo =
        authServiceChannel.getUacServiceBlockingStub().getCurrentUser(Empty.newBuilder().build());
    LOGGER.info(ModelDBMessages.AUTH_SERVICE_RES_RECEIVED_MSG);

    if (userInfo == null || userInfo.getVertaInfo() == null) {
      LOGGER.info("user not found {}", userInfo);
      Status status =
          Status.newBuilder()
              .setCode(Code.NOT_FOUND_VALUE)
              .setMessage("Current user could not be resolved.")
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    } else {
      return userInfo;
    }
  } catch (StatusRuntimeException ex) {
    return (UserInfo)
        ModelDBUtils.retryOrThrowException(
            ex, retry, (ModelDBUtils.RetryCallInterface<UserInfo>) this::getCurrentLoginUserInfo);
  }
}
 

@Override
public String getProjectIdByExperimentRunId(String experimentRunId) {
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    ExperimentRunEntity experimentRunObj =
        session.get(ExperimentRunEntity.class, experimentRunId);
    if (experimentRunObj != null) {
      LOGGER.debug("Got ProjectId by ExperimentRunId ");
      return experimentRunObj.getProject_id();
    } else {
      String errorMessage = "ExperimentRun not found for given ID : " + experimentRunId;
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder().setCode(Code.NOT_FOUND_VALUE).setMessage(errorMessage).build();
      throw StatusProto.toStatusRuntimeException(status);
    }
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return getProjectIdByExperimentRunId(experimentRunId);
    } else {
      throw ex;
    }
  }
}
 

/**
 * Converts the given {@link StatusRuntimeException} to a {@link UserException}, if possible.
 *
 * @param sre status runtime exception
 * @return user exception if one is passed as part of the details
 */
public static Optional<UserException> fromStatusRuntimeException(StatusRuntimeException sre) {
  final Status statusProto = StatusProto.fromThrowable(sre);
  if (statusProto == null) {
    return Optional.empty();
  }
  return fromStatus(statusProto);
}
 

private static Status statusFromThrowable(Throwable t) {
  Status status = StatusProto.fromThrowable(t);
  if (status == null) {
    status =
        Status.newBuilder().setCode(io.grpc.Status.fromThrowable(t).getCode().value()).build();
  }
  return status;
}
 

@Override
public Iterable<Digest> putAllBlobs(Iterable<ByteString> blobs, RequestMetadata requestMetadata)
    throws ExcessiveWriteSizeException, IOException, InterruptedException {
  ImmutableList.Builder<Digest> blobDigestsBuilder = new ImmutableList.Builder<Digest>();
  PutAllBlobsException exception = null;
  for (ByteString blob : blobs) {
    Digest digest = digestUtil.compute(blob);
    try {
      blobDigestsBuilder.add(putBlob(this, digest, blob, 1, SECONDS, requestMetadata));
    } catch (StatusException e) {
      if (exception == null) {
        exception = new PutAllBlobsException();
      }
      com.google.rpc.Status status = StatusProto.fromThrowable(e);
      if (status == null) {
        status =
            com.google.rpc.Status.newBuilder()
                .setCode(Status.fromThrowable(e).getCode().value())
                .build();
      }
      exception.addFailedResponse(
          BatchUpdateBlobsResponse.Response.newBuilder()
              .setDigest(digest)
              .setStatus(status)
              .build());
    }
  }
  if (exception != null) {
    throw exception;
  }
  return blobDigestsBuilder.build();
}
 

@Override
public void getExperimentRunComments(
    GetComments request, StreamObserver<Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    if (request.getEntityId().isEmpty()) {
      String errorMessage = "Entity ID not found in GetComments request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(GetComments.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }
    String projectId = experimentRunDAO.getProjectIdByExperimentRunId(request.getEntityId());
    // Validate if current user has access to the entity or not
    roleService.validateEntityUserWithUserInfo(
        ModelDBServiceResourceTypes.PROJECT, projectId, ModelDBServiceActions.READ);

    List<Comment> comments = commentDAO.getComments(experimentRunEntity, request.getEntityId());
    responseObserver.onNext(GetComments.Response.newBuilder().addAllComments(comments).build());
    responseObserver.onCompleted();
  } catch (Exception e) {
    ModelDBUtils.observeError(responseObserver, e, GetComments.Response.getDefaultInstance());
  }
}
 

@Override
public Boolean deleteExperimentRuns(List<String> experimentRunIds) {
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {

    List<String> accessibleExperimentRunIds =
        getAccessibleExperimentRunIDs(
            experimentRunIds, ModelDBActionEnum.ModelDBServiceActions.UPDATE);
    if (accessibleExperimentRunIds.isEmpty()) {
      Status statusMessage =
          Status.newBuilder()
              .setCode(Code.PERMISSION_DENIED_VALUE)
              .setMessage(
                  "Access is denied. User is unauthorized for given ExperimentRun entities : "
                      + accessibleExperimentRunIds)
              .build();
      throw StatusProto.toStatusRuntimeException(statusMessage);
    }
    Transaction transaction = session.beginTransaction();
    Query query = session.createQuery(DELETED_STATUS_EXPERIMENT_RUN_QUERY_STRING);
    query.setParameter("deleted", true);
    query.setParameter("experimentRunIds", accessibleExperimentRunIds);
    int updatedCount = query.executeUpdate();
    LOGGER.debug(
        "Mark ExperimentRun as deleted : {}, count : {}",
        accessibleExperimentRunIds,
        updatedCount);
    transaction.commit();
    LOGGER.debug("ExperimentRun deleted successfully");
    return true;
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return deleteExperimentRuns(experimentRunIds);
    } else {
      throw ex;
    }
  }
}
 

/**
 * Update project name in Project Entity. Create project object with updated data from
 * UpdateProjectName request and update in database.
 *
 * @param UpdateProjectName request, UpdateProjectName.Response response
 * @return void
 */
@Override
public void updateProjectName(
    UpdateProjectName request, StreamObserver<UpdateProjectName.Response> responseObserver) {
  QPSCountResource.inc();

  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    // Request Parameter Validation
    if (request.getId().isEmpty()) {
      String errorMessage = "Project ID not found in UpdateProjectName request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(UpdateProjectName.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    // Validate if current user has access to the entity or not
    roleService.validateEntityUserWithUserInfo(
        ModelDBServiceResourceTypes.PROJECT, request.getId(), ModelDBServiceActions.UPDATE);

    Project updatedProject =
        projectDAO.updateProjectName(
            request.getId(), ModelDBUtils.checkEntityNameLength(request.getName()));
    responseObserver.onNext(
        UpdateProjectName.Response.newBuilder().setProject(updatedProject).build());
    responseObserver.onCompleted();

  } catch (Exception e) {
    ModelDBUtils.observeError(
        responseObserver, e, UpdateProjectName.Response.getDefaultInstance());
  }
}
 

@Override
public List<Observation> getObservationByKey(String experimentRunId, String observationKey)
    throws InvalidProtocolBufferException {

  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    ExperimentRunEntity experimentRunEntityObj =
        session.get(ExperimentRunEntity.class, experimentRunId);
    if (experimentRunEntityObj == null) {
      LOGGER.info(ModelDBMessages.EXP_RUN_NOT_FOUND_ERROR_MSG);
      Status status =
          Status.newBuilder()
              .setCode(Code.NOT_FOUND_VALUE)
              .setMessage(ModelDBMessages.EXP_RUN_NOT_FOUND_ERROR_MSG)
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }
    ExperimentRun experimentRun = experimentRunEntityObj.getProtoObject();
    List<Observation> observationEntities = new ArrayList<>();
    for (Observation observation : experimentRun.getObservationsList()) {
      if ((observation.hasArtifact() && observation.getArtifact().getKey().equals(observationKey))
          || (observation.hasAttribute()
              && observation.getAttribute().getKey().equals(observationKey))) {
        observationEntities.add(observation);
      }
    }
    return observationEntities;
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return getObservationByKey(experimentRunId, observationKey);
    } else {
      throw ex;
    }
  }
}
 

/**
 * This is the common method for all to throw an exception to the UI
 *
 * @param errorMessage : error message throws by any service
 * @param errorCode : error code like Code.NOT_FOUND, Code.INTERNAL etc.
 * @param defaultResponse : Method reference to identify the error block
 */
public static void logAndThrowError(String errorMessage, int errorCode, Any defaultResponse) {
  LOGGER.warn(errorMessage);
  Status status =
      Status.newBuilder()
          .setCode(errorCode)
          .setMessage(errorMessage)
          .addDetails(defaultResponse)
          .build();
  throw StatusProto.toStatusRuntimeException(status);
}
 

@Override
public void getProjectTags(GetTags request, StreamObserver<GetTags.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    // Request Parameter Validation
    if (request.getId().isEmpty()) {
      String errorMessage = "Project ID not found in GetTags request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(GetTags.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    // Validate if current user has access to the entity or not
    roleService.validateEntityUserWithUserInfo(
        ModelDBServiceResourceTypes.PROJECT, request.getId(), ModelDBServiceActions.READ);

    List<String> tags = projectDAO.getProjectTags(request.getId());
    responseObserver.onNext(GetTags.Response.newBuilder().addAllTags(tags).build());
    responseObserver.onCompleted();

  } catch (Exception e) {
    ModelDBUtils.observeError(responseObserver, e, GetTags.Response.getDefaultInstance());
  }
}
 

@Override
public Experiment deepCopyExperimentForUser(
    Experiment srcExperiment, Project newProject, UserInfo newOwner)
    throws InvalidProtocolBufferException {
  checkIfEntityAlreadyExists(srcExperiment, false);

  if (newOwner == null || newProject == null) {
    Status status =
        Status.newBuilder()
            .setCode(Code.INVALID_ARGUMENT_VALUE)
            .setMessage("New owner or new project not passed for cloning Experiment.")
            .build();
    throw StatusProto.toStatusRuntimeException(status);
  }

  Experiment copyExperiment = copyExperimentAndUpdateDetails(srcExperiment, newProject, newOwner);
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    ExperimentEntity experimentObj = RdbmsUtils.generateExperimentEntity(copyExperiment);
    Transaction transaction = session.beginTransaction();
    session.saveOrUpdate(experimentObj);
    transaction.commit();
    LOGGER.debug("Experiment copied successfully");
    return experimentObj.getProtoObject();
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return deepCopyExperimentForUser(srcExperiment, newProject, newOwner);
    } else {
      throw ex;
    }
  }
}
 

public static SessionFactory getSessionFactory() {
  try {
    return createOrGetSessionFactory();
  } catch (Exception e) {
    Status status =
        Status.newBuilder().setCode(Code.INTERNAL_VALUE).setMessage(e.getMessage()).build();
    throw StatusProto.toStatusRuntimeException(status);
  }
}
 

@Override
public void deepCopyProject(
    DeepCopyProject request, StreamObserver<DeepCopyProject.Response> responseObserver) {
  QPSCountResource.inc();

  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    // Request Parameter Validation
    if (request.getId() == null) {
      String errorMessage = "Project ID not found in DeepCopyProject request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(GetProjectByName.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    // Get the user info from the Context
    UserInfo userInfo = authService.getCurrentLoginUserInfo();

    Project project = projectDAO.deepCopyProjectForUser(request.getId(), userInfo);

    responseObserver.onNext(DeepCopyProject.Response.newBuilder().setProject(project).build());
    responseObserver.onCompleted();

  } catch (Exception e) {
    ModelDBUtils.observeError(responseObserver, e, DeepCopyProject.Response.getDefaultInstance());
  }
}
 

@Override
public void getProjectReadme(
    GetProjectReadme request, StreamObserver<GetProjectReadme.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    // Request Parameter Validation
    if (request.getId().isEmpty()) {
      String errorMessage = "Project ID not found in GetProjectReadme request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(GetProjectReadme.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    // Validate if current user has access to the entity or not
    roleService.validateEntityUserWithUserInfo(
        ModelDBServiceResourceTypes.PROJECT, request.getId(), ModelDBServiceActions.READ);

    Project project = projectDAO.getProjectByID(request.getId());
    responseObserver.onNext(
        GetProjectReadme.Response.newBuilder().setReadmeText(project.getReadmeText()).build());
    responseObserver.onCompleted();
  } catch (Exception e) {
    ModelDBUtils.observeError(
        responseObserver, e, GetProjectReadme.Response.getDefaultInstance());
  }
}
 

@Override
public void getProjectShortName(
    GetProjectShortName request, StreamObserver<GetProjectShortName.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    // Request Parameter Validation
    if (request.getId().isEmpty()) {
      String errorMessage = "Project ID not found in GetProjectShortName request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(GetProjectShortName.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    // Validate if current user has access to the entity or not
    roleService.validateEntityUserWithUserInfo(
        ModelDBServiceResourceTypes.PROJECT, request.getId(), ModelDBServiceActions.READ);

    Project project = projectDAO.getProjectByID(request.getId());
    responseObserver.onNext(
        GetProjectShortName.Response.newBuilder().setShortName(project.getShortName()).build());
    responseObserver.onCompleted();
  } catch (Exception e) {
    ModelDBUtils.observeError(
        responseObserver, e, GetProjectShortName.Response.getDefaultInstance());
  }
}
 

@Override
public Experiment addExperimentAttributes(String experimentId, List<KeyValue> attributes)
    throws InvalidProtocolBufferException {
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    ExperimentEntity experimentObj = session.get(ExperimentEntity.class, experimentId);
    if (experimentObj == null) {
      String errorMessage = ModelDBMessages.EXPERIMENT_NOT_FOUND_ERROR_MSG + experimentId;
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder().setCode(Code.NOT_FOUND_VALUE).setMessage(errorMessage).build();
      throw StatusProto.toStatusRuntimeException(status);
    }
    experimentObj.setAttributeMapping(
        RdbmsUtils.convertAttributesFromAttributeEntityList(
            experimentObj, ModelDBConstants.ATTRIBUTES, attributes));
    long currentTimestamp = Calendar.getInstance().getTimeInMillis();
    experimentObj.setDate_updated(currentTimestamp);
    Transaction transaction = session.beginTransaction();
    session.saveOrUpdate(experimentObj);
    transaction.commit();
    LOGGER.debug("Experiment attributes added successfully");
    return experimentObj.getProtoObject();
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return addExperimentAttributes(experimentId, attributes);
    } else {
      throw ex;
    }
  }
}
 

private static boolean retriableExecErrors(Exception e) {
  if (e instanceof BulkTransferException) {
    BulkTransferException bulkTransferException = (BulkTransferException) e;
    return bulkTransferException.onlyCausedByCacheNotFoundException();
  }
  if (!RemoteRetrierUtils.causedByStatus(e, Code.FAILED_PRECONDITION)) {
    return false;
  }
  com.google.rpc.Status status = StatusProto.fromThrowable(e);
  if (status == null || status.getDetailsCount() == 0) {
    return false;
  }
  for (Any details : status.getDetailsList()) {
    PreconditionFailure f;
    try {
      f = details.unpack(PreconditionFailure.class);
    } catch (InvalidProtocolBufferException protoEx) {
      return false;
    }
    if (f.getViolationsCount() == 0) {
      return false; // Generally shouldn't happen
    }
    for (Violation v : f.getViolationsList()) {
      if (!v.getType().equals(VIOLATION_TYPE_MISSING)) {
        return false;
      }
    }
  }
  return true; // if *all* > 0 violations have type MISSING
}
 

@Override
public Project setProjectShortName(String projectId, String projectShortName, UserInfo userInfo)
    throws InvalidProtocolBufferException {
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    Query query = session.createQuery(GET_PROJECT_BY_SHORT_NAME_AND_OWNER_HQL);
    query.setParameter("projectShortName", projectShortName);
    query.setParameter("vertaId", authService.getVertaIdFromUserInfo(userInfo));
    ProjectEntity projectEntity = (ProjectEntity) query.uniqueResult();
    if (projectEntity != null) {
      Status status =
          Status.newBuilder()
              .setCode(Code.ALREADY_EXISTS_VALUE)
              .setMessage("Project already exist with given short name")
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    query = session.createQuery(GET_PROJECT_BY_ID_HQL);
    query.setParameter("id", projectId);
    projectEntity = (ProjectEntity) query.uniqueResult();
    projectEntity.setShort_name(projectShortName);
    projectEntity.setDate_updated(Calendar.getInstance().getTimeInMillis());
    Transaction transaction = session.beginTransaction();
    session.update(projectEntity);
    transaction.commit();
    LOGGER.debug(ModelDBMessages.GETTING_PROJECT_BY_ID_MSG_STR);
    return projectEntity.getProtoObject();
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return setProjectShortName(projectId, projectShortName, userInfo);
    } else {
      throw ex;
    }
  }
}
 

@Override
public Boolean deleteDatasets(List<String> datasetIds) {
  // Get self allowed resources id where user has delete permission
  List<String> allowedDatasetIds =
      roleService.getAccessibleResourceIdsByActions(
          ModelDBServiceResourceTypes.DATASET,
          ModelDBActionEnum.ModelDBServiceActions.DELETE,
          datasetIds);
  if (allowedDatasetIds.isEmpty()) {
    Status status =
        Status.newBuilder()
            .setCode(Code.PERMISSION_DENIED_VALUE)
            .setMessage("Access Denied for given dataset Ids : " + datasetIds)
            .build();
    throw StatusProto.toStatusRuntimeException(status);
  }

  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    Transaction transaction = session.beginTransaction();
    Query deletedDatasetsQuery = session.createQuery(DELETED_STATUS_DATASET_QUERY_STRING);
    deletedDatasetsQuery.setParameter("deleted", true);
    deletedDatasetsQuery.setParameter("datasetIds", allowedDatasetIds);
    int updatedCount = deletedDatasetsQuery.executeUpdate();
    LOGGER.debug("Mark Datasets as deleted : {}, count : {}", allowedDatasetIds, updatedCount);
    transaction.commit();
    LOGGER.debug("Dataset deleted successfully");
    return true;
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return deleteDatasets(datasetIds);
    } else {
      throw ex;
    }
  }
}
 

@Override
public void logMetrics(LogMetrics request, StreamObserver<LogMetrics.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    String errorMessage = null;
    if (request.getId().isEmpty() && request.getMetricsList().isEmpty()) {
      errorMessage = "ExperimentRun ID and New Metrics not found in LogMetrics request";
    } else if (request.getId().isEmpty()) {
      errorMessage = "ExperimentRun ID not found in LogMetrics request";
    } else if (request.getMetricsList().isEmpty()) {
      errorMessage = "New Metrics not found in LogMetrics request";
    }

    if (errorMessage != null) {
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(LogMetrics.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    String projectId = experimentRunDAO.getProjectIdByExperimentRunId(request.getId());
    // Validate if current user has access to the entity or not
    roleService.validateEntityUserWithUserInfo(
        ModelDBServiceResourceTypes.PROJECT, projectId, ModelDBServiceActions.UPDATE);

    experimentRunDAO.logMetrics(request.getId(), request.getMetricsList());
    responseObserver.onNext(LogMetrics.Response.newBuilder().build());
    responseObserver.onCompleted();

  } catch (Exception e) {
    ModelDBUtils.observeError(responseObserver, e, LogMetrics.Response.getDefaultInstance());
  }
}
 

private void logAndThrowError(String errorMessage, int errorCode, Any defaultResponse) {
  LOGGER.warn(errorMessage);
  Status status =
      Status.newBuilder()
          .setCode(errorCode)
          .setMessage(errorMessage)
          .addDetails(defaultResponse)
          .build();
  throw StatusProto.toStatusRuntimeException(status);
}
 

/** Deletes dataset corresponding to the id. Required input parameter : id */
@Override
public void deleteDataset(
    DeleteDataset request, StreamObserver<DeleteDataset.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    // Request Parameter Validation
    if (request.getId().isEmpty()) {
      LOGGER.info(ModelDBMessages.DATASET_ID_NOT_FOUND_IN_REQUEST);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(ModelDBMessages.DATASET_ID_NOT_FOUND_IN_REQUEST)
              .addDetails(Any.pack(DeleteDataset.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    boolean deleteStatus = datasetDAO.deleteDatasets(Collections.singletonList(request.getId()));
    responseObserver.onNext(DeleteDataset.Response.newBuilder().setStatus(deleteStatus).build());
    responseObserver.onCompleted();

  } catch (Exception e) {
    ModelDBUtils.observeError(responseObserver, e, DeleteDataset.Response.getDefaultInstance());
  }
}
 

public static String checkEntityNameLength(String entityName) {
  if (entityName != null && entityName.length() > ModelDBConstants.NAME_LENGTH) {
    String errorMessage =
        "Entity name can not be more than " + ModelDBConstants.NAME_LENGTH + " characters";
    LOGGER.info(errorMessage);
    Status status =
        Status.newBuilder().setCode(Code.INVALID_ARGUMENT_VALUE).setMessage(errorMessage).build();
    throw StatusProto.toStatusRuntimeException(status);
  }
  return entityName;
}
 

@Override
public boolean addLabels(IdentificationType id, List<String> labels) {
  try (Session session = ModelDBHibernateUtil.getSessionFactory().openSession()) {
    Transaction transaction = session.beginTransaction();
    for (String label : labels) {
      LabelsMappingEntity labelsMappingEntity = new LabelsMappingEntity(id, label);
      LabelsMappingEntity existingLabelsMappingEntity =
          session.get(LabelsMappingEntity.class, labelsMappingEntity.getId());
      if (existingLabelsMappingEntity == null) {
        session.save(labelsMappingEntity);
      } else {
        Status status =
            Status.newBuilder()
                .setCode(Code.ALREADY_EXISTS_VALUE)
                .setMessage("Label '" + label + "' already exists with given ID")
                .build();
        throw StatusProto.toStatusRuntimeException(status);
      }
    }
    transaction.commit();
    return true;
  } catch (Exception ex) {
    if (ModelDBUtils.needToRetry(ex)) {
      return addLabels(id, labels);
    } else {
      throw ex;
    }
  }
}
 

@Override
public String getUsernameFromUserInfo(UserInfo userInfo) {
  if (userInfo != null
      && userInfo.getVertaInfo() != null
      && !userInfo.getVertaInfo().getUsername().isEmpty()) {
    return userInfo.getVertaInfo().getUsername();
  }
  Status status =
      Status.newBuilder()
          .setCode(Code.NOT_FOUND_VALUE)
          .setMessage("Username not found in userInfo")
          .build();
  throw StatusProto.toStatusRuntimeException(status);
}