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

@Transactional(retryOn = { ONeedRetryException.class })
@Override
public Content getSnapshotFile(String id, String path) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Component component = tx.findComponentWithProperty(P_NAME, id, bucket);
  if (component == null) {
    return null;
  }

  final Asset asset = tx.findAssetWithProperty(P_NAME, createAssetPath(id, path), component);
  if (asset == null) {
    return null;
  }

  final Blob blob = tx.requireBlob(asset.requireBlobRef());
  return FacetHelper.toContent(asset, blob);
}
 

@Override
@TransactionalStoreBlob
public Content put(String path, Payload content) throws IOException {
  StorageFacet storageFacet = facet(StorageFacet.class);
  try (final TempBlob tembBlob = storageFacet.createTempBlob(content, FacetHelper.hashAlgorithms)) {
    StorageTx tx = UnitOfWork.currentTx();
    Bucket bucket = tx.findBucket(getRepository());
    Asset asset = tx.findAssetWithProperty(P_NAME, path, bucket);
    if (asset == null) {
      asset = tx.createAsset(bucket, getRepository().getFormat()).name(path);
    }

    AttributesMap contentAttributes = null;
    if (content instanceof Content) {
      contentAttributes = ((Content) content).getAttributes();
    }
    Content.applyToAsset(asset, Content.maintainLastModified(asset, contentAttributes));
    AssetBlob blob = tx.setBlob(
        asset,
        path,
        tembBlob,
        FacetHelper.hashAlgorithms,
        null,
        content.getContentType(),
        false);
    tx.saveAsset(asset);
    return FacetHelper.toContent(asset, blob.getBlob());
  }
}
 

@Transactional(retryOn = {ONeedRetryException.class})
protected void doIndicateVerified(final Content content, final CacheInfo cacheInfo, final String assetPath) {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());

  Asset asset = Content.findAsset(tx, bucket, content);
  if (asset == null) {
    asset = tx.findAssetWithProperty(P_NAME, assetPath, bucket);
  }
  if (asset == null) {
    return;
  }
  CacheInfo.applyToAsset(asset, cacheInfo);
  tx.saveAsset(asset);
}
 

/**
 * Find a tarball asset by package name and tarball filename in repository.
 */
@Nullable
static Asset findTarballAsset(final StorageTx tx,
                              final Bucket bucket,
                              final NpmPackageId packageId,
                              final String tarballName)
{
  return tx.findAssetWithProperty(P_NAME, tarballAssetName(packageId, tarballName), bucket);
}
 

/**
 * Find a package root asset by package name in repository.
 */
@Nullable
public static Asset findPackageRootAsset(final StorageTx tx,
                                         final Bucket bucket,
                                         final NpmPackageId packageId)
{
  return tx.findAssetWithProperty(P_NAME, packageId.id(), bucket);
}
 

@Override
@TransactionalStoreBlob
public Content getOrCreateAsset(final String path, final Content content, boolean toAttachComponent)
    throws IOException
{
  StorageFacet storageFacet = facet(StorageFacet.class);
  try (final TempBlob tempBlob = storageFacet.createTempBlob(content, HASH_ALGORITHMS)) {
    StorageTx tx = UnitOfWork.currentTx();
    Bucket bucket = tx.findBucket(getRepository());

    Asset asset = tx.findAssetWithProperty(P_NAME, path, bucket);
    if (asset == null) {
      if (toAttachComponent) {
        Component component = findOrCreateComponent(tx, bucket, path);
        asset = tx.createAsset(bucket, component).name(path);
      }
      else {
        asset = tx.createAsset(bucket, getRepository().getFormat()).name(path);
      }
    }
    Content.applyToAsset(asset, content.getAttributes());
    AssetBlob blob = tx.setBlob(asset, path, tempBlob, HASH_ALGORITHMS, null, null, false);
    tx.saveAsset(asset);

    final Content updatedContent = new Content(new BlobPayload(blob.getBlob(), asset.requireContentType()));
    Content.extractFromAsset(asset, HASH_ALGORITHMS, updatedContent.getAttributes());
    return updatedContent;
  }
}
 

@Override
public Asset findOrCreateDebAsset(final StorageTx tx, final String path, final PackageInfo packageInfo)
{
  Bucket bucket = tx.findBucket(getRepository());
  Asset asset = tx.findAssetWithProperty(P_NAME, path, bucket);
  if (asset == null) {
    Component component = findOrCreateComponent(
        tx,
        bucket,
        packageInfo);
    asset = tx.createAsset(bucket, component).name(path);
  }

  return asset;
}
 

@Override
@Nullable
@TransactionalTouchBlob
public Content get(String path) throws IOException {
  final StorageTx tx = UnitOfWork.currentTx();
  final Asset asset = tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository()));
  if (asset == null) {
    return null;
  }

  return FacetHelper.toContent(asset, tx.requireBlob(asset.requireBlobRef()));
}
 

@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;
}
 

@Override
@Nullable
@TransactionalTouchBlob
public Content get(final String path) {
  final StorageTx tx = UnitOfWork.currentTx();
  final Asset asset = tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository()));
  if (asset == null) {
    return null;
  }
  Content content = new Content(new BlobPayload(tx.requireBlob(asset.requireBlobRef()), asset.requireContentType()));
  Content.extractFromAsset(asset, HASH_ALGORITHMS, content.getAttributes());
  return content;
}
 

/**
 * Find an asset by its name.
 *
 * @return found Optional<Asset> or Optional.empty if not found
 */
@Override
public Optional<Asset> findAsset(final StorageTx tx, final String assetName) {
  Bucket bucket = tx.findBucket(getRepository());
  Asset asset = tx.findAssetWithProperty(P_NAME, assetName, bucket);
  return Optional.ofNullable(asset);
}
 

@Override
@Nullable
@TransactionalTouchBlob
public Content get(final String path) throws IOException {
  final StorageTx tx = UnitOfWork.currentTx();
  final Asset asset = tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository()));
  if (asset == null) {
    return null;
  }

  return FacetHelper.toContent(asset, tx.requireBlob(asset.requireBlobRef()));
}
 

@GET
@Path("content")
public Response content(
        @QueryParam("r") String repositoryName,
        @QueryParam("g") String groupId,
        @QueryParam("a") String artifactId,
        @QueryParam("v") String version,
        @QueryParam("c") String classifier,
        @QueryParam("p") @DefaultValue("jar") String extension
) {


    // default version
    if ("LATEST".equals(version)) {
        version = null;
    }
    version = Optional.ofNullable(version).orElse(latestVersion(
            repositoryName, groupId, artifactId, classifier, extension
    ));

    // valid params
    if (isBlank(repositoryName) || isBlank(groupId) || isBlank(artifactId) || isBlank(version)) {
        return NOT_FOUND;
    }

    Repository repository = repositoryManager.get(repositoryName);
    if (null == repository || !repository.getFormat().getValue().equals("maven2")) {
        return NOT_FOUND;
    }

    StorageFacet facet = repository.facet(StorageFacet.class);
    Supplier<StorageTx> storageTxSupplier = facet.txSupplier();

    log.debug("rundeck download repository: {}", repository);
    final StorageTx tx = storageTxSupplier.get();
    tx.begin();
    Bucket bucket = tx.findBucket(repository);
    log.debug("rundeck download bucket: {}", bucket);

    if (null == bucket) {
        return commitAndReturn(NOT_FOUND, tx);
    }

    String fileName = artifactId + "-" + version + (isBlank(classifier) ? "" : ("-" + classifier)) + "." + extension;
    String path = groupId.replace(".", "/") +
            "/" + artifactId +
            "/" + version +
            "/" + fileName;
    Asset asset = tx.findAssetWithProperty("name", path, bucket);
    log.debug("rundeck download asset: {}", asset);
    if (null == asset) {
        return commitAndReturn(NOT_FOUND, tx);
    }
    asset.markAsDownloaded();
    tx.saveAsset(asset);
    Blob blob = tx.requireBlob(asset.requireBlobRef());
    Response.ResponseBuilder ok = Response.ok(blob.getInputStream());
    ok.header("Content-Type", blob.getHeaders().get("BlobStore.content-type"));
    ok.header("Content-Disposition", "attachment;filename=\"" + fileName + "\"");
    return commitAndReturn(ok.build(), tx);
}
 

@Nullable
private Asset findAsset(final StorageTx tx, final String path) {
  return tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository()));
}
 

@Override
@TransactionalTouchBlob
public boolean assetExists(final String path) {
  final StorageTx tx = UnitOfWork.currentTx();
  return tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository())) != null;
}
 

@Override
@Nullable
public Asset findAsset(final StorageTx tx, final Bucket bucket, final String assetName)
{
  return tx.findAssetWithProperty(MetadataNodeEntityAdapter.P_NAME, assetName, bucket);
}
 

private Asset findAsset(StorageTx tx, String path) {
  return tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository()));
}
 

@Override
@TransactionalTouchBlob
public boolean assetExists(final String path) {
  final StorageTx tx = UnitOfWork.currentTx();
  return tx.findAssetWithProperty(P_NAME, path, tx.findBucket(getRepository())) != null;
}
 

/**
 * Find an asset by its name.
 *
 * @return found asset or null if not found
 */
@Nullable
@Override
public Asset findAsset(final StorageTx tx, final Bucket bucket, final String assetName) {
  return tx.findAssetWithProperty(MetadataNodeEntityAdapter.P_NAME, assetName, bucket);
}
 

/**
 * Find an asset by its name.
 *
 * @return found asset or null if not found
 */
@Nullable
static Asset findAsset(final StorageTx tx, final Bucket bucket, final String assetName) {
  return tx.findAssetWithProperty(MetadataNodeEntityAdapter.P_NAME, assetName, bucket);
}