org.sonatype.nexus.common.stateguard.Guarded Java Examples

@Override
@Guarded(by = STARTED)
public Blob create(final InputStream blobData, final Map<String, String> headers) {
  checkNotNull(blobData);

  return create(headers, destination -> {
      try (InputStream data = blobData) {
        MetricsInputStream input = new MetricsInputStream(data);
        TransferManager transferManager = new TransferManager(s3);
        transferManager.upload(getConfiguredBucket(), destination, input, new ObjectMetadata())
            .waitForCompletion();
        return input.getMetrics();
      } catch (InterruptedException e) {
        throw new BlobStoreException("error uploading blob", e, null);
      }
    });
}
 

@Override
@Guarded(by = ACTIVE)
public AssetBlob createBlob(final String blobName,
                            final Supplier<InputStream> streamSupplier,
                            final Iterable<HashAlgorithm> hashAlgorithms,
                            @Nullable final Map<String, String> headers,
                            @Nullable final String declaredContentType,
                            final boolean skipContentVerification) throws IOException
{
  checkNotNull(blobName);
  checkNotNull(streamSupplier);
  checkNotNull(hashAlgorithms);

  if (!writePolicy.checkCreateAllowed()) {
    throw new IllegalOperationException("Repository is read only: " + repositoryName);
  }

  Map<String, String> storageHeadersMap = buildStorageHeaders(blobName, streamSupplier, headers, declaredContentType,
      skipContentVerification);
  return blobTx.create(
      streamSupplier.get(),
      storageHeadersMap,
      hashAlgorithms,
      storageHeadersMap.get(BlobStore.CONTENT_TYPE_HEADER)
  );
}
 

@Override
@Guarded(by = STOPPED)
public void update(final Configuration configuration) throws Exception {
  checkNotNull(configuration);

  // Ensure configuration sanity
  validate(configuration);
  this.configuration = configuration;

  MultipleFailures failures = new MultipleFailures();
  for (Facet facet : facets) {
    try {
      log.debug("Updating facet: {}", facet);
      facet.update();
    }
    catch (Throwable t) {
      log.error("Failed to update facet: {}", facet, t);
      failures.add(t);
    }
  }
  failures.maybePropagate("Failed to update facets");
}
 

@Override
@Guarded(by = STARTED)
public void forceDelete(final String name) throws Exception {
  checkNotNull(name);
  freezeService.checkWritable("Unable to delete a BlobStore while database is frozen.");

  BlobStore blobStore = blobStore(name);
  log.debug("Deleting BlobStore: {}", name);
  blobStore.shutdown();
  blobStore.remove();
  untrack(name);
  if (!EventHelper.isReplicating()) {
    store.delete(blobStore.getBlobStoreConfiguration());
  }
  eventManager.post(new BlobStoreDeletedEvent(blobStore));
}
 

@Override
@Guarded(by = STARTED)
public void deleteByRepository(final String repositoryName) {
  log.debug("Deleting all browse nodes for repository {}", repositoryName);

  ProgressLogIntervalHelper progressLogger = new ProgressLogIntervalHelper(log, 60);

  int deletedCount;
  do {
    deletedCount = inTxRetry(databaseInstance).call(
        db -> entityAdapter.deleteByRepository(db, repositoryName, deletePageSize));

    progressLogger.info("Deleted {} browse nodes for repository {} in {}",
        deletedCount, repositoryName, progressLogger.getElapsed());
  }
  while (deletedCount == deletePageSize);

  progressLogger.flush();

  log.debug("All browse nodes deleted for repository {} in {}", repositoryName, progressLogger.getElapsed());
}
 

@Override
@Guarded(by = STARTED)
public <T> List<Entry<T, EntityId>> getNextPage(final OIndexCursor cursor, final int limit) {
  List<Entry<T, EntityId>> page = new ArrayList<>(limit);

  // For reasons unknown Orient needs the connection despite the code not using it
  try (ODatabaseDocumentTx db = databaseInstance.get().acquire()) {
    cursor.setPrefetchSize(limit);
    while (page.size() < limit) {
      Entry<Object, OIdentifiable> entry = cursor.nextEntry();
      if (entry == null) {
        break;
      }

      @SuppressWarnings("unchecked")
      T key = (T) entry.getKey();
      EntityId value = new AttachedEntityId(entityAdapter, entry.getValue().getIdentity());
      page.add(new SimpleEntry<>(key, value));
    }
  }

  return page;
}
 

@Override
@Guarded(by = STARTED)
public void enqueueDeletion(final Repository repository, final BlobStore blobStore, final Bucket bucket)
{
  checkNotNull(repository);
  checkNotNull(blobStore);
  checkNotNull(bucket);

  // The bucket associated with repository needs a new "repository name" created for it in order to avoid clashes.
  // Consider what happens if the bucket is still being deleted and someone tries to reuse that repository name.
  String generatedRepositoryName = repository.getName() + '$' + UUID.randomUUID();
  bucket.setRepositoryName(generatedRepositoryName);
  bucket.attributes().set(P_PENDING_DELETION, true);

  updateBucket(bucket);
}
 

@Override
@Guarded(by = STARTED)
public Optional<DataStore<?>> get(final String storeName) {
  checkNotNull(storeName);

  return ofNullable(dataStores.get(lower(storeName)));
}
 

@Override
@Guarded(by = STARTED)
public void invalidate(final NegativeCacheKey key) {
  checkNotNull(key);
  if (cache != null && cache.remove(key)) {
    log.debug("Removing {} from negative-cache of {}", key, getRepository());
  }
}
 

@Override
@Guarded(by = STARTED)
public synchronized boolean releaseUserInitiatedIfPresent() {
  Optional<FreezeRequest> request = getState().stream()
      .filter(it -> InitiatorType.USER_INITIATED.equals(it.getInitiatorType()))
      .findAny();
  if (request.isPresent()) {
    return releaseRequest(request.get());
  }
  return false;
}
 

@Override
@Guarded(by = NEW)
public void attach(final Facet facet) throws Exception {
  checkNotNull(facet);
  log.debug("Attaching facet: {}", facet);
  facet.attach(this);
  facets.add(facet);
}
 

@Guarded(by = STARTED)
public BlobStoreMetrics getMetrics() {
  try {
    return getCombinedMetrics(backingFiles());
  }
  catch (BlobStoreMetricsNotAvailableException e) {
    log.error("Blob store metrics cannot be accessed", e);
    return UnavailableBlobStoreMetrics.getInstance();
  }
}
 

@Override
@Guarded(by = ACTIVE)
public AssetBlob setBlob(final Asset asset,
                         final String blobName,
                         final Path sourceFile,
                         final Map<HashAlgorithm, HashCode> hashes,
                         @Nullable final Map<String, String> headers,
                         final String declaredContentType,
                         final long size) throws IOException
{
  checkNotNull(asset);
  checkArgument(!Strings2.isBlank(declaredContentType), "no declaredContentType provided");

  // Enforce write policy ahead, as we have asset here
  BlobRef oldBlobRef = asset.blobRef();
  if (oldBlobRef != null) {
    if (!writePolicySelector.select(asset, writePolicy).checkUpdateAllowed()) {
      throw new IllegalOperationException( "Repository does not allow updating assets: " + repositoryName);
    }
  }
  final AssetBlob assetBlob = createBlob(
      blobName,
      sourceFile,
      hashes,
      headers,
      declaredContentType,
      size
  );
  attachBlob(asset, assetBlob);
  return assetBlob;
}
 

@Override
@Guarded(by = STARTED)
public BlobStoreMetrics getMetrics() {
  Iterable<BlobStoreMetrics> membersMetrics = (Iterable<BlobStoreMetrics>) members.get().stream()
    .map((BlobStore member) -> member.getMetrics())
    ::iterator;
  return new BlobStoreGroupMetrics(membersMetrics);
}
 

@Override
@Guarded(by = STARTED)
public void purgeUnused(final int numberOfDays) {
  checkArgument(numberOfDays > 0, "Number of days must be greater then zero");
  log.info("Purging unused components from repository {}", getRepository().getName());
  ContentFacetSupport contentFacetSupport = (ContentFacetSupport) getRepository().facet(ContentFacet.class);

  deleteComponentsOlderThan(numberOfDays, contentFacetSupport);
  deleteAssetsOlderThan(numberOfDays, contentFacetSupport);
}
 

/**
 * Used by {@link QuartzTaskFuture#cancel(boolean)}.
 */
@Guarded(by = STARTED)
public boolean cancelJob(final JobKey jobKey) {
  checkNotNull(jobKey);

  try (TcclBlock tccl = TcclBlock.begin(this)) {
    return scheduler.interrupt(jobKey);
  }
  catch (UnableToInterruptJobException e) {
    log.debug("Unable to interrupt job with key: {}", jobKey, e);
  }
  return false;
}
 

@Override
@Guarded(by = STARTED)
public void invalidate() {
  if (cache != null) {
    log.debug("Removing all from negative-cache of {}", getRepository());
    cache.removeAll();
  }
}
 

@Override
@Guarded(by = STARTED)
@Nullable
public BlobStore get(final String name) {
  checkNotNull(name);

  return stores.get(name);
}
 

@Override
@Guarded(by = ACTIVE)
public boolean assetExists(final String name,
                           final Repository repository)
{
  checkNotNull(name);
  checkNotNull(repository);

  return assetEntityAdapter.exists(db, name, bucketOf(repository.getName()));
}
 

@Override
@Guarded(by = STARTED)
public void transformCselToSql(final ASTJexlScript script, final SelectorSqlBuilder builder) {
  final DatastoreSqlTransformer transformer = dataStoreId
      .map(transformerMap::get)
      .orElseThrow(() -> new IllegalStateException("Cannot find sql transformer for " + dataStoreId));

  script.childrenAccept(transformer, builder);
}
 

@Override
@Guarded(by = STARTED)
public PeriodicJob schedule(final Runnable runnable, final int repeatPeriodSeconds) {
  ScheduledFuture<?> scheduledFuture = executor.scheduleAtFixedRate(
      wrap(runnable),
      repeatPeriodSeconds,
      repeatPeriodSeconds,
      TimeUnit.SECONDS);

  return () -> scheduledFuture.cancel(false);
}
 

@Subscribe
@Guarded(by = STARTED)
@AllowConcurrentEvents
public void on(final AssetUpdatedEvent updated) {
  if (matchingEvent(updated) && hasBlobBeenUpdated(updated)) {
    invalidatePackageRoot(updated);
  }
}
 

@Subscribe
@Guarded(by = STARTED)
@AllowConcurrentEvents
public void on(final AssetDeletedEvent deleted) {
  if (matchingEvent(deleted)) {
    invalidatePackageRoot(deleted);
  }
}
 

@Override
@Guarded(by = STARTED)
public void persistApiKey(final String domain, final PrincipalCollection principals, final char[] apiKey) {
  checkNotNull(domain);
  checkNotNull(principals);
  checkNotNull(apiKey);
  final OrientApiKey entity = entityAdapter.newEntity();
  entity.setDomain(domain);
  entity.setApiKey(apiKey);
  entity.setPrincipals(principals);
  inTxRetry(databaseInstance).run(db -> entityAdapter.addEntity(db, entity));
}
 

@Guarded(by = STARTED)
public synchronized Map<String, String> load() {
  Map<String, String> modelVersions = new HashMap<>();
  load(modelVersions, upgradeManager.getLocalModels(), localModelVersions::getProperty);
  load(modelVersions, upgradeManager.getClusteredModels(), clusteredModelVersions::get);
  return modelVersions;
}
 

@Override
@Guarded(by = STARTED)
public void create(final Configuration configuration) {
  checkNotNull(configuration);

  inTxRetry(databaseInstance).run(db -> entityAdapter.addEntity(db, cast(configuration)));
}
 

@Override
@Guarded(by = STARTED)
public void delete(final BlobStoreConfiguration configuration) {
  checkBlobStoreConfiguration(configuration);

  inTxRetry(databaseInstance).run(db -> entityAdapter.deleteEntity(db, (OrientBlobStoreConfiguration) configuration));
}
 

@Override
@Guarded(by = STARTED)
public void update(final RoutingRule rule) {
  checkNotNull(rule);
  validate(rule);

  persist(entityAdapter::editEntity, rule);
}
 

@Override
@Guarded(by = STARTED)
public Blob copy(final BlobId blobId, final Map<String, String> headers) {
  GoogleCloudStorageBlob sourceBlob = (GoogleCloudStorageBlob) checkNotNull(get(blobId));

  return createInternal(headers, destination -> {
    sourceBlob.getBlob().copyTo(getConfiguredBucketName(), destination);
    BlobMetrics metrics = sourceBlob.getMetrics();
    return new StreamMetrics(metrics.getContentSize(), metrics.getSha1Hash());
  }, null);
}
 

@Override
@Guarded(by = STARTED)
public Asset save(Asset asset) {
  if (hasMetadata(asset)) {
    inTxRetry(databaseInstance).run(db -> entityAdapter.editEntity(db, asset));
    return asset;
  }
  else {
    return inTxRetry(databaseInstance).call(db -> entityAdapter.readEntity(entityAdapter.addEntity(db, asset)));
  }
}