diff --git a/docs/guides/gradle-plugin.md b/docs/guides/gradle-plugin.md index e822014d65..23e9052cf6 100644 --- a/docs/guides/gradle-plugin.md +++ b/docs/guides/gradle-plugin.md @@ -87,6 +87,31 @@ End-to-end tests should be tailored to the needs of your plugin, but generally t The Nextflow Gradle plugin allows you to publish plugins to the [Nextflow plugin registry](https://registry.nextflow.io/) from the command line. +(gradle-plugin-readme)= + +### README.md requirement + +When publishing to the registry, your project must include a `README.md` file in the plugin project root directory. This file will be used as the plugin description in the registry. + +**Required sections:** + +1. **Summary** - Explain what the plugin does +2. **Get Started** - Setup and configuration instructions +3. **Examples** - Code examples with code blocks +4. **License** - Specify the plugin's license (e.g., Apache 2.0, MIT, GPL) + +**Optional sections:** + +- **What's new** - Recent changes or new features +- **Breaking changes** - Incompatible changes users should be aware of + +**Requirements:** + +- Content must be meaningful (no placeholder text like TODO, TBD, Lorem ipsum) +- Content must be in English + +### Publishing steps + To publish plugins to the [Nextflow plugin registry](https://registry.nextflow.io/): 1. {ref}`Claim your plugin ` in the registry. diff --git a/docs/plugins/plugin-registry.md b/docs/plugins/plugin-registry.md index f17ded2287..b0f5b96d55 100644 --- a/docs/plugins/plugin-registry.md +++ b/docs/plugins/plugin-registry.md @@ -10,6 +10,8 @@ Nextflow 25.10 and later can use the plugin registry as a drop-in replacement fo The Nextflow plugin registry is currently available as a public preview. Plugin developers can access the registry by contacting [info@nextflow.io](mailto:info@nextflow.io) to obtain access to the registry. ::: +See {ref}`gradle-plugin-publish` for instructions on how to publish plugins to the registry, including the {ref}`README.md requirement `. + (plugin-registry-claim)= ## Claiming a plugin diff --git a/plugins/gradle.properties b/plugins/gradle.properties index c8a24981e8..9c3bc1ec23 100644 --- a/plugins/gradle.properties +++ b/plugins/gradle.properties @@ -1,3 +1,3 @@ ## plugins settings -nextflowPluginVersion=1.0.0-beta.10 +nextflowPluginVersion=1.0.0-beta.14 nextflowPluginProvider=nextflow-io diff --git a/plugins/nf-amazon/README.md b/plugins/nf-amazon/README.md new file mode 100644 index 0000000000..30ec717aaa --- /dev/null +++ b/plugins/nf-amazon/README.md @@ -0,0 +1,87 @@ +# Amazon Web Services plugin for Nextflow + +The Amazon Web Services (AWS) plugin provides support for AWS, including AWS Batch as a compute executor, S3 as a file system, and Fusion file system for high-performance data operations. + +## Get started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-amazon' +} +``` + +Configure your AWS credentials using environment variables, AWS CLI profiles, or IAM roles. Then set up the executor and work directory: + +```groovy +process.executor = 'awsbatch' +process.queue = '' +workDir = 's3:///work' + +aws { + region = 'us-east-1' + batch { + cliPath = '/home/ec2-user/miniconda/bin/aws' + } +} +``` + +## Examples + +### Basic AWS Batch configuration + +```groovy +plugins { + id 'nf-amazon' +} + +process.executor = 'awsbatch' +process.queue = 'my-batch-queue' +workDir = 's3://my-bucket/work' + +aws { + region = 'eu-west-1' + batch { + cliPath = '/home/ec2-user/miniconda/bin/aws' + jobRole = 'arn:aws:iam::123456789:role/MyBatchJobRole' + } +} +``` + +### Using Fusion file system + +```groovy +fusion { + enabled = true +} + +wave { + enabled = true +} + +process.executor = 'awsbatch' +workDir = 's3://my-bucket/work' +``` + +### S3 storage options + +```groovy +aws { + client { + maxConnections = 20 + connectionTimeout = 10000 + storageEncryption = 'AES256' + } + region = 'us-east-1' +} +``` + +## Resources + +- [AWS Batch Executor Documentation](https://nextflow.io/docs/latest/aws.html) +- [Amazon S3 Storage Documentation](https://nextflow.io/docs/latest/aws.html#s3-storage) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-amazon/build.gradle b/plugins/nf-amazon/build.gradle index c0818d753a..d64c87d7ba 100644 --- a/plugins/nf-amazon/build.gradle +++ b/plugins/nf-amazon/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Provides comprehensive AWS cloud integration including Batch executor, S3 file system, and Fusion support for high-performance data operations' className = 'nextflow.cloud.aws.AmazonPlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.cloud.aws.batch.AwsBatchExecutor', 'nextflow.cloud.aws.config.AwsConfig', diff --git a/plugins/nf-azure/README.md b/plugins/nf-azure/README.md index 512e33b1d6..e6f3bac318 100644 --- a/plugins/nf-azure/README.md +++ b/plugins/nf-azure/README.md @@ -1,70 +1,83 @@ -# Azure plugin for Nextflow +# Microsoft Azure plugin for Nextflow -This plugin implements the support for Azure Blob storage as file system -provider (via JSR203 interface) and Azure Batch executor for Nextflow. +The Microsoft Azure plugin provides support for Azure Blob Storage as a file system, and Azure Batch as a compute executor for Nextflow pipelines. -## Development +## Get Started -Build Nextflow as usual: +To use this plugin, add it to your `nextflow.config`: -```bash -make compile +```groovy +plugins { + id 'nf-azure' +} ``` -Use the following Nextflow configuration: +Configure your Azure credentials and services: + +```groovy +azure { + storage { + accountName = '' + accountKey = '' + } + + batch { + endpoint = 'https://..batch.azure.com' + accountName = '' + accountKey = '' + } +} +``` + +Set the executor and work directory: + +```groovy +process.executor = 'azurebatch' +workDir = 'az:///work' +``` + +## Examples + +### Basic Azure Batch Configuration ```groovy plugins { - id 'nf-azure' + id 'nf-azure' } azure { - storage { - accountKey = "" - accountName = "" - } - - batch { - endpoint = 'https://.westeurope.batch.azure.com' - accountName = '' - accountKey = '' - } + storage { + accountName = 'mystorageaccount' + accountKey = System.getenv('AZURE_STORAGE_KEY') + } + + batch { + endpoint = 'https://mybatchaccount.westeurope.batch.azure.com' + accountName = 'mybatchaccount' + accountKey = System.getenv('AZURE_BATCH_KEY') + autoPoolMode = true + deletePoolsOnCompletion = true + } } process.executor = 'azurebatch' -workDir = 'az:///work' +workDir = 'az://mycontainer/work' ``` -Then test the local build as usual: +### Using Managed Identity -```bash -./launch.sh run -c nextflow.config rnaseq-nf +```groovy +azure { + managedIdentity { + clientId = '' + } +} ``` -## Todo - -* Currently, the Blob storage service uses NettyHttpClient and Batch service - uses OkHttp client, duplicating the number of required libraries. In principle - the Blob service can use OkHttp, adding the following deps, however using that - Nextflow hangs during the shutdown, apparently because the connection pool used - by the blob service is not closed timely. - - ```groovy - compile('com.azure:azure-storage-blob:12.9.0') { - exclude group: 'org.slf4j', module: 'slf4j-api' - exclude group: 'com.azure', module: 'azure-core-http-netty' - } - compile('com.azure:azure-core-http-okhttp:1.3.3') { - exclude group: 'org.slf4j', module: 'slf4j-api' - } - ``` - -* Remove invalid directory from .command.run PATH for project having `bin/` folder -* Add the configuration for the region -* Make the backend endpoint optional - -### Additional Resources - -* https://github.com/Azure/azure-sdk-for-java/wiki -* https://github.com/Azure/azure-sdk-for-java/tree/master/sdk/storage/azure-storage-blob-nio -* https://github.com/Azure/azure-sdk-for-java/blob/master/sdk/storage/azure-storage-blob-nio/src/samples/java/com/azure/storage/blob/nio/ReadmeSamples.java +## Resources + +- [Azure Batch Executor Documentation](https://nextflow.io/docs/latest/azure.html) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-azure/build.gradle b/plugins/nf-azure/build.gradle index 9371972692..79d0b8d5d1 100644 --- a/plugins/nf-azure/build.gradle +++ b/plugins/nf-azure/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Enables Azure cloud execution through Batch service with native Blob storage access and comprehensive authentication options' className = 'nextflow.cloud.azure.AzurePlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.cloud.azure.batch.AzBatchExecutor', 'nextflow.cloud.azure.config.AzConfig', diff --git a/plugins/nf-cloudcache/README.md b/plugins/nf-cloudcache/README.md new file mode 100644 index 0000000000..b077227bd2 --- /dev/null +++ b/plugins/nf-cloudcache/README.md @@ -0,0 +1,84 @@ +# Cloud cache plugin for Nextflow + +The Cloud cache plugin provides cloud-based caching support for Nextflow pipelines. It enables workflow resume capability when using cloud storage as the work directory. + +## Get Started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-cloudcache' +} +``` + +The plugin is automatically activated when using cloud storage (S3, GS, Azure Blob) as the work directory with resume enabled. + +```groovy +workDir = 's3://my-bucket/work' +``` + +Run your pipeline with the `-resume` flag: + +```bash +nextflow run main.nf -resume +``` + +## Examples + +### AWS S3 Cache + +```groovy +plugins { + id 'nf-amazon' + id 'nf-cloudcache' +} + +workDir = 's3://my-bucket/work' + +aws { + region = 'us-east-1' +} +``` + +### Google Cloud Storage Cache + +```groovy +plugins { + id 'nf-google' + id 'nf-cloudcache' +} + +workDir = 'gs://my-bucket/work' + +google { + project = 'my-project' + location = 'us-central1' +} +``` + +### Azure Blob Storage Cache + +```groovy +plugins { + id 'nf-azure' + id 'nf-cloudcache' +} + +workDir = 'az://my-container/work' + +azure { + storage { + accountName = 'mystorageaccount' + accountKey = System.getenv('AZURE_STORAGE_KEY') + } +} +``` + +## Resources + +- [Nextflow Cache and Resume](https://nextflow.io/docs/latest/cache-and-resume.html) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-cloudcache/build.gradle b/plugins/nf-cloudcache/build.gradle index bfb23035ed..99376adae9 100644 --- a/plugins/nf-cloudcache/build.gradle +++ b/plugins/nf-cloudcache/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Implements cloud-based caching system to optimize workflow performance by reducing redundant computations and data transfers' className = 'nextflow.CloudCachePlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.cache.CloudCacheFactory' ] diff --git a/plugins/nf-codecommit/README.md b/plugins/nf-codecommit/README.md new file mode 100644 index 0000000000..b94b3e2dc9 --- /dev/null +++ b/plugins/nf-codecommit/README.md @@ -0,0 +1,71 @@ +# AWS CodeCommit plugin for Nextflow + +The AWS CodeCommit plugin provides integration with AWS CodeCommit. It enables Nextflow to pull pipeline scripts directly from CodeCommit repositories. + +## Get Started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-codecommit' +} +``` + +The plugin enables Nextflow to recognize CodeCommit repository URLs and authenticate using your AWS credentials. + +Run a pipeline directly from CodeCommit: + +```bash +nextflow run codecommit://my-repo/main.nf +``` + +## Examples + +### Running a Pipeline from CodeCommit + +```bash +nextflow run codecommit://my-pipeline-repo/main.nf +``` + +### Specifying a Branch or Tag + +```bash +nextflow run codecommit://my-pipeline-repo/main.nf -r develop +``` + +### Using a Specific AWS Region + +```bash +nextflow run codecommit://my-pipeline-repo/main.nf -hub codecommit -hub-opts region=eu-west-1 +``` + +### Configuration with AWS Region + +```groovy +plugins { + id 'nf-codecommit' +} + +aws { + region = 'us-east-1' +} +``` + +### Using AWS Profiles + +Set the AWS profile via environment variable: + +```bash +export AWS_PROFILE=my-profile +nextflow run codecommit://my-repo/main.nf +``` + +## Resources + +- [AWS CodeCommit Documentation](https://docs.aws.amazon.com/codecommit/) +- [Nextflow Pipeline Sharing](https://nextflow.io/docs/latest/sharing.html) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-codecommit/build.gradle b/plugins/nf-codecommit/build.gradle index fa3d1dd9ad..9f2ca1c4de 100644 --- a/plugins/nf-codecommit/build.gradle +++ b/plugins/nf-codecommit/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Provides seamless integration with AWS CodeCommit repositories for workflow source code management and version control' className = 'nextflow.cloud.aws.codecommit.AwsCodeCommitPlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.cloud.aws.codecommit.AwsCodeCommitFactory' ] diff --git a/plugins/nf-console/README.md b/plugins/nf-console/README.md new file mode 100644 index 0000000000..c6848fc643 --- /dev/null +++ b/plugins/nf-console/README.md @@ -0,0 +1,73 @@ +# Groovy console plugin for Nextflow + +The Groovy console plugin provides an interactive console and graphical user interface for Nextflow development, testing, and workflow exploration. + +## Get Started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-console' +} +``` + +Launch the console: + +```bash +nextflow console +``` + +This opens a Groovy console with the Nextflow runtime pre-loaded, allowing you to interactively develop and test workflow components. + +## Examples + +### Launching the Console + +```bash +nextflow console +``` + +### Loading a Script in the Console + +```bash +nextflow console my-script.nf +``` + +### Interactive Testing + +In the console, you can test Nextflow constructs: + +```groovy +// Test a channel operation +Channel.of(1, 2, 3) + .map { it * 2 } + .view() + +// Test file operations +file('data.txt').text = 'Hello World' + +// Test process inputs/outputs +def reads = Channel.fromPath('*.fastq') +reads.view() +``` + +### Exploring the Runtime + +```groovy +// Access workflow metadata +println workflow.projectDir +println workflow.launchDir + +// Check available executors +println executorFactory.getExecutorNames() +``` + +## Resources + +- [Nextflow Console Documentation](https://nextflow.io/docs/latest/cli.html#console) +- [Groovy Console Guide](https://groovy-lang.org/groovyconsole.html) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-console/build.gradle b/plugins/nf-console/build.gradle index e1d02ab193..37886f9cc8 100644 --- a/plugins/nf-console/build.gradle +++ b/plugins/nf-console/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Provides an interactive console and GUI interface for interactive Nextflow development, testing, and workflow exploration' className = 'nextflow.ui.console.ConsolePlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.ui.console.ConsoleRunner', ] diff --git a/plugins/nf-google/README.md b/plugins/nf-google/README.md new file mode 100644 index 0000000000..09d4ce71d0 --- /dev/null +++ b/plugins/nf-google/README.md @@ -0,0 +1,80 @@ +# Google Cloud plugin for Nextflow + +The Google Cloud plugin provides support for Google Cloud Platform (GCP), including Google Cloud Batch as a compute executor and Google Cloud Storage as a file system. + +## Get Started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-google' +} +``` + +Configure your Google Cloud credentials and project: + +```groovy +google { + project = '' + location = 'us-central1' +} + +process.executor = 'google-batch' +workDir = 'gs:///work' +``` + +Authentication can be done via: +- Application Default Credentials +- Service account JSON key file +- Workload Identity (for GKE) + +## Examples + +### Basic Google Cloud Batch Configuration + +```groovy +plugins { + id 'nf-google' +} + +google { + project = 'my-gcp-project' + location = 'europe-west1' + batch { + spot = true + } +} + +process.executor = 'google-batch' +workDir = 'gs://my-bucket/work' +``` + +### Using Service Account + +```groovy +google { + project = 'my-gcp-project' + location = 'us-central1' + credentials = '/path/to/service-account.json' +} +``` + +### Machine Type Configuration + +```groovy +process { + executor = 'google-batch' + machineType = 'n2-standard-4' + disk = '100 GB' +} +``` + +## Resources + +- [Google Cloud Batch Executor Documentation](https://nextflow.io/docs/latest/google.html) +- [Google Cloud Storage Documentation](https://nextflow.io/docs/latest/google.html#google-cloud-storage) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-google/build.gradle b/plugins/nf-google/build.gradle index 1873e8c515..63e633200a 100644 --- a/plugins/nf-google/build.gradle +++ b/plugins/nf-google/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Enables Google Cloud Platform execution through Batch service with native Cloud Storage access and intelligent machine type selection' className = 'nextflow.cloud.google.GoogleCloudPlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.cloud.google.GoogleOpts', 'nextflow.cloud.google.batch.GoogleBatchExecutor', diff --git a/plugins/nf-k8s/README.md b/plugins/nf-k8s/README.md new file mode 100644 index 0000000000..271a424086 --- /dev/null +++ b/plugins/nf-k8s/README.md @@ -0,0 +1,83 @@ +# Kubernetes plugin for Nextflow + +The Kubernetes plugin provides native Kubernetes execution capability for Nextflow pipelines. It supports pod management, volume mounting, and resource allocation. + +## Get Started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-k8s' +} +``` + +Configure the Kubernetes executor: + +```groovy +process.executor = 'k8s' + +k8s { + namespace = 'default' + serviceAccount = 'nextflow' + storageClaimName = 'nextflow-pvc' +} +``` + +The plugin automatically detects the Kubernetes configuration from: +- In-cluster configuration (when running inside a pod) +- `~/.kube/config` file +- `KUBECONFIG` environment variable + +## Examples + +### Basic Kubernetes Configuration + +```groovy +plugins { + id 'nf-k8s' +} + +process.executor = 'k8s' + +k8s { + namespace = 'nextflow' + serviceAccount = 'nextflow-sa' + storageClaimName = 'nf-workdir-pvc' + storageMountPath = '/workspace' +} + +workDir = '/workspace/work' +``` + +### Pod Configuration + +```groovy +k8s { + namespace = 'nextflow' + pod = [ + [volumeClaim: 'data-pvc', mountPath: '/data'], + [secret: 'aws-credentials', mountPath: '/root/.aws'] + ] +} +``` + +### Resource Requests + +```groovy +process { + executor = 'k8s' + cpus = 2 + memory = '4 GB' + + pod = [[label: 'app', value: 'nextflow']] +} +``` + +## Resources + +- [Kubernetes Executor Documentation](https://nextflow.io/docs/latest/kubernetes.html) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-k8s/build.gradle b/plugins/nf-k8s/build.gradle index f74f3f2373..b55b8b1a80 100644 --- a/plugins/nf-k8s/build.gradle +++ b/plugins/nf-k8s/build.gradle @@ -25,6 +25,7 @@ nextflowPlugin { description = 'Provides native Kubernetes execution capability with advanced pod management, volume mounting, and resource allocation features' className = 'nextflow.k8s.K8sPlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'nextflow.k8s.K8sConfig', 'nextflow.k8s.K8sExecutor', diff --git a/plugins/nf-tower/README.md b/plugins/nf-tower/README.md new file mode 100644 index 0000000000..b499a67898 --- /dev/null +++ b/plugins/nf-tower/README.md @@ -0,0 +1,91 @@ +# Seqera Platform plugin for Nextflow + +The Seqera Platform plugin provides integration with Seqera Platform (formerly Tower) for workflow monitoring, resource tracking, and centralized pipeline management. + +## Get Started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-tower' +} +``` + +Configure your Seqera Platform access token: + +```groovy +tower { + enabled = true + accessToken = '' +} +``` + +Alternatively, set the access token via environment variable: + +```bash +export TOWER_ACCESS_TOKEN='' +``` + +Then enable Tower in your config: + +```groovy +tower { + enabled = true +} +``` + +## Examples + +### Basic Configuration + +```groovy +plugins { + id 'nf-tower' +} + +tower { + enabled = true + accessToken = System.getenv('TOWER_ACCESS_TOKEN') +} +``` + +### Using a Specific Workspace + +```groovy +tower { + enabled = true + accessToken = System.getenv('TOWER_ACCESS_TOKEN') + workspaceId = '1234567890' +} +``` + +### Custom Seqera Platform Endpoint + +```groovy +tower { + enabled = true + accessToken = System.getenv('TOWER_ACCESS_TOKEN') + endpoint = 'https://tower.mycompany.com/api' +} +``` + +### Reports and cache management + +```groovy +tower { + enabled = true + reports { + enabled = true + } +} +``` + +## Resources + +- [Seqera Platform Documentation](https://docs.seqera.io/) +- [Nextflow Tower Configuration](https://nextflow.io/docs/latest/tracing.html#seqera-platform) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-tower/build.gradle b/plugins/nf-tower/build.gradle index 7d1b91039c..9fc9a1007e 100644 --- a/plugins/nf-tower/build.gradle +++ b/plugins/nf-tower/build.gradle @@ -21,6 +21,7 @@ nextflowPlugin { description = 'Integrates with Seqera Platform for comprehensive workflow monitoring, resource tracking, and cache management capabilities' className = 'io.seqera.tower.plugin.TowerPlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'io.seqera.tower.plugin.TowerConfig', 'io.seqera.tower.plugin.TowerFactory', diff --git a/plugins/nf-wave/README.md b/plugins/nf-wave/README.md new file mode 100644 index 0000000000..c123bf63a9 --- /dev/null +++ b/plugins/nf-wave/README.md @@ -0,0 +1,113 @@ +# Wave containers plugin for Nextflow + +The Wave containers plugin provides integration with the Wave container service for dynamic container building, augmentation, and on-demand software provisioning. + +## Get started + +To use this plugin, add it to your `nextflow.config`: + +```groovy +plugins { + id 'nf-wave' +} +``` + +Enable Wave in your configuration: + +```groovy +wave { + enabled = true +} +``` + +Wave automatically builds containers from Conda packages or Dockerfiles defined in your processes. + +## Examples + +### Basic Wave configuration + +```groovy +plugins { + id 'nf-wave' +} + +wave { + enabled = true +} + +process { + conda = 'samtools=1.17' +} +``` + +### Using Wave with Conda packages + +```groovy +wave { + enabled = true +} + +process ALIGN { + conda 'bioconda::bwa=0.7.17 bioconda::samtools=1.17' + + script: + ''' + bwa mem ref.fa reads.fq | samtools view -bS - > aligned.bam + ''' +} +``` + +### Wave with Fusion file system + +```groovy +wave { + enabled = true +} + +fusion { + enabled = true +} + +process.executor = 'awsbatch' +workDir = 's3://my-bucket/work' +``` + +### Container augmentation + +```groovy +wave { + enabled = true + strategy = 'conda,container' +} + +process TOOL { + container 'ubuntu:22.04' + conda 'bioconda::samtools=1.17' + + script: + ''' + samtools --version + ''' +} +``` + +### Using private registries + +```groovy +wave { + enabled = true +} + +docker { + registry = 'quay.io' +} +``` + +## Resources + +- [Wave Documentation](https://docs.seqera.io/wave) +- [Wave Integration Guide](https://nextflow.io/docs/latest/wave.html) + +## License + +[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/plugins/nf-wave/build.gradle b/plugins/nf-wave/build.gradle index 541c38f4e6..8b6aa12322 100644 --- a/plugins/nf-wave/build.gradle +++ b/plugins/nf-wave/build.gradle @@ -21,6 +21,7 @@ nextflowPlugin { description = 'Provides dynamic container building and augmentation capabilities with on-demand software installation and advanced container management features' className = 'io.seqera.wave.plugin.WavePlugin' useDefaultDependencies = false + generateSpec = false extensionPoints = [ 'io.seqera.wave.plugin.WaveFactory', 'io.seqera.wave.plugin.config.WaveConfig',