Java Code Examples for org.sonatype.nexus.repository.storage.StorageTx#deleteAsset()

@Transactional(retryOn = ONeedRetryException.class)
@Override
protected Set<String> deleteAssetTx(final EntityId assetId, final boolean deleteBlobs) {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Asset asset = tx.findAsset(assetId, bucket);

  if (asset == null) {
    return Collections.emptySet();
  }

  tx.deleteAsset(asset, deleteBlobs);

  if (asset.componentId() != null) {
    Component component = tx.findComponentInBucket(asset.componentId(), bucket);

    if (!tx.browseAssets(component).iterator().hasNext()) {
      log.debug("Deleting component: {}", component);
      tx.deleteComponent(component, deleteBlobs);
    }
  }
  return Collections.singleton(asset.name());
}
 

@Transactional(retryOn = ONeedRetryException.class)
@Override
protected Set<String> deleteAssetTx(final EntityId assetId, final boolean deleteBlobs) {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Asset asset = tx.findAsset(assetId, bucket);

  if (asset == null) {
    return emptySet();
  }

  tx.deleteAsset(asset, deleteBlobs);

  if (asset.componentId() != null) {
    Component component = tx.findComponentInBucket(asset.componentId(), bucket);

    if (!tx.browseAssets(component).iterator().hasNext()) {
      log.debug("Deleting component: {}", component);
      tx.deleteComponent(component, deleteBlobs);
    }
  }
  return Collections.singleton(asset.name());
}
 

/**
 * Deletes the package root and all related tarballs too.
 */
static Set<String> deletePackageRoot(final StorageTx tx,
                                     final Repository repository,
                                     final NpmPackageId packageId,
                                     final boolean deleteBlobs)
{
  // find package asset -> delete
  Asset packageRootAsset = findPackageRootAsset(tx, tx.findBucket(repository), packageId);
  if (packageRootAsset == null) {
    return Collections.emptySet();
  }
  tx.deleteAsset(packageRootAsset, deleteBlobs);
  // find all tarball components -> delete
  Iterable<Component> npmTarballs = findPackageTarballComponents(tx, repository, packageId);
  Set<String> deletedAssetNames = new HashSet<>();
  for (Component npmTarball : npmTarballs) {
    deletedAssetNames.addAll(tx.deleteComponent(npmTarball, deleteBlobs));
  }
  return deletedAssetNames;
}
 

@TransactionalDeleteBlob
public void deleteIndex(final String packageName)
{
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());

  String indexPath = PyPiPathUtils.indexPath(normalizeName(packageName));
  Asset cachedIndex = findAsset(tx, bucket, indexPath);
  
  /*
    There is a chance that the index wasn't found because of package name normalization. For example '.' 
    characters are normalized to '-' so jts.python would have an index at /simple/jts-python/. It is possible that 
    we could just check for the normalized name but we check for both just in case. Searching for an index with a
    normalized name first means that most, if not all, index deletions will only perform a single search.
    
    See https://issues.sonatype.org/browse/NEXUS-19303 for additional context. 
   */
  if (cachedIndex == null) {
    indexPath = PyPiPathUtils.indexPath(packageName);
    cachedIndex = findAsset(tx, bucket, indexPath);
  }
  
  if (cachedIndex != null) {
    tx.deleteAsset(cachedIndex);
  }
}
 

@Override
@TransactionalDeleteBlob
public boolean delete(final String path) {
  checkNotNull(path);

  StorageTx tx = UnitOfWork.currentTx();
  Optional<Asset> asset = helmFacet.findAsset(tx, path);
  if (!asset.isPresent()) {
    return false;
  }
  else {
    tx.deleteAsset(asset.get());
    return true;
  }
}
 

@Override
@TransactionalDeleteBlob
public boolean delete(String path) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Asset asset = tx.findAssetWithProperty(P_NAME, path, bucket);
  if (asset == null) {
    return false;
  }

  tx.deleteAsset(asset);
  return true;
}
 

@TransactionalStoreBlob
public Asset ingestAsset(ControlFile control, TempBlob body, long size, String contentType) throws IOException, PGPException {
  AptFacet aptFacet = getRepository().facet(AptFacet.class);
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());

  String name = control.getField("Package").map(f -> f.value).get();
  String version = control.getField("Version").map(f -> f.value).get();
  String architecture = control.getField("Architecture").map(f -> f.value).get();

  String assetPath = FacetHelper.buildAssetPath(name, version, architecture);

  Content content = aptFacet.put(assetPath, new StreamPayload(() -> body.get(), size, contentType));
  Asset asset = Content.findAsset(tx, bucket, content);
  String indexSection = buildIndexSection(control, asset.size(), asset.getChecksums(FacetHelper.hashAlgorithms), assetPath);
  asset.formatAttributes().set(P_ARCHITECTURE, architecture);
  asset.formatAttributes().set(P_PACKAGE_NAME, name);
  asset.formatAttributes().set(P_PACKAGE_VERSION, version);
  asset.formatAttributes().set(P_INDEX_SECTION, indexSection);
  asset.formatAttributes().set(P_ASSET_KIND, "DEB");
  tx.saveAsset(asset);

  List<AssetChange> changes = new ArrayList<>();
  changes.add(new AssetChange(AssetAction.ADDED, asset));

  for (Asset removed : selectOldPackagesToRemove(name, architecture)) {
    tx.deleteAsset(removed);
    changes.add(new AssetChange(AssetAction.REMOVED, removed));
  }

  rebuildIndexesInTransaction(tx, changes.stream().toArray(AssetChange[]::new));
  return asset;
}
 

@Transactional
protected void cleanupPackageRootAssetOnlyFromCache(final Asset packageRootAsset) {
  checkNotNull(packageRootAsset);

  StorageTx tx = UnitOfWork.currentTx();

  // Don't delete the blob because we already know it is missing
  tx.deleteAsset(packageRootAsset, false);
}
 

@TransactionalDeleteBlob
protected void deleteAsset() throws IOException {
  log.debug("Invalidating cached npm index of {}", getRepository().getName());
  StorageTx tx = UnitOfWork.currentTx();
  Asset asset = NpmFacetUtils.findRepositoryRootAsset(tx, tx.findBucket(getRepository()));
  if (asset == null) {
    return;
  }
  tx.deleteAsset(asset);
  eventManager.post(new NpmSearchIndexInvalidatedEvent(getRepository()));
}
 

@Override
public void updateAsset(final Repository repository, final StorageTx tx, final Asset asset) {
  AssetKind assetKind = AssetKind.valueOf(asset.formatAttributes().get(P_ASSET_KIND, String.class));
  if (ROOT_INDEX.equals(assetKind) || INDEX.equals(assetKind)) {
    tx.deleteAsset(asset);
  }
}
 

@TransactionalDeleteBlob
public void deleteRootIndex() {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Asset rootIndex = findAsset(tx, bucket, INDEX_PATH_PREFIX);
  if (rootIndex != null) {
    tx.deleteAsset(rootIndex);
  }
}
 

private boolean deleteArtifact(final MavenPath path, final StorageTx tx) {
  final Component component = findComponent(tx, getRepository(), path);
  if (component == null) {
    return false;
  }
  final Asset asset = findAsset(tx, tx.findBucket(getRepository()), path);
  if (asset == null) {
    return false;
  }
  tx.deleteAsset(asset);
  if (!tx.browseAssets(component).iterator().hasNext()) {
    tx.deleteComponent(component);
  }
  return true;
}
 

private boolean deleteFile(final MavenPath path, final StorageTx tx) {
  final Asset asset = findAsset(tx, tx.findBucket(getRepository()), path);
  if (asset == null) {
    return false;
  }
  tx.deleteAsset(asset);
  return true;
}
 

@Override
@TransactionalDeleteBlob
public boolean delete(final String path) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Asset asset = tx.findAssetWithProperty(P_NAME, path, bucket);
  if (asset == null) {
    return false;
  }

  tx.deleteAsset(asset);
  return true;
}
 

@TransactionalDeleteBlob
protected void deleteAsset(final Repository repository, final String assetName) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  Asset asset = findAsset(repository, assetName);
  if (asset != null) {
    tx.deleteAsset(asset, false);
  }
}
 

/**
 * Delete all unused assets.
 */
@TransactionalDeleteBlob
protected void deleteUnusedAssets(final Date olderThan) {
  StorageTx tx = UnitOfWork.currentTx();

  for (Asset asset : findUnusedAssets(tx, olderThan)) {
    checkCancellation();
    log.debug("Deleting unused asset {}", asset);
    tx.deleteAsset(asset); // TODO: commit in batches
  }
}