From 7cf9dfd323f7095cba4d9780321b6b737c789ef8 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 7 Jun 2024 15:39:36 +0530 Subject: [PATCH 01/92] Initial commit --- .gitignore | 2 ++ lib/.github/workflows/ci.yml | 21 +++++++++++++++++++++ lib/Cargo.toml | 10 ++++++++++ lib/src/lib.rs | 14 ++++++++++++++ 4 files changed, 47 insertions(+) create mode 100644 .gitignore create mode 100644 lib/.github/workflows/ci.yml create mode 100644 lib/Cargo.toml create mode 100644 lib/src/lib.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1e7caa9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +Cargo.lock +target/ diff --git a/lib/.github/workflows/ci.yml b/lib/.github/workflows/ci.yml new file mode 100644 index 0000000..4f0c603 --- /dev/null +++ b/lib/.github/workflows/ci.yml @@ -0,0 +1,21 @@ +name: CI + +on: [push, pull_request] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Install Rust + run: rustup update stable + - name: Build + run: cargo build --verbose + - name: Run tests + run: cargo test --verbose + - name: Lint + run: cargo clippy -- -D warnings + - name: Format + run: cargo fmt -- --check diff --git a/lib/Cargo.toml b/lib/Cargo.toml new file mode 100644 index 0000000..1120dee --- /dev/null +++ b/lib/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "lib" +version = "0.1.0" +authors = ["Aarav Mehta"] +edition = "2021" +description = "A library to interact with the different API's of GA4GH" +license = "Apache-2.0" +repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk.git" + +[dependencies] diff --git a/lib/src/lib.rs b/lib/src/lib.rs new file mode 100644 index 0000000..6ac2420 --- /dev/null +++ b/lib/src/lib.rs @@ -0,0 +1,14 @@ +//! This is the main library file for the `lib` crate. +#![warn(missing_docs)] + + +// UNIT TESTING +#[cfg(test)] +mod tests { + // use super::*; + + #[test] + fn test() { + // This test currently does nothing, it is just a placeholder. + } +} \ No newline at end of file From 008788196b4dbfacab28ac82f6e611857575d1dd Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 7 Jun 2024 16:22:39 +0530 Subject: [PATCH 02/92] added tes-autogenerated code for all the models --- {lib/.github => .github}/workflows/ci.yml | 0 lib/src/TES/models/mod.rs | 34 +++++++++ lib/src/TES/models/service.rs | 67 +++++++++++++++++ lib/src/TES/models/service_organization.rs | 33 +++++++++ lib/src/TES/models/service_type.rs | 37 ++++++++++ .../TES/models/tes_create_task_response.rs | 29 ++++++++ lib/src/TES/models/tes_executor.rs | 57 +++++++++++++++ lib/src/TES/models/tes_executor_log.rs | 45 ++++++++++++ lib/src/TES/models/tes_file_type.rs | 38 ++++++++++ lib/src/TES/models/tes_input.rs | 50 +++++++++++++ lib/src/TES/models/tes_list_tasks_response.rs | 33 +++++++++ lib/src/TES/models/tes_output.rs | 48 ++++++++++++ lib/src/TES/models/tes_output_file_log.rs | 37 ++++++++++ lib/src/TES/models/tes_resources.rs | 53 ++++++++++++++ lib/src/TES/models/tes_service_info.rs | 73 +++++++++++++++++++ lib/src/TES/models/tes_service_type.rs | 46 ++++++++++++ lib/src/TES/models/tes_state.rs | 65 +++++++++++++++++ lib/src/TES/models/tes_task.rs | 71 ++++++++++++++++++ lib/src/TES/models/tes_task_log.rs | 49 +++++++++++++ lib/src/service.rs | 0 20 files changed, 865 insertions(+) rename {lib/.github => .github}/workflows/ci.yml (100%) create mode 100644 lib/src/TES/models/mod.rs create mode 100644 lib/src/TES/models/service.rs create mode 100644 lib/src/TES/models/service_organization.rs create mode 100644 lib/src/TES/models/service_type.rs create mode 100644 lib/src/TES/models/tes_create_task_response.rs create mode 100644 lib/src/TES/models/tes_executor.rs create mode 100644 lib/src/TES/models/tes_executor_log.rs create mode 100644 lib/src/TES/models/tes_file_type.rs create mode 100644 lib/src/TES/models/tes_input.rs create mode 100644 lib/src/TES/models/tes_list_tasks_response.rs create mode 100644 lib/src/TES/models/tes_output.rs create mode 100644 lib/src/TES/models/tes_output_file_log.rs create mode 100644 lib/src/TES/models/tes_resources.rs create mode 100644 lib/src/TES/models/tes_service_info.rs create mode 100644 lib/src/TES/models/tes_service_type.rs create mode 100644 lib/src/TES/models/tes_state.rs create mode 100644 lib/src/TES/models/tes_task.rs create mode 100644 lib/src/TES/models/tes_task_log.rs create mode 100644 lib/src/service.rs diff --git a/lib/.github/workflows/ci.yml b/.github/workflows/ci.yml similarity index 100% rename from lib/.github/workflows/ci.yml rename to .github/workflows/ci.yml diff --git a/lib/src/TES/models/mod.rs b/lib/src/TES/models/mod.rs new file mode 100644 index 0000000..232b43a --- /dev/null +++ b/lib/src/TES/models/mod.rs @@ -0,0 +1,34 @@ +pub mod service; +pub use self::service::Service; +pub mod service_organization; +pub use self::service_organization::ServiceOrganization; +pub mod service_type; +pub use self::service_type::ServiceType; +pub mod tes_create_task_response; +pub use self::tes_create_task_response::TesCreateTaskResponse; +pub mod tes_executor; +pub use self::tes_executor::TesExecutor; +pub mod tes_executor_log; +pub use self::tes_executor_log::TesExecutorLog; +pub mod tes_file_type; +pub use self::tes_file_type::TesFileType; +pub mod tes_input; +pub use self::tes_input::TesInput; +pub mod tes_list_tasks_response; +pub use self::tes_list_tasks_response::TesListTasksResponse; +pub mod tes_output; +pub use self::tes_output::TesOutput; +pub mod tes_output_file_log; +pub use self::tes_output_file_log::TesOutputFileLog; +pub mod tes_resources; +pub use self::tes_resources::TesResources; +pub mod tes_service_info; +pub use self::tes_service_info::TesServiceInfo; +pub mod tes_service_type; +pub use self::tes_service_type::TesServiceType; +pub mod tes_state; +pub use self::tes_state::TesState; +pub mod tes_task; +pub use self::tes_task::TesTask; +pub mod tes_task_log; +pub use self::tes_task_log::TesTaskLog; diff --git a/lib/src/TES/models/service.rs b/lib/src/TES/models/service.rs new file mode 100644 index 0000000..1943618 --- /dev/null +++ b/lib/src/TES/models/service.rs @@ -0,0 +1,67 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// Service : GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Service { + /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. + #[serde(rename = "id")] + pub id: String, + /// Name of this service. Should be human readable. + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "type")] + pub r#type: Box, + /// Description of the service. Should be human readable and provide information about the service. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "organization")] + pub organization: Box, + /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). + #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] + pub contact_url: Option, + /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. + #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] + pub documentation_url: Option, + /// Timestamp describing when the service was first deployed and available (RFC 3339 format) + #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] + pub created_at: Option, + /// Timestamp describing when the service was last updated (RFC 3339 format) + #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] + pub updated_at: Option, + /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option, + /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. + #[serde(rename = "version")] + pub version: String, +} + +impl Service { + /// GA4GH service + pub fn new(id: String, name: String, r#type: models::ServiceType, organization: models::ServiceOrganization, version: String) -> Service { + Service { + id, + name, + r#type: Box::new(r#type), + description: None, + organization: Box::new(organization), + contact_url: None, + documentation_url: None, + created_at: None, + updated_at: None, + environment: None, + version, + } + } +} + diff --git a/lib/src/TES/models/service_organization.rs b/lib/src/TES/models/service_organization.rs new file mode 100644 index 0000000..ea658ca --- /dev/null +++ b/lib/src/TES/models/service_organization.rs @@ -0,0 +1,33 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// ServiceOrganization : Organization providing the service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceOrganization { + /// Name of the organization responsible for the service + #[serde(rename = "name")] + pub name: String, + /// URL of the website of the organization (RFC 3986 format) + #[serde(rename = "url")] + pub url: String, +} + +impl ServiceOrganization { + /// Organization providing the service + pub fn new(name: String, url: String) -> ServiceOrganization { + ServiceOrganization { + name, + url, + } + } +} + diff --git a/lib/src/TES/models/service_type.rs b/lib/src/TES/models/service_type.rs new file mode 100644 index 0000000..c325103 --- /dev/null +++ b/lib/src/TES/models/service_type.rs @@ -0,0 +1,37 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// ServiceType : Type of a GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceType { + /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). + #[serde(rename = "group")] + pub group: String, + /// Name of the API or GA4GH specification implemented. Official GA4GH types should be assigned as part of standards approval process. Custom artifacts are supported. + #[serde(rename = "artifact")] + pub artifact: String, + /// Version of the API or specification. GA4GH specifications use semantic versioning. + #[serde(rename = "version")] + pub version: String, +} + +impl ServiceType { + /// Type of a GA4GH service + pub fn new(group: String, artifact: String, version: String) -> ServiceType { + ServiceType { + group, + artifact, + version, + } + } +} + diff --git a/lib/src/TES/models/tes_create_task_response.rs b/lib/src/TES/models/tes_create_task_response.rs new file mode 100644 index 0000000..618d8ef --- /dev/null +++ b/lib/src/TES/models/tes_create_task_response.rs @@ -0,0 +1,29 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesCreateTaskResponse : CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesCreateTaskResponse { + /// Task identifier assigned by the server. + #[serde(rename = "id")] + pub id: String, +} + +impl TesCreateTaskResponse { + /// CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. + pub fn new(id: String) -> TesCreateTaskResponse { + TesCreateTaskResponse { + id, + } + } +} + diff --git a/lib/src/TES/models/tes_executor.rs b/lib/src/TES/models/tes_executor.rs new file mode 100644 index 0000000..f440d88 --- /dev/null +++ b/lib/src/TES/models/tes_executor.rs @@ -0,0 +1,57 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesExecutor : Executor describes a command to be executed, and its environment. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesExecutor { + /// Name of the container image. The string will be passed as the image argument to the containerization run command. Examples: - `ubuntu` - `quay.io/aptible/ubuntu` - `gcr.io/my-org/my-image` - `myregistryhost:5000/fedora/httpd:version1.0` + #[serde(rename = "image")] + pub image: String, + /// A sequence of program arguments to execute, where the first argument is the program to execute (i.e. argv). Example: ``` { \"command\" : [\"/bin/md5\", \"/data/file1\"] } ``` + #[serde(rename = "command")] + pub command: Vec, + /// The working directory that the command will be executed in. If not defined, the system will default to the directory set by the container image. + #[serde(rename = "workdir", skip_serializing_if = "Option::is_none")] + pub workdir: Option, + /// Path inside the container to a file which will be piped to the executor's stdin. This must be an absolute path. This mechanism could be used in conjunction with the input declaration to process a data file using a tool that expects STDIN. For example, to get the MD5 sum of a file by reading it into the STDIN ``` { \"command\" : [\"/bin/md5\"], \"stdin\" : \"/data/file1\" } ``` + #[serde(rename = "stdin", skip_serializing_if = "Option::is_none")] + pub stdin: Option, + /// Path inside the container to a file where the executor's stdout will be written to. Must be an absolute path. Example: ``` { \"stdout\" : \"/tmp/stdout.log\" } ``` + #[serde(rename = "stdout", skip_serializing_if = "Option::is_none")] + pub stdout: Option, + /// Path inside the container to a file where the executor's stderr will be written to. Must be an absolute path. Example: ``` { \"stderr\" : \"/tmp/stderr.log\" } ``` + #[serde(rename = "stderr", skip_serializing_if = "Option::is_none")] + pub stderr: Option, + /// Enviromental variables to set within the container. Example: ``` { \"env\" : { \"ENV_CONFIG_PATH\" : \"/data/config.file\", \"BLASTDB\" : \"/data/GRC38\", \"HMMERDB\" : \"/data/hmmer\" } } ``` + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + /// Default behavior of running an array of executors is that execution stops on the first error. If `ignore_error` is `True`, then the runner will record error exit codes, but will continue on to the next tesExecutor. + #[serde(rename = "ignore_error", skip_serializing_if = "Option::is_none")] + pub ignore_error: Option, +} + +impl TesExecutor { + /// Executor describes a command to be executed, and its environment. + pub fn new(image: String, command: Vec) -> TesExecutor { + TesExecutor { + image, + command, + workdir: None, + stdin: None, + stdout: None, + stderr: None, + env: None, + ignore_error: None, + } + } +} + diff --git a/lib/src/TES/models/tes_executor_log.rs b/lib/src/TES/models/tes_executor_log.rs new file mode 100644 index 0000000..7af295b --- /dev/null +++ b/lib/src/TES/models/tes_executor_log.rs @@ -0,0 +1,45 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesExecutorLog : ExecutorLog describes logging information related to an Executor. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesExecutorLog { + /// Time the executor started, in RFC 3339 format. + #[serde(rename = "start_time", skip_serializing_if = "Option::is_none")] + pub start_time: Option, + /// Time the executor ended, in RFC 3339 format. + #[serde(rename = "end_time", skip_serializing_if = "Option::is_none")] + pub end_time: Option, + /// Stdout content. This is meant for convenience. No guarantees are made about the content. Implementations may chose different approaches: only the head, only the tail, a URL reference only, etc. In order to capture the full stdout client should set Executor.stdout to a container file path, and use Task.outputs to upload that file to permanent storage. + #[serde(rename = "stdout", skip_serializing_if = "Option::is_none")] + pub stdout: Option, + /// Stderr content. This is meant for convenience. No guarantees are made about the content. Implementations may chose different approaches: only the head, only the tail, a URL reference only, etc. In order to capture the full stderr client should set Executor.stderr to a container file path, and use Task.outputs to upload that file to permanent storage. + #[serde(rename = "stderr", skip_serializing_if = "Option::is_none")] + pub stderr: Option, + /// Exit code. + #[serde(rename = "exit_code")] + pub exit_code: i32, +} + +impl TesExecutorLog { + /// ExecutorLog describes logging information related to an Executor. + pub fn new(exit_code: i32) -> TesExecutorLog { + TesExecutorLog { + start_time: None, + end_time: None, + stdout: None, + stderr: None, + exit_code, + } + } +} + diff --git a/lib/src/TES/models/tes_file_type.rs b/lib/src/TES/models/tes_file_type.rs new file mode 100644 index 0000000..c517a37 --- /dev/null +++ b/lib/src/TES/models/tes_file_type.rs @@ -0,0 +1,38 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesFileType : Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. +/// Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum TesFileType { + #[serde(rename = "FILE")] + File, + #[serde(rename = "DIRECTORY")] + Directory, + +} + +impl ToString for TesFileType { + fn to_string(&self) -> String { + match self { + Self::File => String::from("FILE"), + Self::Directory => String::from("DIRECTORY"), + } + } +} + +impl Default for TesFileType { + fn default() -> TesFileType { + Self::File + } +} + diff --git a/lib/src/TES/models/tes_input.rs b/lib/src/TES/models/tes_input.rs new file mode 100644 index 0000000..1a86574 --- /dev/null +++ b/lib/src/TES/models/tes_input.rs @@ -0,0 +1,50 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesInput : Input describes Task input files. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesInput { + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + /// REQUIRED, unless \"content\" is set. URL in long term storage, for example: - s3://my-object-store/file1 - gs://my-bucket/file2 - file:///path/to/my/file - /path/to/my/file + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, + /// Path of the file inside the container. Must be an absolute path. + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "type", skip_serializing_if = "Option::is_none")] + pub r#type: Option, + /// File content literal. Implementations should support a minimum of 128 KiB in this field and may define their own maximum. UTF-8 encoded If content is not empty, \"url\" must be ignored. + #[serde(rename = "content", skip_serializing_if = "Option::is_none")] + pub content: Option, + /// Indicate that a file resource could be accessed using a streaming interface, ie a FUSE mounted s3 object. This flag indicates that using a streaming mount, as opposed to downloading the whole file to the local scratch space, may be faster despite the latency and overhead. This does not mean that the backend will use a streaming interface, as it may not be provided by the vendor, but if the capacity is avalible it can be used without degrading the performance of the underlying program. + #[serde(rename = "streamable", skip_serializing_if = "Option::is_none")] + pub streamable: Option, +} + +impl TesInput { + /// Input describes Task input files. + pub fn new(path: String) -> TesInput { + TesInput { + name: None, + description: None, + url: None, + path, + r#type: None, + content: None, + streamable: None, + } + } +} + diff --git a/lib/src/TES/models/tes_list_tasks_response.rs b/lib/src/TES/models/tes_list_tasks_response.rs new file mode 100644 index 0000000..545457f --- /dev/null +++ b/lib/src/TES/models/tes_list_tasks_response.rs @@ -0,0 +1,33 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesListTasksResponse : ListTasksResponse describes a response from the ListTasks endpoint. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesListTasksResponse { + /// List of tasks. These tasks will be based on the original submitted task document, but with other fields, such as the job state and logging info, added/changed as the job progresses. + #[serde(rename = "tasks")] + pub tasks: Vec, + /// Token used to return the next page of results. This value can be used in the `page_token` field of the next ListTasks request. + #[serde(rename = "next_page_token", skip_serializing_if = "Option::is_none")] + pub next_page_token: Option, +} + +impl TesListTasksResponse { + /// ListTasksResponse describes a response from the ListTasks endpoint. + pub fn new(tasks: Vec) -> TesListTasksResponse { + TesListTasksResponse { + tasks, + next_page_token: None, + } + } +} + diff --git a/lib/src/TES/models/tes_output.rs b/lib/src/TES/models/tes_output.rs new file mode 100644 index 0000000..f627425 --- /dev/null +++ b/lib/src/TES/models/tes_output.rs @@ -0,0 +1,48 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesOutput : Output describes Task output files. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesOutput { + /// User-provided name of output file + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + /// Optional users provided description field, can be used for documentation. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + /// URL at which the TES server makes the output accessible after the task is complete. When tesOutput.path contains wildcards, it must be a directory; see `tesOutput.path_prefix` for details on how output URLs are constructed in this case. For Example: - `s3://my-object-store/file1` - `gs://my-bucket/file2` - `file:///path/to/my/file` + #[serde(rename = "url")] + pub url: String, + /// Absolute path of the file inside the container. May contain pattern matching wildcards to select multiple outputs at once, but mind implications for `tesOutput.url` and `tesOutput.path_prefix`. Only wildcards defined in IEEE Std 1003.1-2017 (POSIX), 12.3 are supported; see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13 + #[serde(rename = "path")] + pub path: String, + /// Prefix to be removed from matching outputs if `tesOutput.path` contains wildcards; output URLs are constructed by appending pruned paths to the directory specfied in `tesOutput.url`. Required if `tesOutput.path` contains wildcards, ignored otherwise. + #[serde(rename = "path_prefix", skip_serializing_if = "Option::is_none")] + pub path_prefix: Option, + #[serde(rename = "type", skip_serializing_if = "Option::is_none")] + pub r#type: Option, +} + +impl TesOutput { + /// Output describes Task output files. + pub fn new(url: String, path: String) -> TesOutput { + TesOutput { + name: None, + description: None, + url, + path, + path_prefix: None, + r#type: None, + } + } +} + diff --git a/lib/src/TES/models/tes_output_file_log.rs b/lib/src/TES/models/tes_output_file_log.rs new file mode 100644 index 0000000..282dd7c --- /dev/null +++ b/lib/src/TES/models/tes_output_file_log.rs @@ -0,0 +1,37 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesOutputFileLog : OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesOutputFileLog { + /// URL of the file in storage, e.g. s3://bucket/file.txt + #[serde(rename = "url")] + pub url: String, + /// Path of the file inside the container. Must be an absolute path. + #[serde(rename = "path")] + pub path: String, + /// Size of the file in bytes. Note, this is currently coded as a string because official JSON doesn't support int64 numbers. + #[serde(rename = "size_bytes")] + pub size_bytes: String, +} + +impl TesOutputFileLog { + /// OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. + pub fn new(url: String, path: String, size_bytes: String) -> TesOutputFileLog { + TesOutputFileLog { + url, + path, + size_bytes, + } + } +} + diff --git a/lib/src/TES/models/tes_resources.rs b/lib/src/TES/models/tes_resources.rs new file mode 100644 index 0000000..8c6286d --- /dev/null +++ b/lib/src/TES/models/tes_resources.rs @@ -0,0 +1,53 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesResources : Resources describes the resources requested by a task. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesResources { + /// Requested number of CPUs + #[serde(rename = "cpu_cores", skip_serializing_if = "Option::is_none")] + pub cpu_cores: Option, + /// Define if the task is allowed to run on preemptible compute instances, for example, AWS Spot. This option may have no effect when utilized on some backends that don't have the concept of preemptible jobs. + #[serde(rename = "preemptible", skip_serializing_if = "Option::is_none")] + pub preemptible: Option, + /// Requested RAM required in gigabytes (GB) + #[serde(rename = "ram_gb", skip_serializing_if = "Option::is_none")] + pub ram_gb: Option, + /// Requested disk size in gigabytes (GB) + #[serde(rename = "disk_gb", skip_serializing_if = "Option::is_none")] + pub disk_gb: Option, + /// Request that the task be run in these compute zones. How this string is utilized will be dependent on the backend system. For example, a system based on a cluster queueing system may use this string to define priorty queue to which the job is assigned. + #[serde(rename = "zones", skip_serializing_if = "Option::is_none")] + pub zones: Option>, + /// Key/value pairs for backend configuration. ServiceInfo shall return a list of keys that a backend supports. Keys are case insensitive. It is expected that clients pass all runtime or hardware requirement key/values that are not mapped to existing tesResources properties to backend_parameters. Backends shall log system warnings if a key is passed that is unsupported. Backends shall not store or return unsupported keys if included in a task. If backend_parameters_strict equals true, backends should fail the task if any key/values are unsupported, otherwise, backends should attempt to run the task Intended uses include VM size selection, coprocessor configuration, etc. Example: ``` { \"backend_parameters\" : { \"VmSize\" : \"Standard_D64_v3\" } } ``` + #[serde(rename = "backend_parameters", skip_serializing_if = "Option::is_none")] + pub backend_parameters: Option>, + /// If set to true, backends should fail the task if any backend_parameters key/values are unsupported, otherwise, backends should attempt to run the task + #[serde(rename = "backend_parameters_strict", skip_serializing_if = "Option::is_none")] + pub backend_parameters_strict: Option, +} + +impl TesResources { + /// Resources describes the resources requested by a task. + pub fn new() -> TesResources { + TesResources { + cpu_cores: None, + preemptible: None, + ram_gb: None, + disk_gb: None, + zones: None, + backend_parameters: None, + backend_parameters_strict: None, + } + } +} + diff --git a/lib/src/TES/models/tes_service_info.rs b/lib/src/TES/models/tes_service_info.rs new file mode 100644 index 0000000..3747a85 --- /dev/null +++ b/lib/src/TES/models/tes_service_info.rs @@ -0,0 +1,73 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesServiceInfo { + /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. + #[serde(rename = "id")] + pub id: String, + /// Name of this service. Should be human readable. + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "type")] + pub r#type: Box, + /// Description of the service. Should be human readable and provide information about the service. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "organization")] + pub organization: Box, + /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). + #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] + pub contact_url: Option, + /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. + #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] + pub documentation_url: Option, + /// Timestamp describing when the service was first deployed and available (RFC 3339 format) + #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] + pub created_at: Option, + /// Timestamp describing when the service was last updated (RFC 3339 format) + #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] + pub updated_at: Option, + /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option, + /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. + #[serde(rename = "version")] + pub version: String, + /// Lists some, but not necessarily all, storage locations supported by the service. + #[serde(rename = "storage", skip_serializing_if = "Option::is_none")] + pub storage: Option>, + /// Lists all tesResources.backend_parameters keys supported by the service + #[serde(rename = "tesResources_backend_parameters", skip_serializing_if = "Option::is_none")] + pub tes_resources_backend_parameters: Option>, +} + +impl TesServiceInfo { + pub fn new(id: String, name: String, r#type: models::TesServiceType, organization: models::ServiceOrganization, version: String) -> TesServiceInfo { + TesServiceInfo { + id, + name, + r#type: Box::new(r#type), + description: None, + organization: Box::new(organization), + contact_url: None, + documentation_url: None, + created_at: None, + updated_at: None, + environment: None, + version, + storage: None, + tes_resources_backend_parameters: None, + } + } +} + diff --git a/lib/src/TES/models/tes_service_type.rs b/lib/src/TES/models/tes_service_type.rs new file mode 100644 index 0000000..efd7386 --- /dev/null +++ b/lib/src/TES/models/tes_service_type.rs @@ -0,0 +1,46 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesServiceType { + /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). + #[serde(rename = "group")] + pub group: String, + #[serde(rename = "artifact")] + pub artifact: Artifact, + /// Version of the API or specification. GA4GH specifications use semantic versioning. + #[serde(rename = "version")] + pub version: String, +} + +impl TesServiceType { + pub fn new(group: String, artifact: Artifact, version: String) -> TesServiceType { + TesServiceType { + group, + artifact, + version, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Artifact { + #[serde(rename = "tes")] + Tes, +} + +impl Default for Artifact { + fn default() -> Artifact { + Self::Tes + } +} + diff --git a/lib/src/TES/models/tes_state.rs b/lib/src/TES/models/tes_state.rs new file mode 100644 index 0000000..3c6d627 --- /dev/null +++ b/lib/src/TES/models/tes_state.rs @@ -0,0 +1,65 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesState : Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. +/// Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum TesState { + #[serde(rename = "UNKNOWN")] + Unknown, + #[serde(rename = "QUEUED")] + Queued, + #[serde(rename = "INITIALIZING")] + Initializing, + #[serde(rename = "RUNNING")] + Running, + #[serde(rename = "PAUSED")] + Paused, + #[serde(rename = "COMPLETE")] + Complete, + #[serde(rename = "EXECUTOR_ERROR")] + ExecutorError, + #[serde(rename = "SYSTEM_ERROR")] + SystemError, + #[serde(rename = "CANCELED")] + Canceled, + #[serde(rename = "PREEMPTED")] + Preempted, + #[serde(rename = "CANCELING")] + Canceling, + +} + +impl ToString for TesState { + fn to_string(&self) -> String { + match self { + Self::Unknown => String::from("UNKNOWN"), + Self::Queued => String::from("QUEUED"), + Self::Initializing => String::from("INITIALIZING"), + Self::Running => String::from("RUNNING"), + Self::Paused => String::from("PAUSED"), + Self::Complete => String::from("COMPLETE"), + Self::ExecutorError => String::from("EXECUTOR_ERROR"), + Self::SystemError => String::from("SYSTEM_ERROR"), + Self::Canceled => String::from("CANCELED"), + Self::Preempted => String::from("PREEMPTED"), + Self::Canceling => String::from("CANCELING"), + } + } +} + +impl Default for TesState { + fn default() -> TesState { + Self::Unknown + } +} + diff --git a/lib/src/TES/models/tes_task.rs b/lib/src/TES/models/tes_task.rs new file mode 100644 index 0000000..68355cc --- /dev/null +++ b/lib/src/TES/models/tes_task.rs @@ -0,0 +1,71 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesTask : Task describes an instance of a task. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesTask { + /// Task identifier assigned by the server. + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "state", skip_serializing_if = "Option::is_none")] + pub state: Option, + /// User-provided task name. + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + /// Optional user-provided description of task for documentation purposes. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + /// Input files that will be used by the task. Inputs will be downloaded and mounted into the executor container as defined by the task request document. + #[serde(rename = "inputs", skip_serializing_if = "Option::is_none")] + pub inputs: Option>, + /// Output files. Outputs will be uploaded from the executor container to long-term storage. + #[serde(rename = "outputs", skip_serializing_if = "Option::is_none")] + pub outputs: Option>, + #[serde(rename = "resources", skip_serializing_if = "Option::is_none")] + pub resources: Option>, + /// An array of executors to be run. Each of the executors will run one at a time sequentially. Each executor is a different command that will be run, and each can utilize a different docker image. But each of the executors will see the same mapped inputs and volumes that are declared in the parent CreateTask message. Execution stops on the first error. + #[serde(rename = "executors")] + pub executors: Vec, + /// Volumes are directories which may be used to share data between Executors. Volumes are initialized as empty directories by the system when the task starts and are mounted at the same path in each Executor. For example, given a volume defined at `/vol/A`, executor 1 may write a file to `/vol/A/exec1.out.txt`, then executor 2 may read from that file. (Essentially, this translates to a `docker run -v` flag where the container path is the same for each executor). + #[serde(rename = "volumes", skip_serializing_if = "Option::is_none")] + pub volumes: Option>, + /// A key-value map of arbitrary tags. These can be used to store meta-data and annotations about a task. Example: ``` { \"tags\" : { \"WORKFLOW_ID\" : \"cwl-01234\", \"PROJECT_GROUP\" : \"alice-lab\" } } ``` + #[serde(rename = "tags", skip_serializing_if = "Option::is_none")] + pub tags: Option>, + /// Task logging information. Normally, this will contain only one entry, but in the case where a task fails and is retried, an entry will be appended to this list. + #[serde(rename = "logs", skip_serializing_if = "Option::is_none")] + pub logs: Option>, + /// Date + time the task was created, in RFC 3339 format. This is set by the system, not the client. + #[serde(rename = "creation_time", skip_serializing_if = "Option::is_none")] + pub creation_time: Option, +} + +impl TesTask { + /// Task describes an instance of a task. + pub fn new(executors: Vec) -> TesTask { + TesTask { + id: None, + state: None, + name: None, + description: None, + inputs: None, + outputs: None, + resources: None, + executors, + volumes: None, + tags: None, + logs: None, + creation_time: None, + } + } +} + diff --git a/lib/src/TES/models/tes_task_log.rs b/lib/src/TES/models/tes_task_log.rs new file mode 100644 index 0000000..90d219e --- /dev/null +++ b/lib/src/TES/models/tes_task_log.rs @@ -0,0 +1,49 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// TesTaskLog : TaskLog describes logging information related to a Task. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesTaskLog { + /// Logs for each executor + #[serde(rename = "logs")] + pub logs: Vec, + /// Arbitrary logging metadata included by the implementation. + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + /// When the task started, in RFC 3339 format. + #[serde(rename = "start_time", skip_serializing_if = "Option::is_none")] + pub start_time: Option, + /// When the task ended, in RFC 3339 format. + #[serde(rename = "end_time", skip_serializing_if = "Option::is_none")] + pub end_time: Option, + /// Information about all output files. Directory outputs are flattened into separate items. + #[serde(rename = "outputs")] + pub outputs: Vec, + /// System logs are any logs the system decides are relevant, which are not tied directly to an Executor process. Content is implementation specific: format, size, etc. System logs may be collected here to provide convenient access. For example, the system may include the name of the host where the task is executing, an error message that caused a SYSTEM_ERROR state (e.g. disk is full), etc. System logs are only included in the FULL task view. + #[serde(rename = "system_logs", skip_serializing_if = "Option::is_none")] + pub system_logs: Option>, +} + +impl TesTaskLog { + /// TaskLog describes logging information related to a Task. + pub fn new(logs: Vec, outputs: Vec) -> TesTaskLog { + TesTaskLog { + logs, + metadata: None, + start_time: None, + end_time: None, + outputs, + system_logs: None, + } + } +} + diff --git a/lib/src/service.rs b/lib/src/service.rs new file mode 100644 index 0000000..e69de29 From 4560fc48de4c725822d3c881a82fedbbe2c3d0e5 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 7 Jun 2024 16:34:44 +0530 Subject: [PATCH 03/92] corrected workflow --- lib/Cargo.toml => Cargo.toml | 4 ++++ 1 file changed, 4 insertions(+) rename lib/Cargo.toml => Cargo.toml (83%) diff --git a/lib/Cargo.toml b/Cargo.toml similarity index 83% rename from lib/Cargo.toml rename to Cargo.toml index 1120dee..787d2f8 100644 --- a/lib/Cargo.toml +++ b/Cargo.toml @@ -8,3 +8,7 @@ license = "Apache-2.0" repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk.git" [dependencies] + +[lib] +name = "my_project" +path = "lib/src/lib.rs" \ No newline at end of file From 4210498369088bf8dd64866dfbdf5e68e80092e3 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 7 Jun 2024 19:49:49 +0530 Subject: [PATCH 04/92] added function create_task from autogenerated, trying some stuff for service.rs --- Cargo.toml | 8 ++ lib/src/lib.rs | 21 ++-- lib/src/service.rs | 77 +++++++++++++++ lib/src/tes/configuration.rs | 53 +++++++++++ lib/src/tes/mod.rs | 95 +++++++++++++++++++ lib/src/{TES => tes}/models/mod.rs | 0 lib/src/{TES => tes}/models/service.rs | 2 +- .../models/service_organization.rs | 2 +- lib/src/{TES => tes}/models/service_type.rs | 7 +- .../models/tes_create_task_response.rs | 2 +- lib/src/{TES => tes}/models/tes_executor.rs | 2 +- .../{TES => tes}/models/tes_executor_log.rs | 2 +- lib/src/{TES => tes}/models/tes_file_type.rs | 2 +- lib/src/{TES => tes}/models/tes_input.rs | 2 +- .../models/tes_list_tasks_response.rs | 2 +- lib/src/{TES => tes}/models/tes_output.rs | 2 +- .../models/tes_output_file_log.rs | 2 +- lib/src/{TES => tes}/models/tes_resources.rs | 2 +- .../{TES => tes}/models/tes_service_info.rs | 2 +- .../{TES => tes}/models/tes_service_type.rs | 2 +- lib/src/{TES => tes}/models/tes_state.rs | 2 +- lib/src/{TES => tes}/models/tes_task.rs | 2 +- lib/src/{TES => tes}/models/tes_task_log.rs | 12 ++- lib/src/tes/tes.rs | 50 ++++++++++ 24 files changed, 318 insertions(+), 35 deletions(-) create mode 100644 lib/src/tes/configuration.rs create mode 100644 lib/src/tes/mod.rs rename lib/src/{TES => tes}/models/mod.rs (100%) rename lib/src/{TES => tes}/models/service.rs (99%) rename lib/src/{TES => tes}/models/service_organization.rs (99%) rename lib/src/{TES => tes}/models/service_type.rs (97%) rename lib/src/{TES => tes}/models/tes_create_task_response.rs (99%) rename lib/src/{TES => tes}/models/tes_executor.rs (99%) rename lib/src/{TES => tes}/models/tes_executor_log.rs (99%) rename lib/src/{TES => tes}/models/tes_file_type.rs (99%) rename lib/src/{TES => tes}/models/tes_input.rs (99%) rename lib/src/{TES => tes}/models/tes_list_tasks_response.rs (99%) rename lib/src/{TES => tes}/models/tes_output.rs (99%) rename lib/src/{TES => tes}/models/tes_output_file_log.rs (99%) rename lib/src/{TES => tes}/models/tes_resources.rs (99%) rename lib/src/{TES => tes}/models/tes_service_info.rs (99%) rename lib/src/{TES => tes}/models/tes_service_type.rs (99%) rename lib/src/{TES => tes}/models/tes_state.rs (99%) rename lib/src/{TES => tes}/models/tes_task.rs (99%) rename lib/src/{TES => tes}/models/tes_task_log.rs (95%) create mode 100644 lib/src/tes/tes.rs diff --git a/Cargo.toml b/Cargo.toml index 787d2f8..fc90be5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,14 @@ license = "Apache-2.0" repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk.git" [dependencies] +serde = "^1.0" +serde_derive = "^1.0" +serde_json = "^1.0" +url = "^2.2" +uuid = { version = "^1.0", features = ["serde", "v4"] } +[dependencies.reqwest] +version = "^0.11" +features = ["json", "multipart"] [lib] name = "my_project" diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 6ac2420..42bdfae 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -1,14 +1,13 @@ -//! This is the main library file for the `lib` crate. -#![warn(missing_docs)] +#![allow(unused_imports)] +#[macro_use] +extern crate serde_derive; -// UNIT TESTING -#[cfg(test)] -mod tests { - // use super::*; +extern crate serde; +extern crate serde_json; +extern crate url; +extern crate reqwest; - #[test] - fn test() { - // This test currently does nothing, it is just a placeholder. - } -} \ No newline at end of file + +pub mod service; +pub mod tes; diff --git a/lib/src/service.rs b/lib/src/service.rs index e69de29..056755f 100644 --- a/lib/src/service.rs +++ b/lib/src/service.rs @@ -0,0 +1,77 @@ +use reqwest::Client; +use serde::Serialize; +use serde_json::Value; +use std::error::Error; + +#[derive(Debug)] +pub struct Service { + base_url: String, + client: Client, + username: Option, + password: Option, + token: Option, +} + +impl Service { + pub fn new(base_url: String, username: Option, password: Option, token: Option) -> Self { + Service { + base_url, + client: Client::new(), + username, + password, + token, + } + } + + pub async fn request( + &self, + method: reqwest::Method, + endpoint: &str, + data: Option, + params: Option, + ) -> Result> { + let url = format!("{}/{}", self.base_url, endpoint); + let mut headers = reqwest::header::HeaderMap::new(); + headers.insert("Content-Type", "application/json".parse()?); + + if let Some(token) = &self.token { + headers.insert( + "Authorization", + format!("Bearer {}", token).parse()?, + ); + } + + let mut req_builder = self.client.request(method, &url).headers(headers); + + if let Some(data) = data { + req_builder = req_builder.json(&data); + } + + if let Some(params) = params { + req_builder = req_builder.query(¶ms); + } + + let response = req_builder.send().await?; + + if !response.status().is_success() { + let error_message = format!("Error: HTTP {} - {}", response.status(), response.status().canonical_reason().unwrap_or("Unknown error")); + eprintln!("{}", error_message); + return Err(error_message.into()); + } + + let content_type = response + .headers() + .get(reqwest::header::CONTENT_TYPE) + .and_then(|value| value.to_str().ok()) + .unwrap_or(""); + + let response_data = if content_type.contains("application/json") { + response.json::().await? + } else { + Value::String(response.text().await?) + }; + + Ok(response_data) + } + +} diff --git a/lib/src/tes/configuration.rs b/lib/src/tes/configuration.rs new file mode 100644 index 0000000..f2be9d1 --- /dev/null +++ b/lib/src/tes/configuration.rs @@ -0,0 +1,53 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + + + +#[derive(Debug, Clone)] +pub struct Configuration { + pub base_path: String, + pub user_agent: Option, + pub client: reqwest::Client, + pub basic_auth: Option, + pub oauth_access_token: Option, + pub bearer_access_token: Option, + pub api_key: Option, + // TODO: take an oauth2 token source, similar to the go one +} + +pub type BasicAuth = (String, Option); + +#[derive(Debug, Clone)] +pub struct ApiKey { + pub prefix: Option, + pub key: String, +} + + +impl Configuration { + pub fn new() -> Configuration { + Configuration::default() + } +} + +impl Default for Configuration { + fn default() -> Self { + Configuration { + base_path: "/ga4gh/tes/v1".to_owned(), + user_agent: Some("OpenAPI-Generator/1.1.0/rust".to_owned()), + client: reqwest::Client::new(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None, + + } + } +} \ No newline at end of file diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs new file mode 100644 index 0000000..f99ad5b --- /dev/null +++ b/lib/src/tes/mod.rs @@ -0,0 +1,95 @@ +use std::error; +use std::fmt; + +#[derive(Debug, Clone)] +pub struct ResponseContent { + pub status: reqwest::StatusCode, + pub content: String, + pub entity: Option, +} + +#[derive(Debug)] +pub enum Error { + Reqwest(reqwest::Error), + Serde(serde_json::Error), + Io(std::io::Error), + ResponseError(ResponseContent), +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (module, e) = match self { + Error::Reqwest(e) => ("reqwest", e.to_string()), + Error::Serde(e) => ("serde", e.to_string()), + Error::Io(e) => ("IO", e.to_string()), + Error::ResponseError(e) => ("response", format!("status code {}", e.status)), + }; + write!(f, "error in {}: {}", module, e) + } +} + +impl error::Error for Error { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + Some(match self { + Error::Reqwest(e) => e, + Error::Serde(e) => e, + Error::Io(e) => e, + Error::ResponseError(_) => return None, + }) + } +} + +impl From for Error { + fn from(e: reqwest::Error) -> Self { + Error::Reqwest(e) + } +} + +impl From for Error { + fn from(e: serde_json::Error) -> Self { + Error::Serde(e) + } +} + +impl From for Error { + fn from(e: std::io::Error) -> Self { + Error::Io(e) + } +} + +pub fn urlencode>(s: T) -> String { + ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +} + +pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { + if let serde_json::Value::Object(object) = value { + let mut params = vec![]; + + for (key, value) in object { + match value { + serde_json::Value::Object(_) => params.append(&mut parse_deep_object( + &format!("{}[{}]", prefix, key), + value, + )), + serde_json::Value::Array(array) => { + for (i, value) in array.iter().enumerate() { + params.append(&mut parse_deep_object( + &format!("{}[{}][{}]", prefix, key, i), + value, + )); + } + }, + serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), + _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), + } + } + + return params; + } + + unimplemented!("Only objects are supported with style=deepObject") +} + +pub mod tes; +pub mod configuration; +pub mod models; \ No newline at end of file diff --git a/lib/src/TES/models/mod.rs b/lib/src/tes/models/mod.rs similarity index 100% rename from lib/src/TES/models/mod.rs rename to lib/src/tes/models/mod.rs diff --git a/lib/src/TES/models/service.rs b/lib/src/tes/models/service.rs similarity index 99% rename from lib/src/TES/models/service.rs rename to lib/src/tes/models/service.rs index 1943618..0fd520f 100644 --- a/lib/src/TES/models/service.rs +++ b/lib/src/tes/models/service.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// Service : GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/service_organization.rs b/lib/src/tes/models/service_organization.rs similarity index 99% rename from lib/src/TES/models/service_organization.rs rename to lib/src/tes/models/service_organization.rs index ea658ca..e38091c 100644 --- a/lib/src/TES/models/service_organization.rs +++ b/lib/src/tes/models/service_organization.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// ServiceOrganization : Organization providing the service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/service_type.rs b/lib/src/tes/models/service_type.rs similarity index 97% rename from lib/src/TES/models/service_type.rs rename to lib/src/tes/models/service_type.rs index c325103..3dee78f 100644 --- a/lib/src/TES/models/service_type.rs +++ b/lib/src/tes/models/service_type.rs @@ -1,14 +1,14 @@ /* * Task Execution Service * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. * * The version of the OpenAPI document: 1.1.0 - * + * * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// ServiceType : Type of a GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] @@ -34,4 +34,3 @@ impl ServiceType { } } } - diff --git a/lib/src/TES/models/tes_create_task_response.rs b/lib/src/tes/models/tes_create_task_response.rs similarity index 99% rename from lib/src/TES/models/tes_create_task_response.rs rename to lib/src/tes/models/tes_create_task_response.rs index 618d8ef..d02f9bd 100644 --- a/lib/src/TES/models/tes_create_task_response.rs +++ b/lib/src/tes/models/tes_create_task_response.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesCreateTaskResponse : CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_executor.rs b/lib/src/tes/models/tes_executor.rs similarity index 99% rename from lib/src/TES/models/tes_executor.rs rename to lib/src/tes/models/tes_executor.rs index f440d88..8cbbe17 100644 --- a/lib/src/TES/models/tes_executor.rs +++ b/lib/src/tes/models/tes_executor.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesExecutor : Executor describes a command to be executed, and its environment. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_executor_log.rs b/lib/src/tes/models/tes_executor_log.rs similarity index 99% rename from lib/src/TES/models/tes_executor_log.rs rename to lib/src/tes/models/tes_executor_log.rs index 7af295b..bbf7173 100644 --- a/lib/src/TES/models/tes_executor_log.rs +++ b/lib/src/tes/models/tes_executor_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesExecutorLog : ExecutorLog describes logging information related to an Executor. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_file_type.rs b/lib/src/tes/models/tes_file_type.rs similarity index 99% rename from lib/src/TES/models/tes_file_type.rs rename to lib/src/tes/models/tes_file_type.rs index c517a37..cc794eb 100644 --- a/lib/src/TES/models/tes_file_type.rs +++ b/lib/src/tes/models/tes_file_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesFileType : Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. /// Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. diff --git a/lib/src/TES/models/tes_input.rs b/lib/src/tes/models/tes_input.rs similarity index 99% rename from lib/src/TES/models/tes_input.rs rename to lib/src/tes/models/tes_input.rs index 1a86574..e36358a 100644 --- a/lib/src/TES/models/tes_input.rs +++ b/lib/src/tes/models/tes_input.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesInput : Input describes Task input files. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_list_tasks_response.rs b/lib/src/tes/models/tes_list_tasks_response.rs similarity index 99% rename from lib/src/TES/models/tes_list_tasks_response.rs rename to lib/src/tes/models/tes_list_tasks_response.rs index 545457f..a15f832 100644 --- a/lib/src/TES/models/tes_list_tasks_response.rs +++ b/lib/src/tes/models/tes_list_tasks_response.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesListTasksResponse : ListTasksResponse describes a response from the ListTasks endpoint. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_output.rs b/lib/src/tes/models/tes_output.rs similarity index 99% rename from lib/src/TES/models/tes_output.rs rename to lib/src/tes/models/tes_output.rs index f627425..6afd91c 100644 --- a/lib/src/TES/models/tes_output.rs +++ b/lib/src/tes/models/tes_output.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesOutput : Output describes Task output files. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_output_file_log.rs b/lib/src/tes/models/tes_output_file_log.rs similarity index 99% rename from lib/src/TES/models/tes_output_file_log.rs rename to lib/src/tes/models/tes_output_file_log.rs index 282dd7c..ccfe0dc 100644 --- a/lib/src/TES/models/tes_output_file_log.rs +++ b/lib/src/tes/models/tes_output_file_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesOutputFileLog : OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_resources.rs b/lib/src/tes/models/tes_resources.rs similarity index 99% rename from lib/src/TES/models/tes_resources.rs rename to lib/src/tes/models/tes_resources.rs index 8c6286d..991aff7 100644 --- a/lib/src/TES/models/tes_resources.rs +++ b/lib/src/tes/models/tes_resources.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesResources : Resources describes the resources requested by a task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_service_info.rs b/lib/src/tes/models/tes_service_info.rs similarity index 99% rename from lib/src/TES/models/tes_service_info.rs rename to lib/src/tes/models/tes_service_info.rs index 3747a85..4a8196a 100644 --- a/lib/src/TES/models/tes_service_info.rs +++ b/lib/src/tes/models/tes_service_info.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] pub struct TesServiceInfo { diff --git a/lib/src/TES/models/tes_service_type.rs b/lib/src/tes/models/tes_service_type.rs similarity index 99% rename from lib/src/TES/models/tes_service_type.rs rename to lib/src/tes/models/tes_service_type.rs index efd7386..81be8ae 100644 --- a/lib/src/TES/models/tes_service_type.rs +++ b/lib/src/tes/models/tes_service_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] pub struct TesServiceType { diff --git a/lib/src/TES/models/tes_state.rs b/lib/src/tes/models/tes_state.rs similarity index 99% rename from lib/src/TES/models/tes_state.rs rename to lib/src/tes/models/tes_state.rs index 3c6d627..1dfd913 100644 --- a/lib/src/TES/models/tes_state.rs +++ b/lib/src/tes/models/tes_state.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesState : Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. /// Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. diff --git a/lib/src/TES/models/tes_task.rs b/lib/src/tes/models/tes_task.rs similarity index 99% rename from lib/src/TES/models/tes_task.rs rename to lib/src/tes/models/tes_task.rs index 68355cc..7b27e8a 100644 --- a/lib/src/TES/models/tes_task.rs +++ b/lib/src/tes/models/tes_task.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesTask : Task describes an instance of a task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/TES/models/tes_task_log.rs b/lib/src/tes/models/tes_task_log.rs similarity index 95% rename from lib/src/TES/models/tes_task_log.rs rename to lib/src/tes/models/tes_task_log.rs index 90d219e..eb8a551 100644 --- a/lib/src/TES/models/tes_task_log.rs +++ b/lib/src/tes/models/tes_task_log.rs @@ -1,14 +1,14 @@ /* * Task Execution Service * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. * * The version of the OpenAPI document: 1.1.0 - * + * * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::tes::models; /// TesTaskLog : TaskLog describes logging information related to a Task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] @@ -35,7 +35,10 @@ pub struct TesTaskLog { impl TesTaskLog { /// TaskLog describes logging information related to a Task. - pub fn new(logs: Vec, outputs: Vec) -> TesTaskLog { + pub fn new( + logs: Vec, + outputs: Vec, + ) -> TesTaskLog { TesTaskLog { logs, metadata: None, @@ -46,4 +49,3 @@ impl TesTaskLog { } } } - diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs new file mode 100644 index 0000000..d87ff1e --- /dev/null +++ b/lib/src/tes/tes.rs @@ -0,0 +1,50 @@ +use reqwest; + +use crate::{tes::ResponseContent, tes::models}; +use super::{Error, configuration}; + +/// struct for passing parameters to the method [`create_task`] +#[derive(Clone, Debug)] +pub struct CreateTaskParams { + pub body: models::TesTask +} + +/// struct for typed errors of method [`create_task`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum CreateTaskError { + UnknownValue(serde_json::Value), +} + +/// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. +pub async fn create_task(configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { + let local_var_configuration = configuration; + + // unbox the parameters + let body = params.body; + + + let local_var_client = &local_var_configuration.client; + + let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); + let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str()); + + if let Some(ref local_var_user_agent) = local_var_configuration.user_agent { + local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); + } + local_var_req_builder = local_var_req_builder.json(&body); + + let local_var_req = local_var_req_builder.build()?; + let local_var_resp = local_var_client.execute(local_var_req).await?; + + let local_var_status = local_var_resp.status(); + let local_var_content = local_var_resp.text().await?; + + if !local_var_status.is_client_error() && !local_var_status.is_server_error() { + serde_json::from_str(&local_var_content).map_err(Error::from) + } else { + let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); + let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; + Err(Error::ResponseError(local_var_error)) + } +} \ No newline at end of file From 61fcb7a5a32accae6d3c8a2af5fb7c39c827c2ac Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 10 Jun 2024 03:44:22 +0530 Subject: [PATCH 05/92] made service.rs class --- lib/src/service.rs | 105 +++++++++++++++++++++++++++++++-------------- lib/src/tes/tes.rs | 6 +-- 2 files changed, 76 insertions(+), 35 deletions(-) diff --git a/lib/src/service.rs b/lib/src/service.rs index 056755f..28d9871 100644 --- a/lib/src/service.rs +++ b/lib/src/service.rs @@ -3,6 +3,13 @@ use serde::Serialize; use serde_json::Value; use std::error::Error; + +use crate::{tes::ResponseContent, tes::models}; + +pub enum CreateTaskError { + UnknownValue(serde_json::Value), +} + #[derive(Debug)] pub struct Service { base_url: String, @@ -30,48 +37,82 @@ impl Service { data: Option, params: Option, ) -> Result> { - let url = format!("{}/{}", self.base_url, endpoint); - let mut headers = reqwest::header::HeaderMap::new(); - headers.insert("Content-Type", "application/json".parse()?); - - if let Some(token) = &self.token { - headers.insert( - "Authorization", - format!("Bearer {}", token).parse()?, - ); - } + // What client are we using? + let mut local_var_req_builder = self.client.request(reqwest::Method::POST, endpoint); - let mut req_builder = self.client.request(method, &url).headers(headers); - - if let Some(data) = data { - req_builder = req_builder.json(&data); + if let Some(ref local_var_user_agent) = self.username { + local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); } + + // Check what are data and params + local_var_req_builder = local_var_req_builder.json(&data); - if let Some(params) = params { - req_builder = req_builder.query(¶ms); - } + let local_var_req = local_var_req_builder.build()?; + let local_var_resp = self.client.execute(local_var_req).await?; + + let local_var_status = local_var_resp.status(); + let local_var_content = local_var_resp.text().await?; - let response = req_builder.send().await?; - if !response.status().is_success() { - let error_message = format!("Error: HTTP {} - {}", response.status(), response.status().canonical_reason().unwrap_or("Unknown error")); + // Check what to return, whether Result> or not + if !local_var_status.is_client_error() && !local_var_status.is_server_error() { + serde_json::from_str(&local_var_content).map_err(|e| Box::new(e) as Box) + // serde_json::from_str(&local_var_content).map_err(Error::from) + } else { + // let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); + // let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; + // Err(Error::ResponseError(local_var_error)) + let error_message = format!("Error: HTTP {} - {}", local_var_status, local_var_status.canonical_reason().unwrap_or("Unknown error")); eprintln!("{}", error_message); - return Err(error_message.into()); + Err(error_message.into()) } - let content_type = response - .headers() - .get(reqwest::header::CONTENT_TYPE) - .and_then(|value| value.to_str().ok()) - .unwrap_or(""); + //GA4GH-CLI PYTHON CODE CONVERTED TO RUST (OLD CODE) - let response_data = if content_type.contains("application/json") { - response.json::().await? - } else { - Value::String(response.text().await?) - }; + + // let url = format!("{}/{}", self.base_url, endpoint); + // let mut headers = reqwest::header::HeaderMap::new(); + // headers.insert("Content-Type", "application/json".parse()?); - Ok(response_data) + // if let Some(token) = &self.token { + // headers.insert( + // "Authorization", + // format!("Bearer {}", token).parse()?, + // ); + // } + + // let mut req_builder = self.client.request(method, &url).headers(headers); + + // if let Some(data) = data { + // req_builder = req_builder.json(&data); + // } + + // if let Some(params) = params { + // req_builder = req_builder.query(¶ms); + // } + + // let response = req_builder.send().await?; + + // if !response.status().is_success() { + // let error_message = format!("Error: HTTP {} - {}", response.status(), response.status().canonical_reason().unwrap_or("Unknown error")); + // eprintln!("{}", error_message); + // return Err(error_message.into()); + // } + + // let content_type = response + // .headers() + // .get(reqwest::header::CONTENT_TYPE) + // .and_then(|value| value.to_str().ok()) + // .unwrap_or(""); + + // let response_data = if content_type.contains("application/json") { + // response.json::().await? + // } else { + // Value::String(response.text().await?) + // }; + + // Ok(response_data) } } + diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs index d87ff1e..aa0dd88 100644 --- a/lib/src/tes/tes.rs +++ b/lib/src/tes/tes.rs @@ -22,12 +22,12 @@ pub async fn create_task(configuration: &configuration::Configuration, params: C // unbox the parameters let body = params.body; - - + let local_var_client = &local_var_configuration.client; let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); - let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str()); + let endpoint = local_var_uri_str.as_str(); + let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, endpoint); if let Some(ref local_var_user_agent) = local_var_configuration.user_agent { local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); From 780e7ff6f7fffbb3756b278569c9eec3efbe9066 Mon Sep 17 00:00:00 2001 From: aaravm Date: Tue, 11 Jun 2024 21:54:56 +0530 Subject: [PATCH 06/92] changed return type of service class, added TES class, using service class to call create tasks --- lib/src/service.rs | 90 +++++++++++------------------------- lib/src/tes/configuration.rs | 1 - lib/src/tes/tes.rs | 73 +++++++++++++++++++---------- 3 files changed, 77 insertions(+), 87 deletions(-) diff --git a/lib/src/service.rs b/lib/src/service.rs index 28d9871..5d7aeb6 100644 --- a/lib/src/service.rs +++ b/lib/src/service.rs @@ -2,6 +2,7 @@ use reqwest::Client; use serde::Serialize; use serde_json::Value; use std::error::Error; +use std::fmt; use crate::{tes::ResponseContent, tes::models}; @@ -10,6 +11,27 @@ pub enum CreateTaskError { UnknownValue(serde_json::Value), } +#[derive(Debug)] +struct MyError { + message: String, +} + +impl MyError { + fn new(message: String) -> MyError { + MyError { + message, + } + } +} + +impl fmt::Display for MyError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.message) + } +} + +impl Error for MyError {} + #[derive(Debug)] pub struct Service { base_url: String, @@ -36,15 +58,13 @@ impl Service { endpoint: &str, data: Option, params: Option, - ) -> Result> { - // What client are we using? + ) -> Result> { let mut local_var_req_builder = self.client.request(reqwest::Method::POST, endpoint); if let Some(ref local_var_user_agent) = self.username { local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); } - // Check what are data and params local_var_req_builder = local_var_req_builder.json(&data); let local_var_req = local_var_req_builder.build()?; @@ -53,66 +73,12 @@ impl Service { let local_var_status = local_var_resp.status(); let local_var_content = local_var_resp.text().await?; - - // Check what to return, whether Result> or not - if !local_var_status.is_client_error() && !local_var_status.is_server_error() { - serde_json::from_str(&local_var_content).map_err(|e| Box::new(e) as Box) - // serde_json::from_str(&local_var_content).map_err(Error::from) + if local_var_status.is_success() { + Ok(local_var_content) } else { - // let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); - // let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; - // Err(Error::ResponseError(local_var_error)) - let error_message = format!("Error: HTTP {} - {}", local_var_status, local_var_status.canonical_reason().unwrap_or("Unknown error")); - eprintln!("{}", error_message); - Err(error_message.into()) - } - - //GA4GH-CLI PYTHON CODE CONVERTED TO RUST (OLD CODE) + Err(Box::new(MyError::new(local_var_content))) - - // let url = format!("{}/{}", self.base_url, endpoint); - // let mut headers = reqwest::header::HeaderMap::new(); - // headers.insert("Content-Type", "application/json".parse()?); - - // if let Some(token) = &self.token { - // headers.insert( - // "Authorization", - // format!("Bearer {}", token).parse()?, - // ); - // } - - // let mut req_builder = self.client.request(method, &url).headers(headers); - - // if let Some(data) = data { - // req_builder = req_builder.json(&data); - // } - - // if let Some(params) = params { - // req_builder = req_builder.query(¶ms); - // } - - // let response = req_builder.send().await?; - - // if !response.status().is_success() { - // let error_message = format!("Error: HTTP {} - {}", response.status(), response.status().canonical_reason().unwrap_or("Unknown error")); - // eprintln!("{}", error_message); - // return Err(error_message.into()); - // } - - // let content_type = response - // .headers() - // .get(reqwest::header::CONTENT_TYPE) - // .and_then(|value| value.to_str().ok()) - // .unwrap_or(""); - - // let response_data = if content_type.contains("application/json") { - // response.json::().await? - // } else { - // Value::String(response.text().await?) - // }; - - // Ok(response_data) + } } -} - +} \ No newline at end of file diff --git a/lib/src/tes/configuration.rs b/lib/src/tes/configuration.rs index f2be9d1..bc7b4fe 100644 --- a/lib/src/tes/configuration.rs +++ b/lib/src/tes/configuration.rs @@ -47,7 +47,6 @@ impl Default for Configuration { oauth_access_token: None, bearer_access_token: None, api_key: None, - } } } \ No newline at end of file diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs index aa0dd88..e778bb9 100644 --- a/lib/src/tes/tes.rs +++ b/lib/src/tes/tes.rs @@ -2,6 +2,15 @@ use reqwest; use crate::{tes::ResponseContent, tes::models}; use super::{Error, configuration}; +use crate::service::Service; +use serde_json::json; +use crate::tes::models::TesCreateTaskResponse; + + +// Defining service class +pub struct Tes { + service: Service, +} /// struct for passing parameters to the method [`create_task`] #[derive(Clone, Debug)] @@ -16,35 +25,51 @@ pub enum CreateTaskError { UnknownValue(serde_json::Value), } -/// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. -pub async fn create_task(configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { - let local_var_configuration = configuration; +impl Tes { + pub fn new(service: Service) -> Self { + Tes { service } + } - // unbox the parameters - let body = params.body; - - let local_var_client = &local_var_configuration.client; + /// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. + pub async fn create_task(&self, configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { + let local_var_configuration = configuration; - let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); - let endpoint = local_var_uri_str.as_str(); - let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, endpoint); + // unbox the parameters + let body = params.body; + + let local_var_client = &local_var_configuration.client; + + let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); + let endpoint = local_var_uri_str.as_str(); + let mut response_ = self.service.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None); - if let Some(ref local_var_user_agent) = local_var_configuration.user_agent { - local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); - } - local_var_req_builder = local_var_req_builder.json(&body); - let local_var_req = local_var_req_builder.build()?; - let local_var_resp = local_var_client.execute(local_var_req).await?; + // if !local_var_status.is_client_error() && !local_var_status.is_server_error() { + // serde_json::from_str(&local_var_content).map_err(Error::from) + // } else { + // let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); + // let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; + // Err(Error::ResponseError(local_var_error)) + // } - let local_var_status = local_var_resp.status(); - let local_var_content = local_var_resp.text().await?; - if !local_var_status.is_client_error() && !local_var_status.is_server_error() { - serde_json::from_str(&local_var_content).map_err(Error::from) - } else { - let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); - let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; - Err(Error::ResponseError(local_var_error)) + // This is not correct, I am working on this + match self.service.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None).await { + Ok(response_text) => { + match serde_json::from_str::(&response_text) { + Ok(parsed_response) => Ok(parsed_response), + Err(_) => Err(Error::new(CreateTaskError::UnknownValue(json!({ + "error": "Failed to parse response", + "response": response_text + })))), + } + } + Err(e) => Err(Error::new(CreateTaskError::UnknownValue(json!({ + "error": e.to_string(), + "cause": "Request execution failed" + })))), + } } + + } \ No newline at end of file From 47e3ca5e37f9c5e08055bcefcf59745414054fda Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 12 Jun 2024 00:09:11 +0530 Subject: [PATCH 07/92] removed return type temporarily fortes class --- lib/src/service.rs | 4 ++-- lib/src/tes/tes.rs | 35 ++++++++++++++++------------------- 2 files changed, 18 insertions(+), 21 deletions(-) diff --git a/lib/src/service.rs b/lib/src/service.rs index 5d7aeb6..d66f708 100644 --- a/lib/src/service.rs +++ b/lib/src/service.rs @@ -1,4 +1,4 @@ -use reqwest::Client; +use reqwest::{Client, Response}; use serde::Serialize; use serde_json::Value; use std::error::Error; @@ -59,7 +59,7 @@ impl Service { data: Option, params: Option, ) -> Result> { - let mut local_var_req_builder = self.client.request(reqwest::Method::POST, endpoint); + let mut local_var_req_builder = self.client.request(method, endpoint); if let Some(ref local_var_user_agent) = self.username { local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs index e778bb9..e20b6d1 100644 --- a/lib/src/tes/tes.rs +++ b/lib/src/tes/tes.rs @@ -31,17 +31,16 @@ impl Tes { } /// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. - pub async fn create_task(&self, configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { + // pub async fn create_task(&self, configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { + pub async fn create_task(&self, configuration: &configuration::Configuration, params: CreateTaskParams) { let local_var_configuration = configuration; // unbox the parameters let body = params.body; - let local_var_client = &local_var_configuration.client; - let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); let endpoint = local_var_uri_str.as_str(); - let mut response_ = self.service.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None); + let response = self.service.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None).await; // if !local_var_status.is_client_error() && !local_var_status.is_server_error() { @@ -53,22 +52,20 @@ impl Tes { // } - // This is not correct, I am working on this - match self.service.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None).await { - Ok(response_text) => { - match serde_json::from_str::(&response_text) { - Ok(parsed_response) => Ok(parsed_response), - Err(_) => Err(Error::new(CreateTaskError::UnknownValue(json!({ - "error": "Failed to parse response", - "response": response_text - })))), - } - } - Err(e) => Err(Error::new(CreateTaskError::UnknownValue(json!({ - "error": e.to_string(), - "cause": "Request execution failed" - })))), + + match response { + Ok(content) => { + // Handle the successful response + println!("Success: {}", content); + // You can also process the content as needed + }, + Err(e) => { + // Handle the error + eprintln!("Error: {}", e); + // You can also process the error as needed + }, } + } From df64e6d1c4b85ccd19b1362c388961d4667ecd57 Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 12 Jun 2024 16:07:55 +0530 Subject: [PATCH 08/92] added tests for service class --- Cargo.toml | 4 ++++ lib/src/service.rs | 53 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index fc90be5..9793d35 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,7 @@ license = "Apache-2.0" repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk.git" [dependencies] +tokio = { version = "1", features = ["full"] } serde = "^1.0" serde_derive = "^1.0" serde_json = "^1.0" @@ -17,6 +18,9 @@ uuid = { version = "^1.0", features = ["serde", "v4"] } version = "^0.11" features = ["json", "multipart"] +[dev-dependencies] +mockito = "0.31" + [lib] name = "my_project" path = "lib/src/lib.rs" \ No newline at end of file diff --git a/lib/src/service.rs b/lib/src/service.rs index d66f708..942fba3 100644 --- a/lib/src/service.rs +++ b/lib/src/service.rs @@ -81,4 +81,57 @@ impl Service { } } +} +#[cfg(test)] +mod tests { + use crate::service::Service; + use reqwest::Method; + use serde_json::json; + use mockito::{mock, Matcher}; + + #[tokio::test] + async fn test_request_success() { + let base_url = &mockito::server_url(); + let _m = mock("GET", "/test") + .with_status(200) + .with_header("content-type", "application/json") + .with_body(r#"{"message": "success"}"#) + .create(); + + let service = Service::new(base_url.clone(), None, None, None); + + let response = service.request( + Method::GET, + &format!("{}/test", base_url), + None, + None, + ).await; + + assert!(response.is_ok()); + let body = response.unwrap(); + assert_eq!(body, r#"{"message": "success"}"#); + } + + #[tokio::test] + async fn test_request_failure() { + let base_url = &mockito::server_url(); + let _m = mock("GET", "/test") + .with_status(404) + .with_header("content-type", "application/json") + .with_body(r#"{"message": "not found"}"#) + .create(); + + let service = Service::new(base_url.clone(), None, None, None); + + let response = service.request( + Method::GET, + &format!("{}/test", base_url), + None, + None, + ).await; + + assert!(response.is_err()); + let error = response.err().unwrap(); + assert_eq!(error.to_string(), r#"{"message": "not found"}"#); + } } \ No newline at end of file From b0ea4394a047fe02c0be7a8be5305957210b6a57 Mon Sep 17 00:00:00 2001 From: aaravm Date: Sat, 15 Jun 2024 11:35:08 +0530 Subject: [PATCH 09/92] added unit test for tes class --- lib/sample/grape.tes | 85 ++++++++++++++++++++++++++++++++++++++++++++ lib/src/service.rs | 10 +++--- lib/src/tes/tes.rs | 46 ++++++++++++++++++++++++ 3 files changed, 136 insertions(+), 5 deletions(-) create mode 100644 lib/sample/grape.tes diff --git a/lib/sample/grape.tes b/lib/sample/grape.tes new file mode 100644 index 0000000..2cceaf6 --- /dev/null +++ b/lib/sample/grape.tes @@ -0,0 +1,85 @@ +{ + "name": "GRAPE", + "resources": { + "disk_gb": 200 + }, + "volumes": [ + "/vol/a/" + ], + "executors": [ + { + "image": "amazon/aws-cli", + "command": [ + "aws", + "s3", + "cp", + "${INPUT}", + "/vol/a/input.vcf.gz" + ], + "env": { + "AWS_ACCESS_KEY_ID": "${AWS_ACCESS_KEY_ID}", + "AWS_SECRET_ACCESS_KEY": "${AWS_SECRET_ACCESS_KEY}", + "AWS_REGION": "${AWS_REGION}" + } + }, + { + "image": "genxnetwork/grape", + "command": [ + "python", + "launcher.py", + "reference", + "--use-bundle", + "--ref-directory", + "/vol/a/media/ref", + "--real-run" + ] + }, + { + "image": "genxnetwork/grape", + "command": [ + "python", + "launcher.py", + "preprocess", + "--ref-directory", + "/vol/a/media/ref", + "--vcf-file", + "/vol/a/input.vcf.gz", + "--directory", + "/vol/a/media/data", + "--assembly", + "hg37", + "--real-run" + ] + }, + { + "image": "genxnetwork/grape", + "command": [ + "python", + "launcher.py", + "find", + "--flow", + "ibis", + "--ref-directory", + "/vol/a/media/ref", + "--directory", + "/vol/a/media/data", + "--real-run" + ] + }, + { + "image": "amazon/aws-cli", + "command": [ + "aws", + "s3", + "cp", + "/vol/a/media/data/results/relatives.tsv", + "${OUTPUT}" + ], + "env": { + "AWS_ACCESS_KEY_ID": "${AWS_ACCESS_KEY_ID}", + "AWS_SECRET_ACCESS_KEY": "${AWS_SECRET_ACCESS_KEY}", + "AWS_REGION": "${AWS_REGION}" + } + } + ] +} \ No newline at end of file diff --git a/lib/src/service.rs b/lib/src/service.rs index 942fba3..8a55706 100644 --- a/lib/src/service.rs +++ b/lib/src/service.rs @@ -34,11 +34,11 @@ impl Error for MyError {} #[derive(Debug)] pub struct Service { - base_url: String, - client: Client, - username: Option, - password: Option, - token: Option, + pub base_url: String, + pub client: Client, + pub username: Option, + pub password: Option, + pub token: Option, } impl Service { diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs index e20b6d1..9e8b33a 100644 --- a/lib/src/tes/tes.rs +++ b/lib/src/tes/tes.rs @@ -69,4 +69,50 @@ impl Tes { } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::tes::configuration::Configuration; + use crate::tes::tes::reqwest::Client; + use crate::tes::models::TesTask; + + #[tokio::test] + async fn test_create_task() { + let client_tes = Client::new(); + + // Define the configuration + let config = Configuration { + base_path: "http://localhost:8000".to_string(), + user_agent: None, + client: client_tes.clone(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None + }; + + // Load the TesTask JSON file + let task_json = std::fs::read_to_string("/home/aarav/dev/ga4gh-sdk/lib/sample/grape.tes").expect("Unable to read file"); + let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); + + // Create the service and Tes instance + let service = Service { + base_url: "http://localhost:8000".to_string(), + client: client_tes.clone(), + username: None, + password: None, + token: None, + + }; + let tes = Tes::new(service); + + // Create the parameters + let params = CreateTaskParams { body: task }; + + // Call the create_task method + let result = tes.create_task(&config, params).await; + println!("{:?}", result); + } } \ No newline at end of file From b54b56f6a989c5dffb720f618832bf9a32edf015 Mon Sep 17 00:00:00 2001 From: aaravm Date: Sun, 16 Jun 2024 21:22:54 +0530 Subject: [PATCH 10/92] changed a lot of names --- lib/src/lib.rs | 4 +- lib/src/service.rs | 137 -------------- lib/src/serviceinfo/models/mod.rs | 6 + lib/src/serviceinfo/models/service.rs | 67 +++++++ .../models/service_organization.rs | 33 ++++ lib/src/serviceinfo/models/service_type.rs | 37 ++++ lib/src/serviceinfo/serviceinfo.rs | 9 + .../configuration.rs | 0 .../{tes => task_execution_service}/mod.rs | 0 .../models/mod.rs | 0 .../models/service.rs | 2 +- .../models/service_organization.rs | 2 +- .../models/service_type.rs | 2 +- .../models/tes_create_task_response.rs | 2 +- .../models/tes_executor.rs | 2 +- .../models/tes_executor_log.rs | 2 +- .../models/tes_file_type.rs | 2 +- .../models/tes_input.rs | 2 +- .../models/tes_list_tasks_response.rs | 2 +- .../models/tes_output.rs | 2 +- .../models/tes_output_file_log.rs | 2 +- .../models/tes_resources.rs | 2 +- .../models/tes_service_info.rs | 2 +- .../models/tes_service_type.rs | 2 +- .../models/tes_state.rs | 2 +- .../models/tes_task.rs | 2 +- .../models/tes_task_log.rs | 2 +- lib/src/task_execution_service/tes.rs | 123 +++++++++++++ lib/src/tes/tes.rs | 118 ------------ lib/src/transport.rs | 173 ++++++++++++++++++ 30 files changed, 467 insertions(+), 274 deletions(-) delete mode 100644 lib/src/service.rs create mode 100644 lib/src/serviceinfo/models/mod.rs create mode 100644 lib/src/serviceinfo/models/service.rs create mode 100644 lib/src/serviceinfo/models/service_organization.rs create mode 100644 lib/src/serviceinfo/models/service_type.rs create mode 100644 lib/src/serviceinfo/serviceinfo.rs rename lib/src/{tes => task_execution_service}/configuration.rs (100%) rename lib/src/{tes => task_execution_service}/mod.rs (100%) rename lib/src/{tes => task_execution_service}/models/mod.rs (100%) rename lib/src/{tes => task_execution_service}/models/service.rs (99%) rename lib/src/{tes => task_execution_service}/models/service_organization.rs (98%) rename lib/src/{tes => task_execution_service}/models/service_type.rs (98%) rename lib/src/{tes => task_execution_service}/models/tes_create_task_response.rs (98%) rename lib/src/{tes => task_execution_service}/models/tes_executor.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_executor_log.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_file_type.rs (98%) rename lib/src/{tes => task_execution_service}/models/tes_input.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_list_tasks_response.rs (98%) rename lib/src/{tes => task_execution_service}/models/tes_output.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_output_file_log.rs (98%) rename lib/src/{tes => task_execution_service}/models/tes_resources.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_service_info.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_service_type.rs (98%) rename lib/src/{tes => task_execution_service}/models/tes_state.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_task.rs (99%) rename lib/src/{tes => task_execution_service}/models/tes_task_log.rs (99%) create mode 100644 lib/src/task_execution_service/tes.rs delete mode 100644 lib/src/tes/tes.rs create mode 100644 lib/src/transport.rs diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 42bdfae..7d32e95 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -9,5 +9,5 @@ extern crate url; extern crate reqwest; -pub mod service; -pub mod tes; +pub mod transport; +pub mod task_execution_service; diff --git a/lib/src/service.rs b/lib/src/service.rs deleted file mode 100644 index 8a55706..0000000 --- a/lib/src/service.rs +++ /dev/null @@ -1,137 +0,0 @@ -use reqwest::{Client, Response}; -use serde::Serialize; -use serde_json::Value; -use std::error::Error; -use std::fmt; - - -use crate::{tes::ResponseContent, tes::models}; - -pub enum CreateTaskError { - UnknownValue(serde_json::Value), -} - -#[derive(Debug)] -struct MyError { - message: String, -} - -impl MyError { - fn new(message: String) -> MyError { - MyError { - message, - } - } -} - -impl fmt::Display for MyError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.message) - } -} - -impl Error for MyError {} - -#[derive(Debug)] -pub struct Service { - pub base_url: String, - pub client: Client, - pub username: Option, - pub password: Option, - pub token: Option, -} - -impl Service { - pub fn new(base_url: String, username: Option, password: Option, token: Option) -> Self { - Service { - base_url, - client: Client::new(), - username, - password, - token, - } - } - - pub async fn request( - &self, - method: reqwest::Method, - endpoint: &str, - data: Option, - params: Option, - ) -> Result> { - let mut local_var_req_builder = self.client.request(method, endpoint); - - if let Some(ref local_var_user_agent) = self.username { - local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); - } - - local_var_req_builder = local_var_req_builder.json(&data); - - let local_var_req = local_var_req_builder.build()?; - let local_var_resp = self.client.execute(local_var_req).await?; - - let local_var_status = local_var_resp.status(); - let local_var_content = local_var_resp.text().await?; - - if local_var_status.is_success() { - Ok(local_var_content) - } else { - Err(Box::new(MyError::new(local_var_content))) - - } - } - -} -#[cfg(test)] -mod tests { - use crate::service::Service; - use reqwest::Method; - use serde_json::json; - use mockito::{mock, Matcher}; - - #[tokio::test] - async fn test_request_success() { - let base_url = &mockito::server_url(); - let _m = mock("GET", "/test") - .with_status(200) - .with_header("content-type", "application/json") - .with_body(r#"{"message": "success"}"#) - .create(); - - let service = Service::new(base_url.clone(), None, None, None); - - let response = service.request( - Method::GET, - &format!("{}/test", base_url), - None, - None, - ).await; - - assert!(response.is_ok()); - let body = response.unwrap(); - assert_eq!(body, r#"{"message": "success"}"#); - } - - #[tokio::test] - async fn test_request_failure() { - let base_url = &mockito::server_url(); - let _m = mock("GET", "/test") - .with_status(404) - .with_header("content-type", "application/json") - .with_body(r#"{"message": "not found"}"#) - .create(); - - let service = Service::new(base_url.clone(), None, None, None); - - let response = service.request( - Method::GET, - &format!("{}/test", base_url), - None, - None, - ).await; - - assert!(response.is_err()); - let error = response.err().unwrap(); - assert_eq!(error.to_string(), r#"{"message": "not found"}"#); - } -} \ No newline at end of file diff --git a/lib/src/serviceinfo/models/mod.rs b/lib/src/serviceinfo/models/mod.rs new file mode 100644 index 0000000..9aa6373 --- /dev/null +++ b/lib/src/serviceinfo/models/mod.rs @@ -0,0 +1,6 @@ +pub mod service; +pub use self::service::Service; +pub mod service_organization; +pub use self::service_organization::ServiceOrganization; +pub mod service_type; +pub use self::service_type::ServiceType; diff --git a/lib/src/serviceinfo/models/service.rs b/lib/src/serviceinfo/models/service.rs new file mode 100644 index 0000000..51451ed --- /dev/null +++ b/lib/src/serviceinfo/models/service.rs @@ -0,0 +1,67 @@ +/* + * GA4GH service-info API specification + * + * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). + * + * The version of the OpenAPI document: 1.0.0 + * Contact: ga4gh-discovery-networks@ga4gh.org + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// Service : GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Service { + /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. + #[serde(rename = "id")] + pub id: String, + /// Name of this service. Should be human readable. + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "type")] + pub r#type: Box, + /// Description of the service. Should be human readable and provide information about the service. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "organization")] + pub organization: Box, + /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). + #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] + pub contact_url: Option, + /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. + #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] + pub documentation_url: Option, + /// Timestamp describing when the service was first deployed and available (RFC 3339 format) + #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] + pub created_at: Option, + /// Timestamp describing when the service was last updated (RFC 3339 format) + #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] + pub updated_at: Option, + /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option, + /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. + #[serde(rename = "version")] + pub version: String, +} + +impl Service { + /// GA4GH service + pub fn new(id: String, name: String, r#type: models::ServiceType, organization: models::ServiceOrganization, version: String) -> Service { + Service { + id, + name, + r#type: Box::new(r#type), + description: None, + organization: Box::new(organization), + contact_url: None, + documentation_url: None, + created_at: None, + updated_at: None, + environment: None, + version, + } + } +} + diff --git a/lib/src/serviceinfo/models/service_organization.rs b/lib/src/serviceinfo/models/service_organization.rs new file mode 100644 index 0000000..64d4609 --- /dev/null +++ b/lib/src/serviceinfo/models/service_organization.rs @@ -0,0 +1,33 @@ +/* + * GA4GH service-info API specification + * + * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). + * + * The version of the OpenAPI document: 1.0.0 + * Contact: ga4gh-discovery-networks@ga4gh.org + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// ServiceOrganization : Organization providing the service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceOrganization { + /// Name of the organization responsible for the service + #[serde(rename = "name")] + pub name: String, + /// URL of the website of the organization (RFC 3986 format) + #[serde(rename = "url")] + pub url: String, +} + +impl ServiceOrganization { + /// Organization providing the service + pub fn new(name: String, url: String) -> ServiceOrganization { + ServiceOrganization { + name, + url, + } + } +} + diff --git a/lib/src/serviceinfo/models/service_type.rs b/lib/src/serviceinfo/models/service_type.rs new file mode 100644 index 0000000..ac2ff98 --- /dev/null +++ b/lib/src/serviceinfo/models/service_type.rs @@ -0,0 +1,37 @@ +/* + * GA4GH service-info API specification + * + * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). + * + * The version of the OpenAPI document: 1.0.0 + * Contact: ga4gh-discovery-networks@ga4gh.org + * Generated by: https://openapi-generator.tech + */ + +use crate::models; + +/// ServiceType : Type of a GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceType { + /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). + #[serde(rename = "group")] + pub group: String, + /// Name of the API or GA4GH specification implemented. Official GA4GH types should be assigned as part of standards approval process. Custom artifacts are supported. + #[serde(rename = "artifact")] + pub artifact: String, + /// Version of the API or specification. GA4GH specifications use semantic versioning. + #[serde(rename = "version")] + pub version: String, +} + +impl ServiceType { + /// Type of a GA4GH service + pub fn new(group: String, artifact: String, version: String) -> ServiceType { + ServiceType { + group, + artifact, + version, + } + } +} + diff --git a/lib/src/serviceinfo/serviceinfo.rs b/lib/src/serviceinfo/serviceinfo.rs new file mode 100644 index 0000000..0f1cb1c --- /dev/null +++ b/lib/src/serviceinfo/serviceinfo.rs @@ -0,0 +1,9 @@ + + +// pub struct ServiceInfo { +// transport: Transport; +// } + +// impl ServiceInfo { + +// } \ No newline at end of file diff --git a/lib/src/tes/configuration.rs b/lib/src/task_execution_service/configuration.rs similarity index 100% rename from lib/src/tes/configuration.rs rename to lib/src/task_execution_service/configuration.rs diff --git a/lib/src/tes/mod.rs b/lib/src/task_execution_service/mod.rs similarity index 100% rename from lib/src/tes/mod.rs rename to lib/src/task_execution_service/mod.rs diff --git a/lib/src/tes/models/mod.rs b/lib/src/task_execution_service/models/mod.rs similarity index 100% rename from lib/src/tes/models/mod.rs rename to lib/src/task_execution_service/models/mod.rs diff --git a/lib/src/tes/models/service.rs b/lib/src/task_execution_service/models/service.rs similarity index 99% rename from lib/src/tes/models/service.rs rename to lib/src/task_execution_service/models/service.rs index 0fd520f..83c22fe 100644 --- a/lib/src/tes/models/service.rs +++ b/lib/src/task_execution_service/models/service.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// Service : GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/service_organization.rs b/lib/src/task_execution_service/models/service_organization.rs similarity index 98% rename from lib/src/tes/models/service_organization.rs rename to lib/src/task_execution_service/models/service_organization.rs index e38091c..01b8e08 100644 --- a/lib/src/tes/models/service_organization.rs +++ b/lib/src/task_execution_service/models/service_organization.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// ServiceOrganization : Organization providing the service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/service_type.rs b/lib/src/task_execution_service/models/service_type.rs similarity index 98% rename from lib/src/tes/models/service_type.rs rename to lib/src/task_execution_service/models/service_type.rs index 3dee78f..2b8ecab 100644 --- a/lib/src/tes/models/service_type.rs +++ b/lib/src/task_execution_service/models/service_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// ServiceType : Type of a GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_create_task_response.rs b/lib/src/task_execution_service/models/tes_create_task_response.rs similarity index 98% rename from lib/src/tes/models/tes_create_task_response.rs rename to lib/src/task_execution_service/models/tes_create_task_response.rs index d02f9bd..f4f40b9 100644 --- a/lib/src/tes/models/tes_create_task_response.rs +++ b/lib/src/task_execution_service/models/tes_create_task_response.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesCreateTaskResponse : CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_executor.rs b/lib/src/task_execution_service/models/tes_executor.rs similarity index 99% rename from lib/src/tes/models/tes_executor.rs rename to lib/src/task_execution_service/models/tes_executor.rs index 8cbbe17..2f687ef 100644 --- a/lib/src/tes/models/tes_executor.rs +++ b/lib/src/task_execution_service/models/tes_executor.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesExecutor : Executor describes a command to be executed, and its environment. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_executor_log.rs b/lib/src/task_execution_service/models/tes_executor_log.rs similarity index 99% rename from lib/src/tes/models/tes_executor_log.rs rename to lib/src/task_execution_service/models/tes_executor_log.rs index bbf7173..0466f2b 100644 --- a/lib/src/tes/models/tes_executor_log.rs +++ b/lib/src/task_execution_service/models/tes_executor_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesExecutorLog : ExecutorLog describes logging information related to an Executor. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_file_type.rs b/lib/src/task_execution_service/models/tes_file_type.rs similarity index 98% rename from lib/src/tes/models/tes_file_type.rs rename to lib/src/task_execution_service/models/tes_file_type.rs index cc794eb..05e1296 100644 --- a/lib/src/tes/models/tes_file_type.rs +++ b/lib/src/task_execution_service/models/tes_file_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesFileType : Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. /// Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. diff --git a/lib/src/tes/models/tes_input.rs b/lib/src/task_execution_service/models/tes_input.rs similarity index 99% rename from lib/src/tes/models/tes_input.rs rename to lib/src/task_execution_service/models/tes_input.rs index e36358a..37a377b 100644 --- a/lib/src/tes/models/tes_input.rs +++ b/lib/src/task_execution_service/models/tes_input.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesInput : Input describes Task input files. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_list_tasks_response.rs b/lib/src/task_execution_service/models/tes_list_tasks_response.rs similarity index 98% rename from lib/src/tes/models/tes_list_tasks_response.rs rename to lib/src/task_execution_service/models/tes_list_tasks_response.rs index a15f832..7a3eb77 100644 --- a/lib/src/tes/models/tes_list_tasks_response.rs +++ b/lib/src/task_execution_service/models/tes_list_tasks_response.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesListTasksResponse : ListTasksResponse describes a response from the ListTasks endpoint. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_output.rs b/lib/src/task_execution_service/models/tes_output.rs similarity index 99% rename from lib/src/tes/models/tes_output.rs rename to lib/src/task_execution_service/models/tes_output.rs index 6afd91c..a1602b8 100644 --- a/lib/src/tes/models/tes_output.rs +++ b/lib/src/task_execution_service/models/tes_output.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesOutput : Output describes Task output files. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_output_file_log.rs b/lib/src/task_execution_service/models/tes_output_file_log.rs similarity index 98% rename from lib/src/tes/models/tes_output_file_log.rs rename to lib/src/task_execution_service/models/tes_output_file_log.rs index ccfe0dc..64c0717 100644 --- a/lib/src/tes/models/tes_output_file_log.rs +++ b/lib/src/task_execution_service/models/tes_output_file_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesOutputFileLog : OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_resources.rs b/lib/src/task_execution_service/models/tes_resources.rs similarity index 99% rename from lib/src/tes/models/tes_resources.rs rename to lib/src/task_execution_service/models/tes_resources.rs index 991aff7..95d8254 100644 --- a/lib/src/tes/models/tes_resources.rs +++ b/lib/src/task_execution_service/models/tes_resources.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesResources : Resources describes the resources requested by a task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_service_info.rs b/lib/src/task_execution_service/models/tes_service_info.rs similarity index 99% rename from lib/src/tes/models/tes_service_info.rs rename to lib/src/task_execution_service/models/tes_service_info.rs index 4a8196a..7486c36 100644 --- a/lib/src/tes/models/tes_service_info.rs +++ b/lib/src/task_execution_service/models/tes_service_info.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] pub struct TesServiceInfo { diff --git a/lib/src/tes/models/tes_service_type.rs b/lib/src/task_execution_service/models/tes_service_type.rs similarity index 98% rename from lib/src/tes/models/tes_service_type.rs rename to lib/src/task_execution_service/models/tes_service_type.rs index 81be8ae..eb1151f 100644 --- a/lib/src/tes/models/tes_service_type.rs +++ b/lib/src/task_execution_service/models/tes_service_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] pub struct TesServiceType { diff --git a/lib/src/tes/models/tes_state.rs b/lib/src/task_execution_service/models/tes_state.rs similarity index 99% rename from lib/src/tes/models/tes_state.rs rename to lib/src/task_execution_service/models/tes_state.rs index 1dfd913..a701757 100644 --- a/lib/src/tes/models/tes_state.rs +++ b/lib/src/task_execution_service/models/tes_state.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesState : Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. /// Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. diff --git a/lib/src/tes/models/tes_task.rs b/lib/src/task_execution_service/models/tes_task.rs similarity index 99% rename from lib/src/tes/models/tes_task.rs rename to lib/src/task_execution_service/models/tes_task.rs index 7b27e8a..8d57ef9 100644 --- a/lib/src/tes/models/tes_task.rs +++ b/lib/src/task_execution_service/models/tes_task.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesTask : Task describes an instance of a task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/tes/models/tes_task_log.rs b/lib/src/task_execution_service/models/tes_task_log.rs similarity index 99% rename from lib/src/tes/models/tes_task_log.rs rename to lib/src/task_execution_service/models/tes_task_log.rs index eb8a551..a349022 100644 --- a/lib/src/tes/models/tes_task_log.rs +++ b/lib/src/task_execution_service/models/tes_task_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::tes::models; +use crate::task_execution_service::models; /// TesTaskLog : TaskLog describes logging information related to a Task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/tes.rs b/lib/src/task_execution_service/tes.rs new file mode 100644 index 0000000..c8be04b --- /dev/null +++ b/lib/src/task_execution_service/tes.rs @@ -0,0 +1,123 @@ +use reqwest; + +use crate::{task_execution_service::{models, ResponseContent}, transport}; +use super::{Error, configuration}; +use crate::transport::Transport; +use serde_json::json; +use crate::task_execution_service::models::TesCreateTaskResponse; + + +// Defining service class +pub struct Tes<'a> { + transport: &'a Transport, // http client essentially + // service_info: // service model +} +/// struct for passing parameters to the method [`create_task`] +#[derive(Clone, Debug)] +pub struct CreateTaskParams { + pub body: models::TesTask +} + +/// struct for typed errors of method [`create_task`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum CreateTaskError { + UnknownValue(serde_json::Value), +} + +impl<'a> Tes<'a> { + pub fn new(transport: &'a Transport) -> Self { + // todo retrieve serviceinfo (incl the version), double check that it's TES + // service => transport + Tes { transport } + } + + /// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. + // pub async fn create(&self, configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { + pub async fn create(&self, transport: &transport::Transport, params: CreateTaskParams) { + let local_var_configuration = transport; + + // unbox the parameters + let body = params.body; + + let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); + let endpoint = local_var_uri_str.as_str(); + let response = self.transport.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None).await; + + match response { + Ok(content) => { + // Handle the successful response + // let content = &response.text().await?; + // let task_response: TesCreateTaskResponse = serde_json::from_str(&content)?; + println!("Success; {}", content); // TODO log functions + // Ok(task_response) + }, + Err(e) => { + // Err(CreateTaskError::from(e)) + // Handle the error + eprintln!("Error: {}", e); + // You can also process the error as needed + }, + } + // let status = response.status(); + + // let content = response.text().await?; + + // if !status.is_success() { + // let error_value: serde_json::Value = serde_json::from_str(&content)?; + // return Err(Error::ResponseError(ResponseContent { + // status, + // content: CreateTaskError::UnknownValue(error_value), + // })); + // } + + // let response_data: TesCreateTaskResponse = serde_json::from_str(&content)?; + // Ok(response_data) + + } + + // TODO: pub fn status() + + // TODO: pub fn list() +} + +#[cfg(test)] +mod tests { + use reqwest::header::TRAILER; + + use super::*; + use crate::task_execution_service::configuration::Configuration; + use crate::task_execution_service::tes::reqwest::Client; + use crate::task_execution_service::models::TesTask; + + #[tokio::test] + async fn test_create_task() { + let client_tes = Client::new(); + + // Define the configuration + let transport = Transport { + base_path: "http://localhost:8000".to_string(), + user_agent: None, + client: client_tes.clone(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None, + password: None + }; + + // Load the TesTask JSON file + let task_json = std::fs::read_to_string("/home/aarav/dev/ga4gh-sdk/lib/sample/grape.tes").expect("Unable to read file"); + let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); + + + let tes = Tes::new(&transport); + + // Create the parameters + let params = CreateTaskParams { body: task }; + + // Call the create_task method + let result = tes.create(&transport, params).await; + println!("{:?}", result); + } +} \ No newline at end of file diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs deleted file mode 100644 index 9e8b33a..0000000 --- a/lib/src/tes/tes.rs +++ /dev/null @@ -1,118 +0,0 @@ -use reqwest; - -use crate::{tes::ResponseContent, tes::models}; -use super::{Error, configuration}; -use crate::service::Service; -use serde_json::json; -use crate::tes::models::TesCreateTaskResponse; - - -// Defining service class -pub struct Tes { - service: Service, -} - -/// struct for passing parameters to the method [`create_task`] -#[derive(Clone, Debug)] -pub struct CreateTaskParams { - pub body: models::TesTask -} - -/// struct for typed errors of method [`create_task`] -#[derive(Debug, Clone, Serialize, Deserialize)] -#[serde(untagged)] -pub enum CreateTaskError { - UnknownValue(serde_json::Value), -} - -impl Tes { - pub fn new(service: Service) -> Self { - Tes { service } - } - - /// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. - // pub async fn create_task(&self, configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { - pub async fn create_task(&self, configuration: &configuration::Configuration, params: CreateTaskParams) { - let local_var_configuration = configuration; - - // unbox the parameters - let body = params.body; - - let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); - let endpoint = local_var_uri_str.as_str(); - let response = self.service.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None).await; - - - // if !local_var_status.is_client_error() && !local_var_status.is_server_error() { - // serde_json::from_str(&local_var_content).map_err(Error::from) - // } else { - // let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); - // let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; - // Err(Error::ResponseError(local_var_error)) - // } - - - - match response { - Ok(content) => { - // Handle the successful response - println!("Success: {}", content); - // You can also process the content as needed - }, - Err(e) => { - // Handle the error - eprintln!("Error: {}", e); - // You can also process the error as needed - }, - } - - } - - -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::tes::configuration::Configuration; - use crate::tes::tes::reqwest::Client; - use crate::tes::models::TesTask; - - #[tokio::test] - async fn test_create_task() { - let client_tes = Client::new(); - - // Define the configuration - let config = Configuration { - base_path: "http://localhost:8000".to_string(), - user_agent: None, - client: client_tes.clone(), - basic_auth: None, - oauth_access_token: None, - bearer_access_token: None, - api_key: None - }; - - // Load the TesTask JSON file - let task_json = std::fs::read_to_string("/home/aarav/dev/ga4gh-sdk/lib/sample/grape.tes").expect("Unable to read file"); - let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); - - // Create the service and Tes instance - let service = Service { - base_url: "http://localhost:8000".to_string(), - client: client_tes.clone(), - username: None, - password: None, - token: None, - - }; - let tes = Tes::new(service); - - // Create the parameters - let params = CreateTaskParams { body: task }; - - // Call the create_task method - let result = tes.create_task(&config, params).await; - println!("{:?}", result); - } -} \ No newline at end of file diff --git a/lib/src/transport.rs b/lib/src/transport.rs new file mode 100644 index 0000000..db97cde --- /dev/null +++ b/lib/src/transport.rs @@ -0,0 +1,173 @@ +use reqwest::{Client, Response}; +use serde::Serialize; +use serde_json::Value; +use std::error::Error; +use std::fmt; + + +use crate::{task_execution_service::ResponseContent, task_execution_service::models}; + +pub enum CreateTaskError { + UnknownValue(serde_json::Value), +} + +#[derive(Debug)] +struct MyError { + message: String, +} + +impl MyError { + fn new(message: String) -> MyError { + MyError { + message, + } + } +} + +impl fmt::Display for MyError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.message) + } +} + +impl Error for MyError {} + + +#[derive(Debug, Clone)] +pub struct Transport { + pub base_path: String, + pub user_agent: Option, + pub client: reqwest::Client, + pub basic_auth: Option, + pub oauth_access_token: Option, + pub bearer_access_token: Option, + pub api_key: Option, + pub password: Option, //CHECK IF REQUIRED +} + +pub type BasicAuth = (String, Option); + +#[derive(Debug, Clone)] +pub struct ApiKey { + pub prefix: Option, + pub key: String, +} + + + +impl Transport { + pub fn new(base_path: String, user_agent: Option, password: Option, bearer_access_token: Option) -> Self { + Transport { + base_path, + user_agent, + client: Client::new(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token, + api_key: None, + password, + } + } + + pub async fn request( + &self, + method: reqwest::Method, + endpoint: &str, + data: Option, + _params: Option, // CHECK IF IT CAN BE USED ANYWHERE/ How to use it + ) -> Result> { + let mut req_builder = self.client.request(method, endpoint); + + if let Some(ref user_agent) = self.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + req_builder = req_builder.json(&data); + // req_builder = req_builder.json(¶ms); + + let req = req_builder.build()?; + let resp = self.client.execute(req).await?; + + let status = resp.status(); + let content = resp.text().await?; + + if status.is_success() { + Ok(content) + } else { + Err(Box::new(MyError::new(content))) + } + } + +} + + +impl Default for Transport { + fn default() -> Self { + Transport { + base_path: "/ga4gh/tes/v1".to_owned(), + user_agent: Some("OpenAPI-Generator/1.1.0/rust".to_owned()), + client: reqwest::Client::new(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None, + password: None, + } + } +} + + + +#[cfg(test)] +mod tests { + use crate::transport::Transport; + use reqwest::Method; + use serde_json::json; + use mockito::{mock, Matcher}; + + #[tokio::test] + async fn test_request_success() { + let base_url = &mockito::server_url(); + let _m = mock("GET", "/test") + .with_status(200) + .with_header("content-type", "application/json") + .with_body(r#"{"message": "success"}"#) + .create(); + + let transport = Transport::new(base_url.clone(), None, None, None); + + let response = transport.request( + Method::GET, + &format!("{}/test", base_url), + None, + None, + ).await; + + assert!(response.is_ok()); + let body = response.unwrap(); + assert_eq!(body, r#"{"message": "success"}"#); + } + + #[tokio::test] + async fn test_request_failure() { + let base_url = &mockito::server_url(); + let _m = mock("GET", "/test") + .with_status(404) + .with_header("content-type", "application/json") + .with_body(r#"{"message": "not found"}"#) + .create(); + + let transport = Transport::new(base_url.clone(), None, None, None); + + let response = transport.request( + Method::GET, + &format!("{}/test", base_url), + None, + None, + ).await; + + assert!(response.is_err()); + let error = response.err().unwrap(); + assert_eq!(error.to_string(), r#"{"message": "not found"}"#); + } +} \ No newline at end of file From 4e5c8dcc54273de441c3f1e9cb695459a21ac1bd Mon Sep 17 00:00:00 2001 From: aaravm Date: Sun, 16 Jun 2024 21:45:54 +0530 Subject: [PATCH 11/92] merged configuration and service class --- .../task_execution_service/configuration.rs | 52 ------------------- lib/src/task_execution_service/mod.rs | 1 - lib/src/task_execution_service/tes.rs | 8 ++- 3 files changed, 3 insertions(+), 58 deletions(-) delete mode 100644 lib/src/task_execution_service/configuration.rs diff --git a/lib/src/task_execution_service/configuration.rs b/lib/src/task_execution_service/configuration.rs deleted file mode 100644 index bc7b4fe..0000000 --- a/lib/src/task_execution_service/configuration.rs +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - - - -#[derive(Debug, Clone)] -pub struct Configuration { - pub base_path: String, - pub user_agent: Option, - pub client: reqwest::Client, - pub basic_auth: Option, - pub oauth_access_token: Option, - pub bearer_access_token: Option, - pub api_key: Option, - // TODO: take an oauth2 token source, similar to the go one -} - -pub type BasicAuth = (String, Option); - -#[derive(Debug, Clone)] -pub struct ApiKey { - pub prefix: Option, - pub key: String, -} - - -impl Configuration { - pub fn new() -> Configuration { - Configuration::default() - } -} - -impl Default for Configuration { - fn default() -> Self { - Configuration { - base_path: "/ga4gh/tes/v1".to_owned(), - user_agent: Some("OpenAPI-Generator/1.1.0/rust".to_owned()), - client: reqwest::Client::new(), - basic_auth: None, - oauth_access_token: None, - bearer_access_token: None, - api_key: None, - } - } -} \ No newline at end of file diff --git a/lib/src/task_execution_service/mod.rs b/lib/src/task_execution_service/mod.rs index f99ad5b..c1e2ce1 100644 --- a/lib/src/task_execution_service/mod.rs +++ b/lib/src/task_execution_service/mod.rs @@ -91,5 +91,4 @@ pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String } pub mod tes; -pub mod configuration; pub mod models; \ No newline at end of file diff --git a/lib/src/task_execution_service/tes.rs b/lib/src/task_execution_service/tes.rs index c8be04b..0dff7c4 100644 --- a/lib/src/task_execution_service/tes.rs +++ b/lib/src/task_execution_service/tes.rs @@ -1,7 +1,7 @@ use reqwest; use crate::{task_execution_service::{models, ResponseContent}, transport}; -use super::{Error, configuration}; +use super::Error; use crate::transport::Transport; use serde_json::json; use crate::task_execution_service::models::TesCreateTaskResponse; @@ -33,7 +33,7 @@ impl<'a> Tes<'a> { } /// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. - // pub async fn create(&self, configuration: &configuration::Configuration, params: CreateTaskParams) -> Result> { + // pub async fn create(&self, transport: &transport::Transport, params: CreateTaskParams) -> Result> { pub async fn create(&self, transport: &transport::Transport, params: CreateTaskParams) { let local_var_configuration = transport; @@ -86,7 +86,6 @@ mod tests { use reqwest::header::TRAILER; use super::*; - use crate::task_execution_service::configuration::Configuration; use crate::task_execution_service::tes::reqwest::Client; use crate::task_execution_service::models::TesTask; @@ -105,9 +104,8 @@ mod tests { api_key: None, password: None }; - // Load the TesTask JSON file - let task_json = std::fs::read_to_string("/home/aarav/dev/ga4gh-sdk/lib/sample/grape.tes").expect("Unable to read file"); + let task_json = std::fs::read_to_string("lib/sample/grape.tes").expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); From ce11ae10f9908b1f3ee069b6cb7da965d3198999 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 17 Jun 2024 03:31:28 +0400 Subject: [PATCH 12/92] refactoring --- .gitignore | 1 + Cargo.toml | 3 + lib/src/configuration.rs | 45 ++++ lib/src/lib.rs | 4 +- lib/src/serviceinfo/mod.rs | 15 ++ lib/src/task_execution_service/mod.rs | 94 -------- lib/src/tes/mod.rs | 220 +++++++++++++++++ .../models/mod.rs | 0 .../models/service.rs | 2 +- .../models/service_organization.rs | 2 +- .../models/service_type.rs | 2 +- .../models/tes_create_task_response.rs | 2 +- .../models/tes_executor.rs | 2 +- .../models/tes_executor_log.rs | 2 +- .../models/tes_file_type.rs | 2 +- .../models/tes_input.rs | 2 +- .../models/tes_list_tasks_response.rs | 2 +- .../models/tes_output.rs | 2 +- .../models/tes_output_file_log.rs | 2 +- .../models/tes_resources.rs | 2 +- .../models/tes_service_info.rs | 2 +- .../models/tes_service_type.rs | 2 +- .../models/tes_state.rs | 2 +- .../models/tes_task.rs | 2 +- .../models/tes_task_log.rs | 2 +- .../{task_execution_service => tes}/tes.rs | 0 lib/src/transport.rs | 228 ++++++++---------- 27 files changed, 400 insertions(+), 244 deletions(-) create mode 100644 lib/src/configuration.rs create mode 100644 lib/src/serviceinfo/mod.rs delete mode 100644 lib/src/task_execution_service/mod.rs create mode 100644 lib/src/tes/mod.rs rename lib/src/{task_execution_service => tes}/models/mod.rs (100%) rename lib/src/{task_execution_service => tes}/models/service.rs (99%) rename lib/src/{task_execution_service => tes}/models/service_organization.rs (98%) rename lib/src/{task_execution_service => tes}/models/service_type.rs (98%) rename lib/src/{task_execution_service => tes}/models/tes_create_task_response.rs (98%) rename lib/src/{task_execution_service => tes}/models/tes_executor.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_executor_log.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_file_type.rs (98%) rename lib/src/{task_execution_service => tes}/models/tes_input.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_list_tasks_response.rs (98%) rename lib/src/{task_execution_service => tes}/models/tes_output.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_output_file_log.rs (98%) rename lib/src/{task_execution_service => tes}/models/tes_resources.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_service_info.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_service_type.rs (98%) rename lib/src/{task_execution_service => tes}/models/tes_state.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_task.rs (99%) rename lib/src/{task_execution_service => tes}/models/tes_task_log.rs (99%) rename lib/src/{task_execution_service => tes}/tes.rs (100%) diff --git a/.gitignore b/.gitignore index 1e7caa9..9b3d7e2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ Cargo.lock target/ +.vscode diff --git a/Cargo.toml b/Cargo.toml index 9793d35..fdb7988 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,9 @@ serde_derive = "^1.0" serde_json = "^1.0" url = "^2.2" uuid = { version = "^1.0", features = ["serde", "v4"] } +log = "0.4" +env_logger = "0.9" + [dependencies.reqwest] version = "^0.11" features = ["json", "multipart"] diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs new file mode 100644 index 0000000..b3a3f2d --- /dev/null +++ b/lib/src/configuration.rs @@ -0,0 +1,45 @@ + + +#[derive(Debug, Clone)] +pub struct ServiceConfiguration { + pub base_path: String, + pub user_agent: Option, + pub basic_auth: Option, + pub oauth_access_token: Option, + pub bearer_access_token: Option, + pub api_key: Option, + // TODO: take an oauth2 token source, similar to the go one +} + +pub type BasicAuth = (String, Option); + +#[derive(Debug, Clone)] +pub struct ApiKey { + pub prefix: Option, + pub key: String, +} + + +impl ServiceConfiguration { + pub fn new() -> ServiceConfiguration { + ServiceConfiguration::default() + } + + pub fn set_base_path(&mut self, base_path: &str) -> &mut Self { + self.base_path = base_path.to_string(); + self + } +} + +impl Default for ServiceConfiguration { + fn default() -> Self { + ServiceConfiguration { + base_path: "localhost".to_owned(), + user_agent: Some("GA4GH SDK".to_owned()), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None, + } + } +} \ No newline at end of file diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 7d32e95..27da2ce 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -9,5 +9,7 @@ extern crate url; extern crate reqwest; +pub mod tes; pub mod transport; -pub mod task_execution_service; +pub mod serviceinfo; +pub mod configuration; \ No newline at end of file diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs new file mode 100644 index 0000000..887a14b --- /dev/null +++ b/lib/src/serviceinfo/mod.rs @@ -0,0 +1,15 @@ +use crate::transport::Transport; +use crate::configuration::ServiceConfiguration; + +pub struct ServiceInfo { + transport: Transport, +} + +impl ServiceInfo { + pub fn new(config: &ServiceConfiguration) -> Self { + // todo: read service info from the server + ServiceInfo { + transport: Transport::new(&config.clone()), + } + } +} \ No newline at end of file diff --git a/lib/src/task_execution_service/mod.rs b/lib/src/task_execution_service/mod.rs deleted file mode 100644 index c1e2ce1..0000000 --- a/lib/src/task_execution_service/mod.rs +++ /dev/null @@ -1,94 +0,0 @@ -use std::error; -use std::fmt; - -#[derive(Debug, Clone)] -pub struct ResponseContent { - pub status: reqwest::StatusCode, - pub content: String, - pub entity: Option, -} - -#[derive(Debug)] -pub enum Error { - Reqwest(reqwest::Error), - Serde(serde_json::Error), - Io(std::io::Error), - ResponseError(ResponseContent), -} - -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let (module, e) = match self { - Error::Reqwest(e) => ("reqwest", e.to_string()), - Error::Serde(e) => ("serde", e.to_string()), - Error::Io(e) => ("IO", e.to_string()), - Error::ResponseError(e) => ("response", format!("status code {}", e.status)), - }; - write!(f, "error in {}: {}", module, e) - } -} - -impl error::Error for Error { - fn source(&self) -> Option<&(dyn error::Error + 'static)> { - Some(match self { - Error::Reqwest(e) => e, - Error::Serde(e) => e, - Error::Io(e) => e, - Error::ResponseError(_) => return None, - }) - } -} - -impl From for Error { - fn from(e: reqwest::Error) -> Self { - Error::Reqwest(e) - } -} - -impl From for Error { - fn from(e: serde_json::Error) -> Self { - Error::Serde(e) - } -} - -impl From for Error { - fn from(e: std::io::Error) -> Self { - Error::Io(e) - } -} - -pub fn urlencode>(s: T) -> String { - ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() -} - -pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { - if let serde_json::Value::Object(object) = value { - let mut params = vec![]; - - for (key, value) in object { - match value { - serde_json::Value::Object(_) => params.append(&mut parse_deep_object( - &format!("{}[{}]", prefix, key), - value, - )), - serde_json::Value::Array(array) => { - for (i, value) in array.iter().enumerate() { - params.append(&mut parse_deep_object( - &format!("{}[{}][{}]", prefix, key, i), - value, - )); - } - }, - serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), - _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), - } - } - - return params; - } - - unimplemented!("Only objects are supported with style=deepObject") -} - -pub mod tes; -pub mod models; \ No newline at end of file diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs new file mode 100644 index 0000000..154d5df --- /dev/null +++ b/lib/src/tes/mod.rs @@ -0,0 +1,220 @@ +pub mod models; +use crate::transport::Transport; +use serde_json::json; +use crate::serviceinfo::ServiceInfo; +use crate::configuration::ServiceConfiguration; +use crate::tes::models::TesTask; +use crate::tes::models::TesCreateTaskResponse; +use crate::tes::models::TesState; + +// *** +// should TES.create return Task? which in turn can do status() and other existing-task-related stuff +// instead of TES.status(task_id) we could do task.status() +pub struct Task { + id: String, +} + +impl Task { + pub fn new(id: String) -> Self { + Task { + id: id, + } + } + + pub fn status(&self) -> Result> { + Ok(TesState::Running) + } +} + +pub struct TES { + config: ServiceConfiguration, + service_info: ServiceInfo, + transport: Transport, +} +// *** see question above + +impl TES { + pub fn new(config: &ServiceConfiguration) -> Self { + // todo double check that it's really a TES using serviceinfo + TES { + config: config.clone(), + transport: Transport::new(config), + service_info: ServiceInfo::new(config) + } + } + + pub async fn create(&self, task: TesTask/*, params: models::TesTask*/) -> Result> { + // todo: version in url based on serviceinfo or user config + let url = format!("{}/ga4gh/tes/v1/tasks", self.config.base_path); + let response = self.transport.post(&url, json!(task)).await; + match response { + Ok(response_body) => { + match serde_json::from_str::(&response_body) { + Ok(tes_create_task_response) => Ok(tes_create_task_response), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) + }, + } + }, + Err(e) => { + log::error!("Error: {}", e); + Err(e.into()) + }, + } + } + + // pub async fn status(&self, task: &TesCreateTaskResponse) -> Result> { + pub async fn status(&self, task_id: &str, view: &str) -> Result> { + // ?? move to Task::status() + // todo: version in url based on serviceinfo or user config + let url = format!("{}/ga4gh/tes/v1/tasks/{}", self.config.base_path, task_id); + let params = [("view", view)]; + let params_value = serde_json::json!(params); + let response = self.transport.get(&url, Some(params_value)).await; + match response { + Ok(response_body) => { + match serde_json::from_str::(&response_body) { + Ok(tes_state) => Ok(tes_state), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) + }, + } + }, + Err(e) => { + log::error!("Error: {}", e); + Err(e.into()) + }, + } + } + + // TODO: pub fn list() +} + +#[cfg(test)] +mod tests { + use crate::tes::TES; + use crate::configuration::ServiceConfiguration; + use crate::tes::models::TesTask; + use crate::tes::models::TesCreateTaskResponse; + + async fn create_task() -> Result> { + let mut config = ServiceConfiguration::default(); + config.set_base_path("http://localhost:8080"); // expecting TES/Funnel, TODO autorun + let tes = TES::new(&config); + + let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); + let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); + + let task = tes.create(task).await?; + Ok(task.id) + } + + #[tokio::test] + async fn test_task_create() { + env_logger::init(); + + let task = create_task().await.expect("Failed to create task"); + assert!(!task.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + } + + #[tokio::test] + async fn test_task_status() { + env_logger::init(); + + let task = create_task().await.expect("Failed to create task"); + // Now use task to get the task status... + // todo: assert_eq!(task.status().await, which status?); + } +} + +// not sure if we need the code bellow, it was autogenerated by openapi-generator as i understand +// #[derive(Debug, Clone)] +// pub struct ResponseContent { +// pub status: reqwest::StatusCode, +// pub content: String, +// pub entity: Option, +// } + +// #[derive(Debug)] +// pub enum Error { +// Reqwest(reqwest::Error), +// Serde(serde_json::Error), +// Io(std::io::Error), +// ResponseError(ResponseContent), +// } + +// impl fmt::Display for Error { +// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { +// let (module, e) = match self { +// Error::Reqwest(e) => ("reqwest", e.to_string()), +// Error::Serde(e) => ("serde", e.to_string()), +// Error::Io(e) => ("IO", e.to_string()), +// Error::ResponseError(e) => ("response", format!("status code {}", e.status)), +// }; +// write!(f, "error in {}: {}", module, e) +// } +// } + +// impl error::Error for Error { +// fn source(&self) -> Option<&(dyn error::Error + 'static)> { +// Some(match self { +// Error::Reqwest(e) => e, +// Error::Serde(e) => e, +// Error::Io(e) => e, +// Error::ResponseError(_) => return None, +// }) +// } +// } + +// impl From for Error { +// fn from(e: reqwest::Error) -> Self { +// Error::Reqwest(e) +// } +// } + +// impl From for Error { +// fn from(e: serde_json::Error) -> Self { +// Error::Serde(e) +// } +// } + +// impl From for Error { +// fn from(e: std::io::Error) -> Self { +// Error::Io(e) +// } +// } + +// pub fn urlencode>(s: T) -> String { +// ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +// } + +// pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { +// if let serde_json::Value::Object(object) = value { +// let mut params = vec![]; + +// for (key, value) in object { +// match value { +// serde_json::Value::Object(_) => params.append(&mut parse_deep_object( +// &format!("{}[{}]", prefix, key), +// value, +// )), +// serde_json::Value::Array(array) => { +// for (i, value) in array.iter().enumerate() { +// params.append(&mut parse_deep_object( +// &format!("{}[{}][{}]", prefix, key, i), +// value, +// )); +// } +// }, +// serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), +// _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), +// } +// } + +// return params; +// } + +// unimplemented!("Only objects are supported with style=deepObject") +// } diff --git a/lib/src/task_execution_service/models/mod.rs b/lib/src/tes/models/mod.rs similarity index 100% rename from lib/src/task_execution_service/models/mod.rs rename to lib/src/tes/models/mod.rs diff --git a/lib/src/task_execution_service/models/service.rs b/lib/src/tes/models/service.rs similarity index 99% rename from lib/src/task_execution_service/models/service.rs rename to lib/src/tes/models/service.rs index 83c22fe..0fd520f 100644 --- a/lib/src/task_execution_service/models/service.rs +++ b/lib/src/tes/models/service.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// Service : GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/service_organization.rs b/lib/src/tes/models/service_organization.rs similarity index 98% rename from lib/src/task_execution_service/models/service_organization.rs rename to lib/src/tes/models/service_organization.rs index 01b8e08..e38091c 100644 --- a/lib/src/task_execution_service/models/service_organization.rs +++ b/lib/src/tes/models/service_organization.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// ServiceOrganization : Organization providing the service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/service_type.rs b/lib/src/tes/models/service_type.rs similarity index 98% rename from lib/src/task_execution_service/models/service_type.rs rename to lib/src/tes/models/service_type.rs index 2b8ecab..3dee78f 100644 --- a/lib/src/task_execution_service/models/service_type.rs +++ b/lib/src/tes/models/service_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// ServiceType : Type of a GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_create_task_response.rs b/lib/src/tes/models/tes_create_task_response.rs similarity index 98% rename from lib/src/task_execution_service/models/tes_create_task_response.rs rename to lib/src/tes/models/tes_create_task_response.rs index f4f40b9..d02f9bd 100644 --- a/lib/src/task_execution_service/models/tes_create_task_response.rs +++ b/lib/src/tes/models/tes_create_task_response.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesCreateTaskResponse : CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_executor.rs b/lib/src/tes/models/tes_executor.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_executor.rs rename to lib/src/tes/models/tes_executor.rs index 2f687ef..8cbbe17 100644 --- a/lib/src/task_execution_service/models/tes_executor.rs +++ b/lib/src/tes/models/tes_executor.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesExecutor : Executor describes a command to be executed, and its environment. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_executor_log.rs b/lib/src/tes/models/tes_executor_log.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_executor_log.rs rename to lib/src/tes/models/tes_executor_log.rs index 0466f2b..bbf7173 100644 --- a/lib/src/task_execution_service/models/tes_executor_log.rs +++ b/lib/src/tes/models/tes_executor_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesExecutorLog : ExecutorLog describes logging information related to an Executor. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_file_type.rs b/lib/src/tes/models/tes_file_type.rs similarity index 98% rename from lib/src/task_execution_service/models/tes_file_type.rs rename to lib/src/tes/models/tes_file_type.rs index 05e1296..cc794eb 100644 --- a/lib/src/task_execution_service/models/tes_file_type.rs +++ b/lib/src/tes/models/tes_file_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesFileType : Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. /// Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. diff --git a/lib/src/task_execution_service/models/tes_input.rs b/lib/src/tes/models/tes_input.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_input.rs rename to lib/src/tes/models/tes_input.rs index 37a377b..e36358a 100644 --- a/lib/src/task_execution_service/models/tes_input.rs +++ b/lib/src/tes/models/tes_input.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesInput : Input describes Task input files. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_list_tasks_response.rs b/lib/src/tes/models/tes_list_tasks_response.rs similarity index 98% rename from lib/src/task_execution_service/models/tes_list_tasks_response.rs rename to lib/src/tes/models/tes_list_tasks_response.rs index 7a3eb77..a15f832 100644 --- a/lib/src/task_execution_service/models/tes_list_tasks_response.rs +++ b/lib/src/tes/models/tes_list_tasks_response.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesListTasksResponse : ListTasksResponse describes a response from the ListTasks endpoint. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_output.rs b/lib/src/tes/models/tes_output.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_output.rs rename to lib/src/tes/models/tes_output.rs index a1602b8..6afd91c 100644 --- a/lib/src/task_execution_service/models/tes_output.rs +++ b/lib/src/tes/models/tes_output.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesOutput : Output describes Task output files. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_output_file_log.rs b/lib/src/tes/models/tes_output_file_log.rs similarity index 98% rename from lib/src/task_execution_service/models/tes_output_file_log.rs rename to lib/src/tes/models/tes_output_file_log.rs index 64c0717..ccfe0dc 100644 --- a/lib/src/task_execution_service/models/tes_output_file_log.rs +++ b/lib/src/tes/models/tes_output_file_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesOutputFileLog : OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_resources.rs b/lib/src/tes/models/tes_resources.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_resources.rs rename to lib/src/tes/models/tes_resources.rs index 95d8254..991aff7 100644 --- a/lib/src/task_execution_service/models/tes_resources.rs +++ b/lib/src/tes/models/tes_resources.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesResources : Resources describes the resources requested by a task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_service_info.rs b/lib/src/tes/models/tes_service_info.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_service_info.rs rename to lib/src/tes/models/tes_service_info.rs index 7486c36..4a8196a 100644 --- a/lib/src/task_execution_service/models/tes_service_info.rs +++ b/lib/src/tes/models/tes_service_info.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] pub struct TesServiceInfo { diff --git a/lib/src/task_execution_service/models/tes_service_type.rs b/lib/src/tes/models/tes_service_type.rs similarity index 98% rename from lib/src/task_execution_service/models/tes_service_type.rs rename to lib/src/tes/models/tes_service_type.rs index eb1151f..81be8ae 100644 --- a/lib/src/task_execution_service/models/tes_service_type.rs +++ b/lib/src/tes/models/tes_service_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] pub struct TesServiceType { diff --git a/lib/src/task_execution_service/models/tes_state.rs b/lib/src/tes/models/tes_state.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_state.rs rename to lib/src/tes/models/tes_state.rs index a701757..1dfd913 100644 --- a/lib/src/task_execution_service/models/tes_state.rs +++ b/lib/src/tes/models/tes_state.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesState : Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. /// Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. diff --git a/lib/src/task_execution_service/models/tes_task.rs b/lib/src/tes/models/tes_task.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_task.rs rename to lib/src/tes/models/tes_task.rs index 8d57ef9..7b27e8a 100644 --- a/lib/src/task_execution_service/models/tes_task.rs +++ b/lib/src/tes/models/tes_task.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesTask : Task describes an instance of a task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/models/tes_task_log.rs b/lib/src/tes/models/tes_task_log.rs similarity index 99% rename from lib/src/task_execution_service/models/tes_task_log.rs rename to lib/src/tes/models/tes_task_log.rs index a349022..eb8a551 100644 --- a/lib/src/task_execution_service/models/tes_task_log.rs +++ b/lib/src/tes/models/tes_task_log.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::task_execution_service::models; +use crate::tes::models; /// TesTaskLog : TaskLog describes logging information related to a Task. #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/task_execution_service/tes.rs b/lib/src/tes/tes.rs similarity index 100% rename from lib/src/task_execution_service/tes.rs rename to lib/src/tes/tes.rs diff --git a/lib/src/transport.rs b/lib/src/transport.rs index db97cde..f3b7222 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -3,90 +3,37 @@ use serde::Serialize; use serde_json::Value; use std::error::Error; use std::fmt; +use crate::configuration::ServiceConfiguration; +// note: could implement custom certs handling, such as in-TEE generated ephemerial certs -use crate::{task_execution_service::ResponseContent, task_execution_service::models}; - -pub enum CreateTaskError { - UnknownValue(serde_json::Value), -} - -#[derive(Debug)] -struct MyError { - message: String, -} - -impl MyError { - fn new(message: String) -> MyError { - MyError { - message, - } - } -} - -impl fmt::Display for MyError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.message) - } -} - -impl Error for MyError {} - - -#[derive(Debug, Clone)] pub struct Transport { - pub base_path: String, - pub user_agent: Option, - pub client: reqwest::Client, - pub basic_auth: Option, - pub oauth_access_token: Option, - pub bearer_access_token: Option, - pub api_key: Option, - pub password: Option, //CHECK IF REQUIRED + config: ServiceConfiguration, + client: reqwest::Client, } -pub type BasicAuth = (String, Option); - -#[derive(Debug, Clone)] -pub struct ApiKey { - pub prefix: Option, - pub key: String, -} - - - impl Transport { - pub fn new(base_path: String, user_agent: Option, password: Option, bearer_access_token: Option) -> Self { + pub fn new(config: &ServiceConfiguration) -> Self { Transport { - base_path, - user_agent, + config: config.clone(), client: Client::new(), - basic_auth: None, - oauth_access_token: None, - bearer_access_token, - api_key: None, - password, } } - pub async fn request( + async fn request( &self, method: reqwest::Method, endpoint: &str, data: Option, - _params: Option, // CHECK IF IT CAN BE USED ANYWHERE/ How to use it + params: Option, ) -> Result> { - let mut req_builder = self.client.request(method, endpoint); - - if let Some(ref user_agent) = self.user_agent { - req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); - } - - req_builder = req_builder.json(&data); - // req_builder = req_builder.json(¶ms); - - let req = req_builder.build()?; - let resp = self.client.execute(req).await?; + let resp = self.client + .request(method, endpoint) + .header(reqwest::header::USER_AGENT, self.config.user_agent.clone().unwrap_or_default()) + .json(&data) + .query(¶ms) + .send() + .await?; let status = resp.status(); let content = resp.text().await?; @@ -94,80 +41,97 @@ impl Transport { if status.is_success() { Ok(content) } else { - Err(Box::new(MyError::new(content))) + Err(Box::new(std::io::Error::new(std::io::ErrorKind::Other, content))) } } -} + pub async fn get(&self, endpoint: &str, params: Option) -> Result> { + self.request(reqwest::Method::GET, endpoint, None, params).await + } + pub async fn post(&self, endpoint: &str, data: Value) -> Result> { + self.request(reqwest::Method::POST, endpoint, Some(data), None).await + } -impl Default for Transport { - fn default() -> Self { - Transport { - base_path: "/ga4gh/tes/v1".to_owned(), - user_agent: Some("OpenAPI-Generator/1.1.0/rust".to_owned()), - client: reqwest::Client::new(), - basic_auth: None, - oauth_access_token: None, - bearer_access_token: None, - api_key: None, - password: None, - } + pub async fn put(&self, endpoint: &str, data: Value) -> Result> { + self.request(reqwest::Method::PUT, endpoint, Some(data), None).await } + + pub async fn delete(&self, endpoint: &str) -> Result> { + self.request(reqwest::Method::DELETE, endpoint, None, None).await + } + + // other HTTP methods can be added here } +// impl Default for Transport { +// fn default() -> Self { +// Transport { +// base_path: "/ga4gh/tes/v1".to_owned(), +// user_agent: Some("OpenAPI-Generator/1.1.0/rust".to_owned()), +// client: reqwest::Client::new(), +// basic_auth: None, +// oauth_access_token: None, +// bearer_access_token: None, +// api_key: None, +// password: None, +// } +// } +// } + + #[cfg(test)] mod tests { - use crate::transport::Transport; - use reqwest::Method; - use serde_json::json; - use mockito::{mock, Matcher}; - - #[tokio::test] - async fn test_request_success() { - let base_url = &mockito::server_url(); - let _m = mock("GET", "/test") - .with_status(200) - .with_header("content-type", "application/json") - .with_body(r#"{"message": "success"}"#) - .create(); - - let transport = Transport::new(base_url.clone(), None, None, None); - - let response = transport.request( - Method::GET, - &format!("{}/test", base_url), - None, - None, - ).await; - - assert!(response.is_ok()); - let body = response.unwrap(); - assert_eq!(body, r#"{"message": "success"}"#); - } - - #[tokio::test] - async fn test_request_failure() { - let base_url = &mockito::server_url(); - let _m = mock("GET", "/test") - .with_status(404) - .with_header("content-type", "application/json") - .with_body(r#"{"message": "not found"}"#) - .create(); - - let transport = Transport::new(base_url.clone(), None, None, None); - - let response = transport.request( - Method::GET, - &format!("{}/test", base_url), - None, - None, - ).await; - - assert!(response.is_err()); - let error = response.err().unwrap(); - assert_eq!(error.to_string(), r#"{"message": "not found"}"#); - } + // use crate::transport::Transport; + // use reqwest::Method; + // use serde_json::json; + // use mockito::{mock, Matcher}; + + // #[tokio::test] + // async fn test_request_success() { + // let base_url = &mockito::server_url(); + // let _m = mock("GET", "/test") + // .with_status(200) + // .with_header("content-type", "application/json") + // .with_body(r#"{"message": "success"}"#) + // .create(); + + // let transport = Transport::new(base_url.clone(), None, None, None); + + // let response = transport.request( + // Method::GET, + // &format!("{}/test", base_url), + // None, + // None, + // ).await; + + // assert!(response.is_ok()); + // let body = response.unwrap(); + // assert_eq!(body, r#"{"message": "success"}"#); + // } + + // #[tokio::test] + // async fn test_request_failure() { + // let base_url = &mockito::server_url(); + // let _m = mock("GET", "/test") + // .with_status(404) + // .with_header("content-type", "application/json") + // .with_body(r#"{"message": "not found"}"#) + // .create(); + + // let transport = Transport::new(base_url.clone(), None, None, None); + + // let response = transport.request( + // Method::GET, + // &format!("{}/test", base_url), + // None, + // None, + // ).await; + + // assert!(response.is_err()); + // let error = response.err().unwrap(); + // assert_eq!(error.to_string(), r#"{"message": "not found"}"#); + // } } \ No newline at end of file From 395b00a611bd3af6bf53f31d237e530a89b1197e Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 17 Jun 2024 13:50:28 +0400 Subject: [PATCH 13/92] tes.rs code moved to mod.rs to avoid import as ::tes::tes --- lib/src/tes/tes.rs | 121 --------------------------------------------- 1 file changed, 121 deletions(-) delete mode 100644 lib/src/tes/tes.rs diff --git a/lib/src/tes/tes.rs b/lib/src/tes/tes.rs deleted file mode 100644 index 0dff7c4..0000000 --- a/lib/src/tes/tes.rs +++ /dev/null @@ -1,121 +0,0 @@ -use reqwest; - -use crate::{task_execution_service::{models, ResponseContent}, transport}; -use super::Error; -use crate::transport::Transport; -use serde_json::json; -use crate::task_execution_service::models::TesCreateTaskResponse; - - -// Defining service class -pub struct Tes<'a> { - transport: &'a Transport, // http client essentially - // service_info: // service model -} -/// struct for passing parameters to the method [`create_task`] -#[derive(Clone, Debug)] -pub struct CreateTaskParams { - pub body: models::TesTask -} - -/// struct for typed errors of method [`create_task`] -#[derive(Debug, Clone, Serialize, Deserialize)] -#[serde(untagged)] -pub enum CreateTaskError { - UnknownValue(serde_json::Value), -} - -impl<'a> Tes<'a> { - pub fn new(transport: &'a Transport) -> Self { - // todo retrieve serviceinfo (incl the version), double check that it's TES - // service => transport - Tes { transport } - } - - /// Create a new task. The user provides a Task document, which the server uses as a basis and adds additional fields. - // pub async fn create(&self, transport: &transport::Transport, params: CreateTaskParams) -> Result> { - pub async fn create(&self, transport: &transport::Transport, params: CreateTaskParams) { - let local_var_configuration = transport; - - // unbox the parameters - let body = params.body; - - let local_var_uri_str = format!("{}/tasks", local_var_configuration.base_path); - let endpoint = local_var_uri_str.as_str(); - let response = self.transport.request(reqwest::Method::POST, endpoint, Some(serde_json::to_value(body).unwrap()), None).await; - - match response { - Ok(content) => { - // Handle the successful response - // let content = &response.text().await?; - // let task_response: TesCreateTaskResponse = serde_json::from_str(&content)?; - println!("Success; {}", content); // TODO log functions - // Ok(task_response) - }, - Err(e) => { - // Err(CreateTaskError::from(e)) - // Handle the error - eprintln!("Error: {}", e); - // You can also process the error as needed - }, - } - // let status = response.status(); - - // let content = response.text().await?; - - // if !status.is_success() { - // let error_value: serde_json::Value = serde_json::from_str(&content)?; - // return Err(Error::ResponseError(ResponseContent { - // status, - // content: CreateTaskError::UnknownValue(error_value), - // })); - // } - - // let response_data: TesCreateTaskResponse = serde_json::from_str(&content)?; - // Ok(response_data) - - } - - // TODO: pub fn status() - - // TODO: pub fn list() -} - -#[cfg(test)] -mod tests { - use reqwest::header::TRAILER; - - use super::*; - use crate::task_execution_service::tes::reqwest::Client; - use crate::task_execution_service::models::TesTask; - - #[tokio::test] - async fn test_create_task() { - let client_tes = Client::new(); - - // Define the configuration - let transport = Transport { - base_path: "http://localhost:8000".to_string(), - user_agent: None, - client: client_tes.clone(), - basic_auth: None, - oauth_access_token: None, - bearer_access_token: None, - api_key: None, - password: None - }; - // Load the TesTask JSON file - let task_json = std::fs::read_to_string("lib/sample/grape.tes").expect("Unable to read file"); - let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); - - - let tes = Tes::new(&transport); - - // Create the parameters - let params = CreateTaskParams { body: task }; - - // Call the create_task method - let result = tes.create(&transport, params).await; - println!("{:?}", result); - } -} \ No newline at end of file From b1c12fe6d988efe4f60e92006f62d8639ad22e9a Mon Sep 17 00:00:00 2001 From: aaravm Date: Tue, 18 Jun 2024 21:55:56 +0530 Subject: [PATCH 14/92] corrected tests in service.rs --- lib/src/configuration.rs | 19 +++++-- lib/src/serviceinfo/mod.rs | 4 +- lib/src/tes/mod.rs | 10 ++-- lib/src/transport.rs | 110 +++++++++++++++++++------------------ 4 files changed, 77 insertions(+), 66 deletions(-) diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs index b3a3f2d..2c5acab 100644 --- a/lib/src/configuration.rs +++ b/lib/src/configuration.rs @@ -1,7 +1,7 @@ #[derive(Debug, Clone)] -pub struct ServiceConfiguration { +pub struct Configuration { pub base_path: String, pub user_agent: Option, pub basic_auth: Option, @@ -20,9 +20,16 @@ pub struct ApiKey { } -impl ServiceConfiguration { - pub fn new() -> ServiceConfiguration { - ServiceConfiguration::default() +impl Configuration { + pub fn new(base_path: String, user_agent: Option, oauth_access_token: Option) -> Self { + Configuration { + base_path, + user_agent, + basic_auth: None, + oauth_access_token, + bearer_access_token: None, + api_key: None, + } } pub fn set_base_path(&mut self, base_path: &str) -> &mut Self { @@ -31,9 +38,9 @@ impl ServiceConfiguration { } } -impl Default for ServiceConfiguration { +impl Default for Configuration { fn default() -> Self { - ServiceConfiguration { + Configuration { base_path: "localhost".to_owned(), user_agent: Some("GA4GH SDK".to_owned()), basic_auth: None, diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 887a14b..883cf79 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -1,12 +1,12 @@ use crate::transport::Transport; -use crate::configuration::ServiceConfiguration; +use crate::configuration::Configuration; pub struct ServiceInfo { transport: Transport, } impl ServiceInfo { - pub fn new(config: &ServiceConfiguration) -> Self { + pub fn new(config: &Configuration) -> Self { // todo: read service info from the server ServiceInfo { transport: Transport::new(&config.clone()), diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 154d5df..2d00020 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -2,7 +2,7 @@ pub mod models; use crate::transport::Transport; use serde_json::json; use crate::serviceinfo::ServiceInfo; -use crate::configuration::ServiceConfiguration; +use crate::configuration::Configuration; use crate::tes::models::TesTask; use crate::tes::models::TesCreateTaskResponse; use crate::tes::models::TesState; @@ -27,14 +27,14 @@ impl Task { } pub struct TES { - config: ServiceConfiguration, + config: Configuration, service_info: ServiceInfo, transport: Transport, } // *** see question above impl TES { - pub fn new(config: &ServiceConfiguration) -> Self { + pub fn new(config: &Configuration) -> Self { // todo double check that it's really a TES using serviceinfo TES { config: config.clone(), @@ -95,12 +95,12 @@ impl TES { #[cfg(test)] mod tests { use crate::tes::TES; - use crate::configuration::ServiceConfiguration; + use crate::configuration::Configuration; use crate::tes::models::TesTask; use crate::tes::models::TesCreateTaskResponse; async fn create_task() -> Result> { - let mut config = ServiceConfiguration::default(); + let mut config = Configuration::default(); config.set_base_path("http://localhost:8080"); // expecting TES/Funnel, TODO autorun let tes = TES::new(&config); diff --git a/lib/src/transport.rs b/lib/src/transport.rs index f3b7222..88b5de3 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -3,17 +3,17 @@ use serde::Serialize; use serde_json::Value; use std::error::Error; use std::fmt; -use crate::configuration::ServiceConfiguration; +use crate::configuration::Configuration; // note: could implement custom certs handling, such as in-TEE generated ephemerial certs pub struct Transport { - config: ServiceConfiguration, + config: Configuration, client: reqwest::Client, } impl Transport { - pub fn new(config: &ServiceConfiguration) -> Self { + pub fn new(config: &Configuration) -> Self { Transport { config: config.clone(), client: Client::new(), @@ -84,54 +84,58 @@ impl Transport { #[cfg(test)] mod tests { - // use crate::transport::Transport; - // use reqwest::Method; - // use serde_json::json; - // use mockito::{mock, Matcher}; - - // #[tokio::test] - // async fn test_request_success() { - // let base_url = &mockito::server_url(); - // let _m = mock("GET", "/test") - // .with_status(200) - // .with_header("content-type", "application/json") - // .with_body(r#"{"message": "success"}"#) - // .create(); - - // let transport = Transport::new(base_url.clone(), None, None, None); - - // let response = transport.request( - // Method::GET, - // &format!("{}/test", base_url), - // None, - // None, - // ).await; - - // assert!(response.is_ok()); - // let body = response.unwrap(); - // assert_eq!(body, r#"{"message": "success"}"#); - // } - - // #[tokio::test] - // async fn test_request_failure() { - // let base_url = &mockito::server_url(); - // let _m = mock("GET", "/test") - // .with_status(404) - // .with_header("content-type", "application/json") - // .with_body(r#"{"message": "not found"}"#) - // .create(); - - // let transport = Transport::new(base_url.clone(), None, None, None); - - // let response = transport.request( - // Method::GET, - // &format!("{}/test", base_url), - // None, - // None, - // ).await; - - // assert!(response.is_err()); - // let error = response.err().unwrap(); - // assert_eq!(error.to_string(), r#"{"message": "not found"}"#); - // } + use crate::{configuration::Configuration, transport::Transport}; + use reqwest::Method; + use serde_json::json; + use mockito::{mock, Matcher}; + + #[tokio::test] + async fn test_request_success() { + let base_url = &mockito::server_url(); + let _m = mock("GET", "/test") + .with_status(200) + .with_header("content-type", "application/json") + .with_body(r#"{"message": "success"}"#) + .create(); + + let config= Configuration::new(base_url.clone(), None, None); + + let transport = Transport::new(&config.clone()); + + let response = transport.request( + Method::GET, + &format!("{}/test", base_url), + None, + None, + ).await; + + assert!(response.is_ok()); + let body = response.unwrap(); + assert_eq!(body, r#"{"message": "success"}"#); + } + + #[tokio::test] + async fn test_request_failure() { + let base_url = &mockito::server_url(); + let _m = mock("GET", "/test") + .with_status(404) + .with_header("content-type", "application/json") + .with_body(r#"{"message": "not found"}"#) + .create(); + + let config= Configuration::new(base_url.clone(), None, None); + + let transport = Transport::new(&config.clone()); + + let response = transport.request( + Method::GET, + &format!("{}/test", base_url), + None, + None, + ).await; + + assert!(response.is_err()); + let error = response.err().unwrap(); + assert_eq!(error.to_string(), r#"{"message": "not found"}"#); + } } \ No newline at end of file From 432ca96359d89e6117934edabcbdb41f8324a98e Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 19 Jun 2024 01:23:34 +0530 Subject: [PATCH 15/92] added service-info(not complete) and made build.sh --- .gitignore | 4 + Readme.md | 4 + build.sh | 43 + lib/src/serviceinfo/mod.rs | 100 +- lib/src/serviceinfo/models/service.rs | 2 +- .../models/service_organization.rs | 2 +- lib/src/serviceinfo/models/service_type.rs | 2 +- lib/src/serviceinfo/serviceinfo.rs | 63 +- lib/src/transport.rs | 4 +- openapi/swagger.yaml | 889 ++++++++++++++++++ 10 files changed, 1106 insertions(+), 7 deletions(-) create mode 100644 Readme.md create mode 100755 build.sh create mode 100644 openapi/swagger.yaml diff --git a/.gitignore b/.gitignore index 9b3d7e2..fd463d5 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,7 @@ Cargo.lock +openapitools.json +package.json +package-lock.json +node_modules/ target/ .vscode diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..6667663 --- /dev/null +++ b/Readme.md @@ -0,0 +1,4 @@ +To use this folder, first clone the folder, and then run the following commands: + +chmod +x build.sh +./build.sh /home/aarav/dev/openapi/tes.yaml diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..f81749a --- /dev/null +++ b/build.sh @@ -0,0 +1,43 @@ +#!/bin/bash + +# Exit immediately if a command exits with a non-zero status. +set -e + + +# Get the directory of the script +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +# Path to the OpenAPI spec file +OPENAPI_SPEC_PATH="$SCRIPT_DIR/openapi/swagger.yaml" + +# Define the temporary output directory for the OpenAPI generator +TEMP_OUTPUT_DIR="$SCRIPT_DIR/tmp" + +# Define the destination directory in your main repository +DESTINATION_DIR="$SCRIPT_DIR" + +# Remove the temporary output directory if it exists +rm -rf $TEMP_OUTPUT_DIR + +# Install OpenAPI Generator CLI locally +npm install @openapitools/openapi-generator-cli + +# Run the OpenAPI generator CLI +npx openapi-generator-cli generate -g rust \ +-i "$OPENAPI_SPEC_PATH" \ +-o "$TEMP_OUTPUT_DIR" \ +--additional-properties=useSingleRequestParameter=true + +# Check if the generation was successful +if [ $? -eq 0 ]; then + # Copy the models folder from the generated code to the main repository + cp -r "$TEMP_OUTPUT_DIR/src/models" "$DESTINATION_DIR" + + # Clean up the temporary output directory + rm -rf $TEMP_OUTPUT_DIR + + echo "OpenAPI generation complete. Models copied to $DESTINATION_DIR" +else + echo "OpenAPI generation failed. Check the verbose output for details." + exit 1 +fi \ No newline at end of file diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 883cf79..5415c28 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -1,3 +1,6 @@ +mod serviceinfo; +mod models; + use crate::transport::Transport; use crate::configuration::Configuration; @@ -12,4 +15,99 @@ impl ServiceInfo { transport: Transport::new(&config.clone()), } } -} \ No newline at end of file +} + +// CHECK WHAT ALL ARE REQUIRED + +use std::error; +use std::fmt; + +#[derive(Debug, Clone)] +pub struct ResponseContent { + pub status: reqwest::StatusCode, + pub content: String, + pub entity: Option, +} + +#[derive(Debug)] +pub enum Error { + Reqwest(reqwest::Error), + Serde(serde_json::Error), + Io(std::io::Error), + ResponseError(ResponseContent), +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (module, e) = match self { + Error::Reqwest(e) => ("reqwest", e.to_string()), + Error::Serde(e) => ("serde", e.to_string()), + Error::Io(e) => ("IO", e.to_string()), + Error::ResponseError(e) => ("response", format!("status code {}", e.status)), + }; + write!(f, "error in {}: {}", module, e) + } +} + +impl error::Error for Error { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + Some(match self { + Error::Reqwest(e) => e, + Error::Serde(e) => e, + Error::Io(e) => e, + Error::ResponseError(_) => return None, + }) + } +} + +impl From for Error { + fn from(e: reqwest::Error) -> Self { + Error::Reqwest(e) + } +} + +impl From for Error { + fn from(e: serde_json::Error) -> Self { + Error::Serde(e) + } +} + +impl From for Error { + fn from(e: std::io::Error) -> Self { + Error::Io(e) + } +} + +pub fn urlencode>(s: T) -> String { + ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +} + +pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { + if let serde_json::Value::Object(object) = value { + let mut params = vec![]; + + for (key, value) in object { + match value { + serde_json::Value::Object(_) => params.append(&mut parse_deep_object( + &format!("{}[{}]", prefix, key), + value, + )), + serde_json::Value::Array(array) => { + for (i, value) in array.iter().enumerate() { + params.append(&mut parse_deep_object( + &format!("{}[{}][{}]", prefix, key, i), + value, + )); + } + }, + serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), + _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), + } + } + + return params; + } + + unimplemented!("Only objects are supported with style=deepObject") +} + diff --git a/lib/src/serviceinfo/models/service.rs b/lib/src/serviceinfo/models/service.rs index 51451ed..67a0c6a 100644 --- a/lib/src/serviceinfo/models/service.rs +++ b/lib/src/serviceinfo/models/service.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::serviceinfo::models; /// Service : GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/serviceinfo/models/service_organization.rs b/lib/src/serviceinfo/models/service_organization.rs index 64d4609..31c4575 100644 --- a/lib/src/serviceinfo/models/service_organization.rs +++ b/lib/src/serviceinfo/models/service_organization.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::serviceinfo::models; /// ServiceOrganization : Organization providing the service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/serviceinfo/models/service_type.rs b/lib/src/serviceinfo/models/service_type.rs index ac2ff98..032faa2 100644 --- a/lib/src/serviceinfo/models/service_type.rs +++ b/lib/src/serviceinfo/models/service_type.rs @@ -8,7 +8,7 @@ * Generated by: https://openapi-generator.tech */ -use crate::models; +use crate::serviceinfo::models; /// ServiceType : Type of a GA4GH service #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] diff --git a/lib/src/serviceinfo/serviceinfo.rs b/lib/src/serviceinfo/serviceinfo.rs index 0f1cb1c..4b6004e 100644 --- a/lib/src/serviceinfo/serviceinfo.rs +++ b/lib/src/serviceinfo/serviceinfo.rs @@ -6,4 +6,65 @@ // impl ServiceInfo { -// } \ No newline at end of file +// } + +use reqwest; + +use crate::{serviceinfo::{models, ResponseContent}, transport}; +use super::Error; +use crate::configuration; + + +/// struct for typed errors of method [`get_service_info`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GetServiceInfoError { + UnknownValue(serde_json::Value), +} + + +pub async fn get_service_info(transport: &transport::Transport) -> Result> { + + let client = &transport.client; + let configuration = &transport.config; + + let url = format!("{}/service-info", configuration.base_path); + let response = &transport.get(&url,None).await; + match response { + Ok(response_body) => { + match serde_json::from_str::(&response_body) { + Ok(tes_create_task_response) => Ok(tes_create_task_response), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) + }, + } + }, + Err(e) => { + log::error!("Error: {}", e); + Err(e.into()) + }, + } + // let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str()); + + // if let Some(ref local_var_user_agent) = local_var_configuration.user_agent { + // local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); + // } + // if let Some(ref local_var_token) = local_var_configuration.bearer_access_token { + // local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned()); + // }; + + // let local_var_req = local_var_req_builder.build()?; + // let local_var_resp = local_var_client.execute(local_var_req).await?; + + // let local_var_status = local_var_resp.status(); + // let local_var_content = local_var_resp.text().await?; + + // if !local_var_status.is_client_error() && !local_var_status.is_server_error() { + // serde_json::from_str(&local_var_content).map_err(Error::from) + // } else { + // let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); + // let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; + // Err(Error::ResponseError(local_var_error)) + // } +} diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 88b5de3..02d98a9 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -8,8 +8,8 @@ use crate::configuration::Configuration; // note: could implement custom certs handling, such as in-TEE generated ephemerial certs pub struct Transport { - config: Configuration, - client: reqwest::Client, + pub config: Configuration, + pub client: reqwest::Client, } impl Transport { diff --git a/openapi/swagger.yaml b/openapi/swagger.yaml new file mode 100644 index 0000000..cfec20b --- /dev/null +++ b/openapi/swagger.yaml @@ -0,0 +1,889 @@ + +openapi: 3.0.1 +info: + title: Task Execution Service + version: 1.1.0 + x-logo: + url: 'https://w3id.org/ga4gh/ga4gh-logo.svg' + license: + name: Apache 2.0 + url: 'https://raw.githubusercontent.com/ga4gh/task-execution-schemas/develop/LICENSE' + description: > + ## Executive Summary + + The Task Execution Service (TES) API is a standardized schema and API for + describing and executing batch execution tasks. A task defines a set of + input files, a set of containers and commands to run, a set of + output files and some other logging and metadata. + + + TES servers accept task documents and execute them asynchronously on + available compute resources. A TES server could be built on top of + a traditional HPC queuing system, + such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch + or Kubernetes. + + ## Introduction + + This document describes the TES API and provides details on the specific + endpoints, request formats, and responses. It is intended to provide key + information for developers of TES-compatible services as well as clients + that will call these TES services. Use cases include: + + - Deploying existing workflow engines on new infrastructure. Workflow engines + such as CWL-Tes and Cromwell have extentions for using TES. This will allow + a system engineer to deploy them onto a new infrastructure using a job scheduling + system not previously supported by the engine. + + - Developing a custom workflow management system. This API provides a common + interface to asynchronous batch processing capabilities. A developer can write + new tools against this interface and expect them to work using a variety of + backend solutions that all support the same specification. + + + ## Standards + + The TES API specification is written in OpenAPI and embodies a RESTful service + philosophy. It uses JSON in requests and responses and standard + HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP + except for testing or internal-only purposes. + + ### Authentication and Authorization + + Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. + However, the decision if authentication is required should be taken by TES API implementers. + + + If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. + + + Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. + + ### CORS + + If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). + Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + + +servers: +- url: /ga4gh/tes/v1 +paths: + /service-info: + get: + tags: + - TaskService + summary: GetServiceInfo + description: |- + Provides information about the service, this structure is based on the + standardized GA4GH service info structure. In addition, this endpoint + will also provide information about customized storage endpoints offered + by the TES server. + operationId: GetServiceInfo + responses: + 200: + description: "" + content: + application/json: + schema: + $ref: '#/components/schemas/tesServiceInfo' + /tasks: + get: + tags: + - TaskService + summary: ListTasks + description: |- + List tasks tracked by the TES server. This includes queued, active and completed tasks. + How long completed tasks are stored by the system may be dependent on the underlying + implementation. + operationId: ListTasks + parameters: + - name: name_prefix + in: query + description: |- + OPTIONAL. Filter the list to include tasks where the name matches this prefix. + If unspecified, no task name filtering is done. + schema: + type: string + - name: state + description: |- + OPTIONAL. Filter tasks by state. If unspecified, + no task state filtering is done. + in: query + required: false + schema: + $ref: '#/components/schemas/tesState' + - name: tag_key + description: |- + OPTIONAL. Provide key tag to filter. The field tag_key is an array + of key values, and will be zipped with an optional tag_value array. + So the query: + ``` + ?tag_key=foo1&tag_value=bar1&tag_key=foo2&tag_value=bar2 + ``` + Should be constructed into the structure { "foo1" : "bar1", "foo2" : "bar2"} + + ``` + ?tag_key=foo1 + ``` + Should be constructed into the structure {"foo1" : ""} + + If the tag_value is empty, it will be treated as matching any possible value. + If a tag value is provided, both the tag's key and value must be exact + matches for a task to be returned. + Filter Tags Match? + ---------------------------------------------------------------------- + {"foo": "bar"} {"foo": "bar"} Yes + {"foo": "bar"} {"foo": "bat"} No + {"foo": ""} {"foo": ""} Yes + {"foo": "bar", "baz": "bat"} {"foo": "bar", "baz": "bat"} Yes + {"foo": "bar"} {"foo": "bar", "baz": "bat"} Yes + {"foo": "bar", "baz": "bat"} {"foo": "bar"} No + {"foo": ""} {"foo": "bar"} Yes + {"foo": ""} {} No + in: query + required: false + schema: + type: array + items: + type: string + - name: tag_value + description: |- + OPTIONAL. The companion value field for tag_key + in: query + required: false + schema: + type: array + items: + type: string + - name: page_size + in: query + description: |- + Optional number of tasks to return in one page. + Must be less than 2048. Defaults to 256. + schema: + type: integer + format: int32 + - name: page_token + in: query + description: |- + OPTIONAL. Page token is used to retrieve the next page of results. + If unspecified, returns the first page of results. The value can be found + in the `next_page_token` field of the last returned result of ListTasks + schema: + type: string + - $ref: '#/components/parameters/view' + + responses: + 200: + description: "" + content: + application/json: + schema: + $ref: '#/components/schemas/tesListTasksResponse' + post: + tags: + - TaskService + summary: CreateTask + description: |- + Create a new task. The user provides a Task document, which the server + uses as a basis and adds additional fields. + operationId: CreateTask + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/tesTask' + required: true + responses: + 200: + description: "" + content: + application/json: + schema: + $ref: '#/components/schemas/tesCreateTaskResponse' + x-codegen-request-body-name: body + /tasks/{id}: + get: + tags: + - TaskService + summary: GetTask + description: |- + Get a single task, based on providing the exact task ID string. + operationId: GetTask + parameters: + - name: id + in: path + required: true + description: ID of task to retrieve. + schema: + type: string + - $ref: '#/components/parameters/view' + responses: + 200: + description: "" + content: + application/json: + schema: + $ref: '#/components/schemas/tesTask' + /tasks/{id}:cancel: + post: + tags: + - TaskService + summary: CancelTask + description: Cancel a task based on providing an exact task ID. + operationId: CancelTask + parameters: + - name: id + in: path + description: ID of task to be canceled. + required: true + schema: + type: string + responses: + 200: + description: "" + content: + application/json: + schema: + $ref: '#/components/schemas/tesCancelTaskResponse' +components: + parameters: + view: + name: view + in: query + description: |- + OPTIONAL. Affects the fields included in the returned Task messages. + + `MINIMAL`: Task message will include ONLY the fields: + - `tesTask.Id` + - `tesTask.State` + + `BASIC`: Task message will include all fields EXCEPT: + - `tesTask.ExecutorLog.stdout` + - `tesTask.ExecutorLog.stderr` + - `tesInput.content` + - `tesTaskLog.system_logs` + + `FULL`: Task message includes all fields. + schema: + type: string + default: MINIMAL + enum: + - MINIMAL + - BASIC + - FULL + + schemas: + tesCancelTaskResponse: + type: object + description: CancelTaskResponse describes a response from the CancelTask endpoint. + tesCreateTaskResponse: + required: + - id + type: object + properties: + id: + type: string + description: Task identifier assigned by the server. + description: |- + CreateTaskResponse describes a response from the CreateTask endpoint. It + will include the task ID that can be used to look up the status of the job. + tesExecutor: + required: + - command + - image + type: object + properties: + image: + type: string + example: ubuntu:20.04 + description: |- + Name of the container image. The string will be passed as the image + argument to the containerization run command. Examples: + - `ubuntu` + - `quay.io/aptible/ubuntu` + - `gcr.io/my-org/my-image` + - `myregistryhost:5000/fedora/httpd:version1.0` + command: + type: array + description: |- + A sequence of program arguments to execute, where the first argument + is the program to execute (i.e. argv). Example: + ``` + { + "command" : ["/bin/md5", "/data/file1"] + } + ``` + items: + type: string + example: ["/bin/md5", "/data/file1"] + workdir: + type: string + description: |- + The working directory that the command will be executed in. + If not defined, the system will default to the directory set by + the container image. + example: /data/ + stdin: + type: string + description: |- + Path inside the container to a file which will be piped + to the executor's stdin. This must be an absolute path. This mechanism + could be used in conjunction with the input declaration to process + a data file using a tool that expects STDIN. + + For example, to get the MD5 sum of a file by reading it into the STDIN + ``` + { + "command" : ["/bin/md5"], + "stdin" : "/data/file1" + } + ``` + example: "/data/file1" + stdout: + type: string + description: |- + Path inside the container to a file where the executor's + stdout will be written to. Must be an absolute path. Example: + ``` + { + "stdout" : "/tmp/stdout.log" + } + ``` + example: "/tmp/stdout.log" + stderr: + type: string + description: |- + Path inside the container to a file where the executor's + stderr will be written to. Must be an absolute path. Example: + ``` + { + "stderr" : "/tmp/stderr.log" + } + ``` + example: "/tmp/stderr.log" + env: + type: object + additionalProperties: + type: string + description: |- + Enviromental variables to set within the container. Example: + ``` + { + "env" : { + "ENV_CONFIG_PATH" : "/data/config.file", + "BLASTDB" : "/data/GRC38", + "HMMERDB" : "/data/hmmer" + } + } + ``` + example: + "BLASTDB" : "/data/GRC38" + "HMMERDB" : "/data/hmmer" + ignore_error: + type: boolean + description: |- + Default behavior of running an array of executors is that execution + stops on the first error. If `ignore_error` is `True`, then the + runner will record error exit codes, but will continue on to the next + tesExecutor. + description: Executor describes a command to be executed, and its environment. + tesExecutorLog: + required: + - exit_code + type: object + properties: + start_time: + type: string + description: Time the executor started, in RFC 3339 format. + example: 2020-10-02T10:00:00-05:00 + end_time: + type: string + description: Time the executor ended, in RFC 3339 format. + example: 2020-10-02T11:00:00-05:00 + stdout: + type: string + description: |- + Stdout content. + + This is meant for convenience. No guarantees are made about the content. + Implementations may chose different approaches: only the head, only the tail, + a URL reference only, etc. + + In order to capture the full stdout client should set Executor.stdout + to a container file path, and use Task.outputs to upload that file + to permanent storage. + stderr: + type: string + description: |- + Stderr content. + + This is meant for convenience. No guarantees are made about the content. + Implementations may chose different approaches: only the head, only the tail, + a URL reference only, etc. + + In order to capture the full stderr client should set Executor.stderr + to a container file path, and use Task.outputs to upload that file + to permanent storage. + exit_code: + type: integer + description: Exit code. + format: int32 + description: ExecutorLog describes logging information related to an Executor. + tesFileType: + type: string + description: |- + Define if input/output element is a file or a directory. It is not required + that the user provide this value, but it is required that the server fill in the + value once the information is avalible at run time. + default: FILE + enum: + - FILE + - DIRECTORY + tesInput: + required: + - path + type: object + properties: + name: + type: string + description: + type: string + url: + type: string + description: |- + REQUIRED, unless "content" is set. + + URL in long term storage, for example: + - s3://my-object-store/file1 + - gs://my-bucket/file2 + - file:///path/to/my/file + - /path/to/my/file + example: s3://my-object-store/file1 + path: + type: string + description: |- + Path of the file inside the container. + Must be an absolute path. + example: /data/file1 + type: + $ref: '#/components/schemas/tesFileType' + content: + type: string + description: |- + File content literal. + + Implementations should support a minimum of 128 KiB in this field + and may define their own maximum. + + UTF-8 encoded + + If content is not empty, "url" must be ignored. + streamable: + type: boolean + description: |- + Indicate that a file resource could be accessed using a streaming + interface, ie a FUSE mounted s3 object. This flag indicates that + using a streaming mount, as opposed to downloading the whole file to + the local scratch space, may be faster despite the latency and + overhead. This does not mean that the backend will use a streaming + interface, as it may not be provided by the vendor, but if the + capacity is avalible it can be used without degrading the + performance of the underlying program. + description: Input describes Task input files. + tesListTasksResponse: + required: + - tasks + type: object + properties: + tasks: + type: array + description: |- + List of tasks. These tasks will be based on the original submitted + task document, but with other fields, such as the job state and + logging info, added/changed as the job progresses. + items: + $ref: '#/components/schemas/tesTask' + next_page_token: + type: string + description: |- + Token used to return the next page of results. This value can be used + in the `page_token` field of the next ListTasks request. + description: ListTasksResponse describes a response from the ListTasks endpoint. + tesOutput: + required: + - path + - url + type: object + properties: + name: + type: string + description: User-provided name of output file + description: + type: string + description: Optional users provided description field, can be used for documentation. + url: + type: string + description: |- + URL at which the TES server makes the output accessible after the task is complete. + When tesOutput.path contains wildcards, it must be a directory; see + `tesOutput.path_prefix` for details on how output URLs are constructed in this case. + For Example: + - `s3://my-object-store/file1` + - `gs://my-bucket/file2` + - `file:///path/to/my/file` + path: + type: string + description: |- + Absolute path of the file inside the container. + May contain pattern matching wildcards to select multiple outputs at once, but mind + implications for `tesOutput.url` and `tesOutput.path_prefix`. + Only wildcards defined in IEEE Std 1003.1-2017 (POSIX), 12.3 are supported; see + https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13 + path_prefix: + type: string + description: |- + Prefix to be removed from matching outputs if `tesOutput.path` contains wildcards; + output URLs are constructed by appending pruned paths to the directory specfied + in `tesOutput.url`. + Required if `tesOutput.path` contains wildcards, ignored otherwise. + type: + $ref: '#/components/schemas/tesFileType' + description: Output describes Task output files. + tesOutputFileLog: + required: + - path + - size_bytes + - url + type: object + properties: + url: + type: string + description: URL of the file in storage, e.g. s3://bucket/file.txt + path: + type: string + description: Path of the file inside the container. Must be an absolute + path. + size_bytes: + type: string + description: |- + Size of the file in bytes. Note, this is currently coded as a string + because official JSON doesn't support int64 numbers. + format: int64 + example: + - "1024" + description: |- + OutputFileLog describes a single output file. This describes + file details after the task has completed successfully, + for logging purposes. + tesResources: + type: object + properties: + cpu_cores: + type: integer + description: Requested number of CPUs + format: int32 + example: 4 + preemptible: + type: boolean + description: |- + Define if the task is allowed to run on preemptible compute instances, + for example, AWS Spot. This option may have no effect when utilized + on some backends that don't have the concept of preemptible jobs. + format: boolean + example: false + ram_gb: + type: number + description: Requested RAM required in gigabytes (GB) + format: double + example: 8 + disk_gb: + type: number + description: Requested disk size in gigabytes (GB) + format: double + example: 40 + zones: + type: array + description: |- + Request that the task be run in these compute zones. How this string + is utilized will be dependent on the backend system. For example, a + system based on a cluster queueing system may use this string to define + priorty queue to which the job is assigned. + items: + type: string + example: us-west-1 + backend_parameters: + type: object + additionalProperties: + type: string + description: |- + Key/value pairs for backend configuration. + ServiceInfo shall return a list of keys that a backend supports. + Keys are case insensitive. + It is expected that clients pass all runtime or hardware requirement key/values + that are not mapped to existing tesResources properties to backend_parameters. + Backends shall log system warnings if a key is passed that is unsupported. + Backends shall not store or return unsupported keys if included in a task. + If backend_parameters_strict equals true, + backends should fail the task if any key/values are unsupported, otherwise, + backends should attempt to run the task + Intended uses include VM size selection, coprocessor configuration, etc. + Example: + ``` + { + "backend_parameters" : { + "VmSize" : "Standard_D64_v3" + } + } + ``` + example: + "VmSize" : "Standard_D64_v3" + backend_parameters_strict: + type: boolean + description: |- + If set to true, backends should fail the task if any backend_parameters + key/values are unsupported, otherwise, backends should attempt to run the task + format: boolean + default: false + example: false + description: Resources describes the resources requested by a task. + tesServiceType: + allOf: + - $ref: 'https://raw.githubusercontent.com/ga4gh-discovery/ga4gh-service-info/v1.0.0/service-info.yaml#/components/schemas/ServiceType' + - type: object + required: + - artifact + properties: + artifact: + type: string + enum: [tes] + example: tes + tesServiceInfo: + allOf: + - $ref: 'https://raw.githubusercontent.com/ga4gh-discovery/ga4gh-service-info/v1.0.0/service-info.yaml#/components/schemas/Service' + - type: object + properties: + storage: + type: array + description: |- + Lists some, but not necessarily all, storage locations supported + by the service. + items: + type: string + example: + - file:///path/to/local/funnel-storage + - s3://ohsu-compbio-funnel/storage + tesResources_backend_parameters: + type: array + description: |- + Lists all tesResources.backend_parameters keys supported + by the service + items: + type: string + example: ["VmSize"] + type: + $ref: '#/components/schemas/tesServiceType' + tesState: + type: string + readOnly: True + description: |- + Task state as defined by the server. + + - `UNKNOWN`: The state of the task is unknown. The cause for this status + message may be dependent on the underlying system. The `UNKNOWN` states + provides a safe default for messages where this field is missing so + that a missing field does not accidentally imply that + the state is QUEUED. + - `QUEUED`: The task is queued and awaiting resources to begin computing. + - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. + For example, the worker may be turning on, downloading input files, etc. + - `RUNNING`: The task is running. Input files are downloaded and the first Executor + has been started. + - `PAUSED`: The task is paused. The reasons for this would be tied to + the specific system running the job. An implementation may have the ability + to pause a task, but this is not required. + - `COMPLETE`: The task has completed running. Executors have exited without error + and output files have been successfully uploaded. + - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, + this means that an Executor exited with a non-zero exit code. + - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, + for example an upload failed due to network issues, the worker's ran out + of disk space, etc. + - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. + - `CANCELING`: The task was canceled by the user, + but the downstream resources are still awaiting deletion. + - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to + the specific system running the job. Generally, this means that the system reclaimed the compute + capacity for reallocation. + default: UNKNOWN + example: COMPLETE + enum: + - UNKNOWN + - QUEUED + - INITIALIZING + - RUNNING + - PAUSED + - COMPLETE + - EXECUTOR_ERROR + - SYSTEM_ERROR + - CANCELED + - PREEMPTED + - CANCELING + tesTask: + required: + - executors + type: object + properties: + id: + type: string + description: Task identifier assigned by the server. + readOnly: true + example: job-0012345 + state: + $ref: '#/components/schemas/tesState' + name: + type: string + description: User-provided task name. + description: + type: string + description: |- + Optional user-provided description of task for documentation purposes. + inputs: + type: array + description: |- + Input files that will be used by the task. Inputs will be downloaded + and mounted into the executor container as defined by the task request + document. + items: + $ref: '#/components/schemas/tesInput' + example: + - { "url" : "s3://my-object-store/file1", "path" : "/data/file1" } + outputs: + type: array + description: |- + Output files. + Outputs will be uploaded from the executor container to long-term storage. + items: + $ref: '#/components/schemas/tesOutput' + example: + - { "path" : "/data/outfile", "url" : "s3://my-object-store/outfile-1", type: "FILE" } + resources: + $ref: '#/components/schemas/tesResources' + executors: + type: array + description: |- + An array of executors to be run. Each of the executors will run one + at a time sequentially. Each executor is a different command that + will be run, and each can utilize a different docker image. But each of + the executors will see the same mapped inputs and volumes that are declared + in the parent CreateTask message. + + Execution stops on the first error. + items: + $ref: '#/components/schemas/tesExecutor' + volumes: + type: array + example: + - "/vol/A/" + description: |- + Volumes are directories which may be used to share data between + Executors. Volumes are initialized as empty directories by the + system when the task starts and are mounted at the same path + in each Executor. + + For example, given a volume defined at `/vol/A`, + executor 1 may write a file to `/vol/A/exec1.out.txt`, then + executor 2 may read from that file. + + (Essentially, this translates to a `docker run -v` flag where + the container path is the same for each executor). + items: + type: string + tags: + type: object + example: + "WORKFLOW_ID" : "cwl-01234" + "PROJECT_GROUP" : "alice-lab" + + additionalProperties: + type: string + description: |- + A key-value map of arbitrary tags. These can be used to store meta-data + and annotations about a task. Example: + ``` + { + "tags" : { + "WORKFLOW_ID" : "cwl-01234", + "PROJECT_GROUP" : "alice-lab" + } + } + ``` + logs: + type: array + description: |- + Task logging information. + Normally, this will contain only one entry, but in the case where + a task fails and is retried, an entry will be appended to this list. + readOnly: true + items: + $ref: '#/components/schemas/tesTaskLog' + creation_time: + type: string + description: |- + Date + time the task was created, in RFC 3339 format. + This is set by the system, not the client. + example: 2020-10-02T10:00:00-05:00 + readOnly: true + description: Task describes an instance of a task. + tesTaskLog: + required: + - logs + - outputs + type: object + properties: + logs: + type: array + description: Logs for each executor + items: + $ref: '#/components/schemas/tesExecutorLog' + metadata: + type: object + additionalProperties: + type: string + description: Arbitrary logging metadata included by the implementation. + example: + host: worker-001 + slurmm_id: 123456 + start_time: + type: string + description: When the task started, in RFC 3339 format. + example: 2020-10-02T10:00:00-05:00 + end_time: + type: string + description: When the task ended, in RFC 3339 format. + example: 2020-10-02T11:00:00-05:00 + outputs: + type: array + description: |- + Information about all output files. Directory outputs are + flattened into separate items. + items: + $ref: '#/components/schemas/tesOutputFileLog' + system_logs: + type: array + description: |- + System logs are any logs the system decides are relevant, + which are not tied directly to an Executor process. + Content is implementation specific: format, size, etc. + + System logs may be collected here to provide convenient access. + + For example, the system may include the name of the host + where the task is executing, an error message that caused + a SYSTEM_ERROR state (e.g. disk is full), etc. + + System logs are only included in the FULL task view. + items: + type: string + description: TaskLog describes logging information related to a Task. + From 57406a1aa1e38eebee810e2b20df5ead955cf918 Mon Sep 17 00:00:00 2001 From: Aarav Mehta <32593731+aaravm@users.noreply.github.com> Date: Wed, 19 Jun 2024 01:27:08 +0530 Subject: [PATCH 16/92] Update Readme.md --- Readme.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Readme.md b/Readme.md index 6667663..f64fd98 100644 --- a/Readme.md +++ b/Readme.md @@ -1,4 +1,6 @@ -To use this folder, first clone the folder, and then run the following commands: - +# Usage +To use this folder, first clone the repository, and then run the following commands: +``` chmod +x build.sh ./build.sh /home/aarav/dev/openapi/tes.yaml +``` From ab08a44781081aec7ab55fb483766b71fd4122c3 Mon Sep 17 00:00:00 2001 From: Aarav Mehta <32593731+aaravm@users.noreply.github.com> Date: Wed, 19 Jun 2024 01:27:40 +0530 Subject: [PATCH 17/92] Update Readme.md --- Readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Readme.md b/Readme.md index f64fd98..1b3b568 100644 --- a/Readme.md +++ b/Readme.md @@ -2,5 +2,5 @@ To use this folder, first clone the repository, and then run the following commands: ``` chmod +x build.sh -./build.sh /home/aarav/dev/openapi/tes.yaml +./build.sh ``` From 02685c09509d5eef8c2c66dc0bcf3ba1baf42eb0 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 20 Jun 2024 16:06:05 +0530 Subject: [PATCH 18/92] added serviceinfo class --- lib/src/serviceinfo/serviceinfo.rs | 82 +++++++++++------------------- 1 file changed, 30 insertions(+), 52 deletions(-) diff --git a/lib/src/serviceinfo/serviceinfo.rs b/lib/src/serviceinfo/serviceinfo.rs index 4b6004e..1f0ea50 100644 --- a/lib/src/serviceinfo/serviceinfo.rs +++ b/lib/src/serviceinfo/serviceinfo.rs @@ -1,16 +1,7 @@ - -// pub struct ServiceInfo { -// transport: Transport; -// } - -// impl ServiceInfo { - -// } - use reqwest; -use crate::{serviceinfo::{models, ResponseContent}, transport}; +use crate::{serviceinfo::{models, ResponseContent, Transport}, transport}; use super::Error; use crate::configuration; @@ -23,48 +14,35 @@ pub enum GetServiceInfoError { } -pub async fn get_service_info(transport: &transport::Transport) -> Result> { - - let client = &transport.client; - let configuration = &transport.config; - - let url = format!("{}/service-info", configuration.base_path); - let response = &transport.get(&url,None).await; - match response { - Ok(response_body) => { - match serde_json::from_str::(&response_body) { - Ok(tes_create_task_response) => Ok(tes_create_task_response), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - }, - } - }, - Err(e) => { - log::error!("Error: {}", e); - Err(e.into()) - }, - } - // let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str()); - - // if let Some(ref local_var_user_agent) = local_var_configuration.user_agent { - // local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone()); - // } - // if let Some(ref local_var_token) = local_var_configuration.bearer_access_token { - // local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned()); - // }; - - // let local_var_req = local_var_req_builder.build()?; - // let local_var_resp = local_var_client.execute(local_var_req).await?; +pub struct ServiceInfo { + transport: Transport, +} - // let local_var_status = local_var_resp.status(); - // let local_var_content = local_var_resp.text().await?; +impl ServiceInfo { + pub fn new(transport: Transport)-> Self{ + ServiceInfo { transport } + } + pub async fn get_service_info(&self) -> Result> { + + let configuration = &self.transport.config; + + let url = format!("{}/service-info", configuration.base_path); + let response = self.transport.get(&url,None).await; + match response { + Ok(response_body) => { + match serde_json::from_str::(&response_body) { + Ok(tes_create_task_response) => Ok(tes_create_task_response), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) + }, + } + }, + Err(e) => { + log::error!("Error: {}", e); + Err(e) + }, + } + } - // if !local_var_status.is_client_error() && !local_var_status.is_server_error() { - // serde_json::from_str(&local_var_content).map_err(Error::from) - // } else { - // let local_var_entity: Option = serde_json::from_str(&local_var_content).ok(); - // let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity }; - // Err(Error::ResponseError(local_var_error)) - // } } From cbba4aece195c9e0ca324aec93ba5733231f27eb Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 20 Jun 2024 16:35:51 +0530 Subject: [PATCH 19/92] checking whether correct from servicinfo --- lib/src/serviceinfo/mod.rs | 33 ++++++++++++++++---- lib/src/serviceinfo/serviceinfo.rs | 48 ------------------------------ lib/src/tes/mod.rs | 27 ++++++++++++----- lib/src/transport.rs | 2 +- 4 files changed, 47 insertions(+), 63 deletions(-) delete mode 100644 lib/src/serviceinfo/serviceinfo.rs diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 5415c28..52678a4 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -1,22 +1,43 @@ -mod serviceinfo; mod models; use crate::transport::Transport; use crate::configuration::Configuration; +#[derive(Clone)] pub struct ServiceInfo { transport: Transport, } impl ServiceInfo { - pub fn new(config: &Configuration) -> Self { - // todo: read service info from the server - ServiceInfo { - transport: Transport::new(&config.clone()), - } + pub fn new(transport: Transport)-> Self{ + Self { transport } + } + pub async fn get_service_info(&self) -> Result> { + + let configuration = &self.transport.config; + + let url = format!("{}/service-info", configuration.base_path); + let response = self.transport.get(&url,None).await; + match response { + Ok(response_body) => { + match serde_json::from_str::(&response_body) { + Ok(tes_create_task_response) => Ok(tes_create_task_response), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) + }, + } + }, + Err(e) => { + log::error!("Error: {}", e); + Err(e) + }, + } } + } + // CHECK WHAT ALL ARE REQUIRED use std::error; diff --git a/lib/src/serviceinfo/serviceinfo.rs b/lib/src/serviceinfo/serviceinfo.rs deleted file mode 100644 index 1f0ea50..0000000 --- a/lib/src/serviceinfo/serviceinfo.rs +++ /dev/null @@ -1,48 +0,0 @@ - -use reqwest; - -use crate::{serviceinfo::{models, ResponseContent, Transport}, transport}; -use super::Error; -use crate::configuration; - - -/// struct for typed errors of method [`get_service_info`] -#[derive(Debug, Clone, Serialize, Deserialize)] -#[serde(untagged)] -pub enum GetServiceInfoError { - UnknownValue(serde_json::Value), -} - - -pub struct ServiceInfo { - transport: Transport, -} - -impl ServiceInfo { - pub fn new(transport: Transport)-> Self{ - ServiceInfo { transport } - } - pub async fn get_service_info(&self) -> Result> { - - let configuration = &self.transport.config; - - let url = format!("{}/service-info", configuration.base_path); - let response = self.transport.get(&url,None).await; - match response { - Ok(response_body) => { - match serde_json::from_str::(&response_body) { - Ok(tes_create_task_response) => Ok(tes_create_task_response), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - }, - } - }, - Err(e) => { - log::error!("Error: {}", e); - Err(e) - }, - } - } - -} diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 2d00020..8351f4a 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,5 +1,7 @@ pub mod models; use crate::transport::Transport; +use reqwest::Response; +use serde::ser; use serde_json::json; use crate::serviceinfo::ServiceInfo; use crate::configuration::Configuration; @@ -34,14 +36,17 @@ pub struct TES { // *** see question above impl TES { - pub fn new(config: &Configuration) -> Self { - // todo double check that it's really a TES using serviceinfo - TES { - config: config.clone(), - transport: Transport::new(config), - service_info: ServiceInfo::new(config) - } + pub async fn new(config: &Configuration) -> Self { + let transport = &Transport::new(config); + let service_info = &ServiceInfo::new(transport.clone()); + let _resp = service_info.get_service_info().await; + // assert_eq!(_resp.name, "TES"); + TES { + config: config.clone(), + transport: transport.clone(), + service_info: service_info.clone(), } +} pub async fn create(&self, task: TesTask/*, params: models::TesTask*/) -> Result> { // todo: version in url based on serviceinfo or user config @@ -102,7 +107,7 @@ mod tests { async fn create_task() -> Result> { let mut config = Configuration::default(); config.set_base_path("http://localhost:8080"); // expecting TES/Funnel, TODO autorun - let tes = TES::new(&config); + let tes = TES::new(&config).await; let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); @@ -130,6 +135,12 @@ mod tests { } // not sure if we need the code bellow, it was autogenerated by openapi-generator as i understand +// struct for typed errors of method [`get_service_info`] +// #[derive(Debug, Clone, Serialize, Deserialize)] +// #[serde(untagged)] +// pub enum GetServiceInfoError { +// UnknownValue(serde_json::Value), +// } // #[derive(Debug, Clone)] // pub struct ResponseContent { // pub status: reqwest::StatusCode, diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 02d98a9..b4faca9 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -6,7 +6,7 @@ use std::fmt; use crate::configuration::Configuration; // note: could implement custom certs handling, such as in-TEE generated ephemerial certs - +#[derive(Clone)] pub struct Transport { pub config: Configuration, pub client: reqwest::Client, From e9ccf4352d257ca6a1d175a0c44ec5c5c996288e Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 20 Jun 2024 19:14:40 +0530 Subject: [PATCH 20/92] checking tests --- Cargo.toml | 1 + lib/src/serviceinfo/mod.rs | 223 +++++++++++++++++++++---------------- lib/src/tes/mod.rs | 4 +- 3 files changed, 127 insertions(+), 101 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index fdb7988..94be5cb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,7 @@ features = ["json", "multipart"] [dev-dependencies] mockito = "0.31" +mockall = "0.10.2" [lib] name = "my_project" diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 52678a4..a08570f 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -18,117 +18,142 @@ impl ServiceInfo { let url = format!("{}/service-info", configuration.base_path); let response = self.transport.get(&url,None).await; - match response { - Ok(response_body) => { - match serde_json::from_str::(&response_body) { - Ok(tes_create_task_response) => Ok(tes_create_task_response), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - }, - } - }, - Err(e) => { - log::error!("Error: {}", e); - Err(e) - }, - } + match response { + Ok(response_body) => { + match serde_json::from_str::(&response_body) { + Ok(tes_create_task_response) => Ok(tes_create_task_response), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) + }, + } + }, + Err(e) => { + log::error!("Error: {}", e); + Err(e) + }, + } } } -// CHECK WHAT ALL ARE REQUIRED - -use std::error; -use std::fmt; - -#[derive(Debug, Clone)] -pub struct ResponseContent { - pub status: reqwest::StatusCode, - pub content: String, - pub entity: Option, -} -#[derive(Debug)] -pub enum Error { - Reqwest(reqwest::Error), - Serde(serde_json::Error), - Io(std::io::Error), - ResponseError(ResponseContent), -} +#[cfg(test)] +mod tests { + use super::*; + use std::ptr::eq; + use mockall::predicate::*; -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let (module, e) = match self { - Error::Reqwest(e) => ("reqwest", e.to_string()), - Error::Serde(e) => ("serde", e.to_string()), - Error::Io(e) => ("IO", e.to_string()), - Error::ResponseError(e) => ("response", format!("status code {}", e.status)), - }; - write!(f, "error in {}: {}", module, e) - } -} - -impl error::Error for Error { - fn source(&self) -> Option<&(dyn error::Error + 'static)> { - Some(match self { - Error::Reqwest(e) => e, - Error::Serde(e) => e, - Error::Io(e) => e, - Error::ResponseError(_) => return None, - }) - } -} + #[tokio::test] + async fn test_get_service_info() { + // let mut mock_transport = MockTransport::new(); -impl From for Error { - fn from(e: reqwest::Error) -> Self { - Error::Reqwest(e) - } -} + // // Set up the mock to return a specific value when `get` is called + // mock_transport.expect_get() + // .with(eq("http://localhost/service-info"), eq(None)) + // .returning(|_, _| Ok(String::from("{\"id\": \"test\", \"name\": \"test\"}"))); -impl From for Error { - fn from(e: serde_json::Error) -> Self { - Error::Serde(e) - } -} + // let service_info = ServiceInfo::new(mock_transport); + // let result = service_info.get_service_info().await; -impl From for Error { - fn from(e: std::io::Error) -> Self { - Error::Io(e) + // assert!(result.is_ok()); + // assert_eq!(result.unwrap().id, "test"); + // assert_eq!(result.unwrap().name, "test"); } } -pub fn urlencode>(s: T) -> String { - ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() -} - -pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { - if let serde_json::Value::Object(object) = value { - let mut params = vec![]; - - for (key, value) in object { - match value { - serde_json::Value::Object(_) => params.append(&mut parse_deep_object( - &format!("{}[{}]", prefix, key), - value, - )), - serde_json::Value::Array(array) => { - for (i, value) in array.iter().enumerate() { - params.append(&mut parse_deep_object( - &format!("{}[{}][{}]", prefix, key, i), - value, - )); - } - }, - serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), - _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), - } - } - - return params; - } +// CHECK WHAT ALL ARE REQUIRED - unimplemented!("Only objects are supported with style=deepObject") -} +// use std::error; +// use std::fmt; + +// #[derive(Debug, Clone)] +// pub struct ResponseContent { +// pub status: reqwest::StatusCode, +// pub content: String, +// pub entity: Option, +// } + +// #[derive(Debug)] +// pub enum Error { +// Reqwest(reqwest::Error), +// Serde(serde_json::Error), +// Io(std::io::Error), +// ResponseError(ResponseContent), +// } + +// impl fmt::Display for Error { +// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { +// let (module, e) = match self { +// Error::Reqwest(e) => ("reqwest", e.to_string()), +// Error::Serde(e) => ("serde", e.to_string()), +// Error::Io(e) => ("IO", e.to_string()), +// Error::ResponseError(e) => ("response", format!("status code {}", e.status)), +// }; +// write!(f, "error in {}: {}", module, e) +// } +// } + +// impl error::Error for Error { +// fn source(&self) -> Option<&(dyn error::Error + 'static)> { +// Some(match self { +// Error::Reqwest(e) => e, +// Error::Serde(e) => e, +// Error::Io(e) => e, +// Error::ResponseError(_) => return None, +// }) +// } +// } + +// impl From for Error { +// fn from(e: reqwest::Error) -> Self { +// Error::Reqwest(e) +// } +// } + +// impl From for Error { +// fn from(e: serde_json::Error) -> Self { +// Error::Serde(e) +// } +// } + +// impl From for Error { +// fn from(e: std::io::Error) -> Self { +// Error::Io(e) +// } +// } + +// pub fn urlencode>(s: T) -> String { +// ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +// } + +// pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { +// if let serde_json::Value::Object(object) = value { +// let mut params = vec![]; + +// for (key, value) in object { +// match value { +// serde_json::Value::Object(_) => params.append(&mut parse_deep_object( +// &format!("{}[{}]", prefix, key), +// value, +// )), +// serde_json::Value::Array(array) => { +// for (i, value) in array.iter().enumerate() { +// params.append(&mut parse_deep_object( +// &format!("{}[{}][{}]", prefix, key, i), +// value, +// )); +// } +// }, +// serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), +// _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), +// } +// } + +// return params; +// } + +// unimplemented!("Only objects are supported with style=deepObject") +// } diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 8351f4a..20dae19 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -64,7 +64,7 @@ impl TES { }, Err(e) => { log::error!("Error: {}", e); - Err(e.into()) + Err(e) }, } } @@ -89,7 +89,7 @@ impl TES { }, Err(e) => { log::error!("Error: {}", e); - Err(e.into()) + Err(e) }, } } From d4faee29c34e7eb5fa6b30d3839b4b412305779d Mon Sep 17 00:00:00 2001 From: aaravm Date: Sat, 22 Jun 2024 23:52:05 +0530 Subject: [PATCH 21/92] added service-info unit test using funnel --- lib/src/serviceinfo/mod.rs | 20 ++++++++++++++++++++ lib/src/tes/mod.rs | 20 ++++++++++---------- 2 files changed, 30 insertions(+), 10 deletions(-) diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index a08570f..7f7fc61 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -44,6 +44,7 @@ mod tests { use super::*; use std::ptr::eq; use mockall::predicate::*; + use tokio; #[tokio::test] async fn test_get_service_info() { @@ -61,6 +62,25 @@ mod tests { // assert_eq!(result.unwrap().id, "test"); // assert_eq!(result.unwrap().name, "test"); } + #[tokio::test] + async fn test_get_service_info_from_funnel() { + // Initialize the Transport struct to point to your local Funnel server + let config = Configuration::new("http://localhost:8000".to_string(), None, None); + let transport = Transport::new(&config); + + // Create a ServiceInfo instance using the local Transport + let service_info = ServiceInfo::new(transport); + + // Call get_service_info and print the result + match service_info.get_service_info().await { + Ok(service) => { + println!("Service Info: {:?}", service); + }, + Err(e) => { + println!("Failed to get service info: {}", e); + }, + } + } } // CHECK WHAT ALL ARE REQUIRED diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 20dae19..61391b0 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -39,8 +39,8 @@ impl TES { pub async fn new(config: &Configuration) -> Self { let transport = &Transport::new(config); let service_info = &ServiceInfo::new(transport.clone()); - let _resp = service_info.get_service_info().await; - // assert_eq!(_resp.name, "TES"); + let resp = service_info.get_service_info().await; + assert_eq!(resp.unwrap().r#type.artifact, "tes"); TES { config: config.clone(), transport: transport.clone(), @@ -106,7 +106,7 @@ mod tests { async fn create_task() -> Result> { let mut config = Configuration::default(); - config.set_base_path("http://localhost:8080"); // expecting TES/Funnel, TODO autorun + config.set_base_path("http://localhost:8000"); // expecting TES/Funnel, TODO autorun let tes = TES::new(&config).await; let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); @@ -124,14 +124,14 @@ mod tests { assert!(!task.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion } - #[tokio::test] - async fn test_task_status() { - env_logger::init(); + // #[tokio::test] + // async fn test_task_status() { + // env_logger::init(); - let task = create_task().await.expect("Failed to create task"); - // Now use task to get the task status... - // todo: assert_eq!(task.status().await, which status?); - } + // let task = create_task().await.expect("Failed to create task"); + // // Now use task to get the task status... + // // todo: assert_eq!(task.status().await, which status?); + // } } // not sure if we need the code bellow, it was autogenerated by openapi-generator as i understand From f1bd0c50b21ba410e4e6cdf294db0ea40ca1a7da Mon Sep 17 00:00:00 2001 From: aaravm Date: Sun, 23 Jun 2024 00:59:59 +0530 Subject: [PATCH 22/92] added check function in TES --- lib/src/serviceinfo/mod.rs | 2 +- lib/src/tes/mod.rs | 42 +++++++++++++++++++++++++++----------- 2 files changed, 31 insertions(+), 13 deletions(-) diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 7f7fc61..10d2ee5 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -1,4 +1,4 @@ -mod models; +pub(crate) mod models; use crate::transport::Transport; use crate::configuration::Configuration; diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 61391b0..a93ee09 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,5 +1,7 @@ pub mod models; use crate::transport::Transport; +use crate::serviceinfo::models::Service; +use models::service; use reqwest::Response; use serde::ser; use serde_json::json; @@ -30,25 +32,41 @@ impl Task { pub struct TES { config: Configuration, - service_info: ServiceInfo, + service: Result>, transport: Transport, } // *** see question above impl TES { - pub async fn new(config: &Configuration) -> Self { - let transport = &Transport::new(config); - let service_info = &ServiceInfo::new(transport.clone()); - let resp = service_info.get_service_info().await; - assert_eq!(resp.unwrap().r#type.artifact, "tes"); - TES { - config: config.clone(), - transport: transport.clone(), - service_info: service_info.clone(), + pub async fn new(config: &Configuration) -> Result> { + let transport = &Transport::new(config); + let service_info = &ServiceInfo::new(transport.clone()); + let resp = service_info.get_service_info().await; + // println!("artifact: {}",resp.clone().unwrap().r#type.artifact); + let instance = TES { + config: config.clone(), + transport: transport.clone(), + service: resp, + }; + + if instance.check() { + Ok(instance) + } else { + Err("The endpoint is not an instance of TES".into()) + } + } + fn check(&self) -> bool { + let resp = &self.service; + return resp.as_ref().unwrap().r#type.artifact == "tes" } -} pub async fn create(&self, task: TesTask/*, params: models::TesTask*/) -> Result> { + // First, check if the service is of TES class + if !self.check() { + // If check fails, log an error and return an Err immediately + log::error!("Service check failed"); + return Err("Service check failed".into()); + } // todo: version in url based on serviceinfo or user config let url = format!("{}/ga4gh/tes/v1/tasks", self.config.base_path); let response = self.transport.post(&url, json!(task)).await; @@ -112,7 +130,7 @@ mod tests { let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); - let task = tes.create(task).await?; + let task = tes?.create(task).await?; Ok(task.id) } From c9cdbfc51d069157f80dee201d8c0bb3935c6a6e Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Sun, 23 Jun 2024 21:12:00 +0400 Subject: [PATCH 23/92] openapi models auto-generation: build script update, rm generated models from the repo --- .gitignore | 2 + README.md | 19 + Readme.md | 6 - build-models.sh | 79 ++ build.sh | 43 - lib/src/serviceinfo/models/mod.rs | 6 - lib/src/serviceinfo/models/service.rs | 67 -- .../models/service_organization.rs | 33 - lib/src/serviceinfo/models/service_type.rs | 37 - lib/src/tes/models/mod.rs | 34 - lib/src/tes/models/service.rs | 67 -- lib/src/tes/models/service_organization.rs | 33 - lib/src/tes/models/service_type.rs | 36 - .../tes/models/tes_create_task_response.rs | 29 - lib/src/tes/models/tes_executor.rs | 57 -- lib/src/tes/models/tes_executor_log.rs | 45 - lib/src/tes/models/tes_file_type.rs | 38 - lib/src/tes/models/tes_input.rs | 50 - lib/src/tes/models/tes_list_tasks_response.rs | 33 - lib/src/tes/models/tes_output.rs | 48 - lib/src/tes/models/tes_output_file_log.rs | 37 - lib/src/tes/models/tes_resources.rs | 53 -- lib/src/tes/models/tes_service_info.rs | 73 -- lib/src/tes/models/tes_service_type.rs | 46 - lib/src/tes/models/tes_state.rs | 65 -- lib/src/tes/models/tes_task.rs | 71 -- lib/src/tes/models/tes_task_log.rs | 51 - openapi/swagger.yaml | 889 ------------------ 28 files changed, 100 insertions(+), 1947 deletions(-) create mode 100644 README.md delete mode 100644 Readme.md create mode 100755 build-models.sh delete mode 100755 build.sh delete mode 100644 lib/src/serviceinfo/models/mod.rs delete mode 100644 lib/src/serviceinfo/models/service.rs delete mode 100644 lib/src/serviceinfo/models/service_organization.rs delete mode 100644 lib/src/serviceinfo/models/service_type.rs delete mode 100644 lib/src/tes/models/mod.rs delete mode 100644 lib/src/tes/models/service.rs delete mode 100644 lib/src/tes/models/service_organization.rs delete mode 100644 lib/src/tes/models/service_type.rs delete mode 100644 lib/src/tes/models/tes_create_task_response.rs delete mode 100644 lib/src/tes/models/tes_executor.rs delete mode 100644 lib/src/tes/models/tes_executor_log.rs delete mode 100644 lib/src/tes/models/tes_file_type.rs delete mode 100644 lib/src/tes/models/tes_input.rs delete mode 100644 lib/src/tes/models/tes_list_tasks_response.rs delete mode 100644 lib/src/tes/models/tes_output.rs delete mode 100644 lib/src/tes/models/tes_output_file_log.rs delete mode 100644 lib/src/tes/models/tes_resources.rs delete mode 100644 lib/src/tes/models/tes_service_info.rs delete mode 100644 lib/src/tes/models/tes_service_type.rs delete mode 100644 lib/src/tes/models/tes_state.rs delete mode 100644 lib/src/tes/models/tes_task.rs delete mode 100644 lib/src/tes/models/tes_task_log.rs delete mode 100644 openapi/swagger.yaml diff --git a/.gitignore b/.gitignore index fd463d5..7a66fa9 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,5 @@ package-lock.json node_modules/ target/ .vscode +lib/src/**/models/ + diff --git a/README.md b/README.md new file mode 100644 index 0000000..5ee79f6 --- /dev/null +++ b/README.md @@ -0,0 +1,19 @@ +# A Generic SDK and CLI for GA4GH API services + + +# Building + +First, clone the repository, and then run the following command to auto-generate models using OpenAPI specifications: +``` +bash ./build-models.sh +``` + +To build the project: +``` +cargo build +``` + +To run the tests: +``` +cargo test +``` \ No newline at end of file diff --git a/Readme.md b/Readme.md deleted file mode 100644 index 1b3b568..0000000 --- a/Readme.md +++ /dev/null @@ -1,6 +0,0 @@ -# Usage -To use this folder, first clone the repository, and then run the following commands: -``` -chmod +x build.sh -./build.sh -``` diff --git a/build-models.sh b/build-models.sh new file mode 100755 index 0000000..01343ee --- /dev/null +++ b/build-models.sh @@ -0,0 +1,79 @@ +#!/bin/bash + +# Exit immediately if a command exits with a non-zero status. +set -e + +get_git_repo_name() { + # Extract the URL of the remote "origin" + url=$(git config --get remote.origin.url) + + # Extract the repository name from the URL + repo_name=$(basename -s .git "$url") + + echo "$repo_name" +} + +repo_name=$(get_git_repo_name) +if [ "$repo_name" != "ga4gh-sdk" ]; then + echo "This script must be run from the 'ga4gh-sdk' repository." + exit 1 +fi + +cd $(git rev-parse --show-toplevel) +SCRIPT_DIR="$(pwd)" + +generate_openapi_models() { + # Parameters + OPENAPI_SPEC_PATH="$1" + API_NAME="$2" + DESTINATION_DIR="$3" + + # Define the temporary output directory for the OpenAPI generator + TEMP_OUTPUT_DIR=$(mktemp -d) + + # Remove the temporary directory at the end of the script + trap 'rm -rf "$TEMP_OUTPUT_DIR"' EXIT + + # Run the OpenAPI generator CLI + npx openapi-generator-cli generate -g rust \ + -i "$OPENAPI_SPEC_PATH" \ + -o "$TEMP_OUTPUT_DIR" \ + --additional-properties=useSingleRequestParameter=true + #--skip-validate-spec + # --global-property models,modelDocs=false,apiDocs=false,apiTests=false,modelTests=false \ + #,packageName=$API_NAME + + # Check if the generation was successful + if [ $? -ne 0 ]; then + echo "OpenAPI generation failed. Check the verbose output for details." + exit 1 + fi + + # Remove the openapitools.json file + rm -f ./openapitools.json + + # Modify the import statements in each generated file + for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do + sed -i '' "s/use crate::models;/use crate::$API_NAME::models;/" "$file" + done + + rm -rf "$DESTINATION_DIR/models" + mkdir -p "$DESTINATION_DIR" + cp -r "$TEMP_OUTPUT_DIR/src/models" "$DESTINATION_DIR" + + echo "OpenAPI generation complete. Models copied to $DESTINATION_DIR" +} + +# Check if OpenAPI Generator CLI is installed +if ! npx openapi-generator-cli version > /dev/null 2>&1; then + # Install OpenAPI Generator CLI locally + npm install -g @openapitools/openapi-generator-cli +fi + +generate_openapi_models \ + "https://raw.githubusercontent.com/ga4gh-discovery/ga4gh-service-info/develop/service-info.yaml" \ + "serviceinfo" "$SCRIPT_DIR/lib/src/serviceinfo/" + +generate_openapi_models \ + "https://raw.githubusercontent.com/ga4gh/task-execution-schemas/develop/openapi/task_execution_service.openapi.yaml" \ + "tes" "$SCRIPT_DIR/lib/src/tes/" diff --git a/build.sh b/build.sh deleted file mode 100755 index f81749a..0000000 --- a/build.sh +++ /dev/null @@ -1,43 +0,0 @@ -#!/bin/bash - -# Exit immediately if a command exits with a non-zero status. -set -e - - -# Get the directory of the script -SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" - -# Path to the OpenAPI spec file -OPENAPI_SPEC_PATH="$SCRIPT_DIR/openapi/swagger.yaml" - -# Define the temporary output directory for the OpenAPI generator -TEMP_OUTPUT_DIR="$SCRIPT_DIR/tmp" - -# Define the destination directory in your main repository -DESTINATION_DIR="$SCRIPT_DIR" - -# Remove the temporary output directory if it exists -rm -rf $TEMP_OUTPUT_DIR - -# Install OpenAPI Generator CLI locally -npm install @openapitools/openapi-generator-cli - -# Run the OpenAPI generator CLI -npx openapi-generator-cli generate -g rust \ --i "$OPENAPI_SPEC_PATH" \ --o "$TEMP_OUTPUT_DIR" \ ---additional-properties=useSingleRequestParameter=true - -# Check if the generation was successful -if [ $? -eq 0 ]; then - # Copy the models folder from the generated code to the main repository - cp -r "$TEMP_OUTPUT_DIR/src/models" "$DESTINATION_DIR" - - # Clean up the temporary output directory - rm -rf $TEMP_OUTPUT_DIR - - echo "OpenAPI generation complete. Models copied to $DESTINATION_DIR" -else - echo "OpenAPI generation failed. Check the verbose output for details." - exit 1 -fi \ No newline at end of file diff --git a/lib/src/serviceinfo/models/mod.rs b/lib/src/serviceinfo/models/mod.rs deleted file mode 100644 index 9aa6373..0000000 --- a/lib/src/serviceinfo/models/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -pub mod service; -pub use self::service::Service; -pub mod service_organization; -pub use self::service_organization::ServiceOrganization; -pub mod service_type; -pub use self::service_type::ServiceType; diff --git a/lib/src/serviceinfo/models/service.rs b/lib/src/serviceinfo/models/service.rs deleted file mode 100644 index 67a0c6a..0000000 --- a/lib/src/serviceinfo/models/service.rs +++ /dev/null @@ -1,67 +0,0 @@ -/* - * GA4GH service-info API specification - * - * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). - * - * The version of the OpenAPI document: 1.0.0 - * Contact: ga4gh-discovery-networks@ga4gh.org - * Generated by: https://openapi-generator.tech - */ - -use crate::serviceinfo::models; - -/// Service : GA4GH service -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct Service { - /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. - #[serde(rename = "id")] - pub id: String, - /// Name of this service. Should be human readable. - #[serde(rename = "name")] - pub name: String, - #[serde(rename = "type")] - pub r#type: Box, - /// Description of the service. Should be human readable and provide information about the service. - #[serde(rename = "description", skip_serializing_if = "Option::is_none")] - pub description: Option, - #[serde(rename = "organization")] - pub organization: Box, - /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). - #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] - pub contact_url: Option, - /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. - #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] - pub documentation_url: Option, - /// Timestamp describing when the service was first deployed and available (RFC 3339 format) - #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] - pub created_at: Option, - /// Timestamp describing when the service was last updated (RFC 3339 format) - #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] - pub updated_at: Option, - /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. - #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] - pub environment: Option, - /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. - #[serde(rename = "version")] - pub version: String, -} - -impl Service { - /// GA4GH service - pub fn new(id: String, name: String, r#type: models::ServiceType, organization: models::ServiceOrganization, version: String) -> Service { - Service { - id, - name, - r#type: Box::new(r#type), - description: None, - organization: Box::new(organization), - contact_url: None, - documentation_url: None, - created_at: None, - updated_at: None, - environment: None, - version, - } - } -} - diff --git a/lib/src/serviceinfo/models/service_organization.rs b/lib/src/serviceinfo/models/service_organization.rs deleted file mode 100644 index 31c4575..0000000 --- a/lib/src/serviceinfo/models/service_organization.rs +++ /dev/null @@ -1,33 +0,0 @@ -/* - * GA4GH service-info API specification - * - * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). - * - * The version of the OpenAPI document: 1.0.0 - * Contact: ga4gh-discovery-networks@ga4gh.org - * Generated by: https://openapi-generator.tech - */ - -use crate::serviceinfo::models; - -/// ServiceOrganization : Organization providing the service -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct ServiceOrganization { - /// Name of the organization responsible for the service - #[serde(rename = "name")] - pub name: String, - /// URL of the website of the organization (RFC 3986 format) - #[serde(rename = "url")] - pub url: String, -} - -impl ServiceOrganization { - /// Organization providing the service - pub fn new(name: String, url: String) -> ServiceOrganization { - ServiceOrganization { - name, - url, - } - } -} - diff --git a/lib/src/serviceinfo/models/service_type.rs b/lib/src/serviceinfo/models/service_type.rs deleted file mode 100644 index 032faa2..0000000 --- a/lib/src/serviceinfo/models/service_type.rs +++ /dev/null @@ -1,37 +0,0 @@ -/* - * GA4GH service-info API specification - * - * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). - * - * The version of the OpenAPI document: 1.0.0 - * Contact: ga4gh-discovery-networks@ga4gh.org - * Generated by: https://openapi-generator.tech - */ - -use crate::serviceinfo::models; - -/// ServiceType : Type of a GA4GH service -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct ServiceType { - /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). - #[serde(rename = "group")] - pub group: String, - /// Name of the API or GA4GH specification implemented. Official GA4GH types should be assigned as part of standards approval process. Custom artifacts are supported. - #[serde(rename = "artifact")] - pub artifact: String, - /// Version of the API or specification. GA4GH specifications use semantic versioning. - #[serde(rename = "version")] - pub version: String, -} - -impl ServiceType { - /// Type of a GA4GH service - pub fn new(group: String, artifact: String, version: String) -> ServiceType { - ServiceType { - group, - artifact, - version, - } - } -} - diff --git a/lib/src/tes/models/mod.rs b/lib/src/tes/models/mod.rs deleted file mode 100644 index 232b43a..0000000 --- a/lib/src/tes/models/mod.rs +++ /dev/null @@ -1,34 +0,0 @@ -pub mod service; -pub use self::service::Service; -pub mod service_organization; -pub use self::service_organization::ServiceOrganization; -pub mod service_type; -pub use self::service_type::ServiceType; -pub mod tes_create_task_response; -pub use self::tes_create_task_response::TesCreateTaskResponse; -pub mod tes_executor; -pub use self::tes_executor::TesExecutor; -pub mod tes_executor_log; -pub use self::tes_executor_log::TesExecutorLog; -pub mod tes_file_type; -pub use self::tes_file_type::TesFileType; -pub mod tes_input; -pub use self::tes_input::TesInput; -pub mod tes_list_tasks_response; -pub use self::tes_list_tasks_response::TesListTasksResponse; -pub mod tes_output; -pub use self::tes_output::TesOutput; -pub mod tes_output_file_log; -pub use self::tes_output_file_log::TesOutputFileLog; -pub mod tes_resources; -pub use self::tes_resources::TesResources; -pub mod tes_service_info; -pub use self::tes_service_info::TesServiceInfo; -pub mod tes_service_type; -pub use self::tes_service_type::TesServiceType; -pub mod tes_state; -pub use self::tes_state::TesState; -pub mod tes_task; -pub use self::tes_task::TesTask; -pub mod tes_task_log; -pub use self::tes_task_log::TesTaskLog; diff --git a/lib/src/tes/models/service.rs b/lib/src/tes/models/service.rs deleted file mode 100644 index 0fd520f..0000000 --- a/lib/src/tes/models/service.rs +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// Service : GA4GH service -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct Service { - /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. - #[serde(rename = "id")] - pub id: String, - /// Name of this service. Should be human readable. - #[serde(rename = "name")] - pub name: String, - #[serde(rename = "type")] - pub r#type: Box, - /// Description of the service. Should be human readable and provide information about the service. - #[serde(rename = "description", skip_serializing_if = "Option::is_none")] - pub description: Option, - #[serde(rename = "organization")] - pub organization: Box, - /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). - #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] - pub contact_url: Option, - /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. - #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] - pub documentation_url: Option, - /// Timestamp describing when the service was first deployed and available (RFC 3339 format) - #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] - pub created_at: Option, - /// Timestamp describing when the service was last updated (RFC 3339 format) - #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] - pub updated_at: Option, - /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. - #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] - pub environment: Option, - /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. - #[serde(rename = "version")] - pub version: String, -} - -impl Service { - /// GA4GH service - pub fn new(id: String, name: String, r#type: models::ServiceType, organization: models::ServiceOrganization, version: String) -> Service { - Service { - id, - name, - r#type: Box::new(r#type), - description: None, - organization: Box::new(organization), - contact_url: None, - documentation_url: None, - created_at: None, - updated_at: None, - environment: None, - version, - } - } -} - diff --git a/lib/src/tes/models/service_organization.rs b/lib/src/tes/models/service_organization.rs deleted file mode 100644 index e38091c..0000000 --- a/lib/src/tes/models/service_organization.rs +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// ServiceOrganization : Organization providing the service -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct ServiceOrganization { - /// Name of the organization responsible for the service - #[serde(rename = "name")] - pub name: String, - /// URL of the website of the organization (RFC 3986 format) - #[serde(rename = "url")] - pub url: String, -} - -impl ServiceOrganization { - /// Organization providing the service - pub fn new(name: String, url: String) -> ServiceOrganization { - ServiceOrganization { - name, - url, - } - } -} - diff --git a/lib/src/tes/models/service_type.rs b/lib/src/tes/models/service_type.rs deleted file mode 100644 index 3dee78f..0000000 --- a/lib/src/tes/models/service_type.rs +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// ServiceType : Type of a GA4GH service -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct ServiceType { - /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). - #[serde(rename = "group")] - pub group: String, - /// Name of the API or GA4GH specification implemented. Official GA4GH types should be assigned as part of standards approval process. Custom artifacts are supported. - #[serde(rename = "artifact")] - pub artifact: String, - /// Version of the API or specification. GA4GH specifications use semantic versioning. - #[serde(rename = "version")] - pub version: String, -} - -impl ServiceType { - /// Type of a GA4GH service - pub fn new(group: String, artifact: String, version: String) -> ServiceType { - ServiceType { - group, - artifact, - version, - } - } -} diff --git a/lib/src/tes/models/tes_create_task_response.rs b/lib/src/tes/models/tes_create_task_response.rs deleted file mode 100644 index d02f9bd..0000000 --- a/lib/src/tes/models/tes_create_task_response.rs +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesCreateTaskResponse : CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesCreateTaskResponse { - /// Task identifier assigned by the server. - #[serde(rename = "id")] - pub id: String, -} - -impl TesCreateTaskResponse { - /// CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. - pub fn new(id: String) -> TesCreateTaskResponse { - TesCreateTaskResponse { - id, - } - } -} - diff --git a/lib/src/tes/models/tes_executor.rs b/lib/src/tes/models/tes_executor.rs deleted file mode 100644 index 8cbbe17..0000000 --- a/lib/src/tes/models/tes_executor.rs +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesExecutor : Executor describes a command to be executed, and its environment. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesExecutor { - /// Name of the container image. The string will be passed as the image argument to the containerization run command. Examples: - `ubuntu` - `quay.io/aptible/ubuntu` - `gcr.io/my-org/my-image` - `myregistryhost:5000/fedora/httpd:version1.0` - #[serde(rename = "image")] - pub image: String, - /// A sequence of program arguments to execute, where the first argument is the program to execute (i.e. argv). Example: ``` { \"command\" : [\"/bin/md5\", \"/data/file1\"] } ``` - #[serde(rename = "command")] - pub command: Vec, - /// The working directory that the command will be executed in. If not defined, the system will default to the directory set by the container image. - #[serde(rename = "workdir", skip_serializing_if = "Option::is_none")] - pub workdir: Option, - /// Path inside the container to a file which will be piped to the executor's stdin. This must be an absolute path. This mechanism could be used in conjunction with the input declaration to process a data file using a tool that expects STDIN. For example, to get the MD5 sum of a file by reading it into the STDIN ``` { \"command\" : [\"/bin/md5\"], \"stdin\" : \"/data/file1\" } ``` - #[serde(rename = "stdin", skip_serializing_if = "Option::is_none")] - pub stdin: Option, - /// Path inside the container to a file where the executor's stdout will be written to. Must be an absolute path. Example: ``` { \"stdout\" : \"/tmp/stdout.log\" } ``` - #[serde(rename = "stdout", skip_serializing_if = "Option::is_none")] - pub stdout: Option, - /// Path inside the container to a file where the executor's stderr will be written to. Must be an absolute path. Example: ``` { \"stderr\" : \"/tmp/stderr.log\" } ``` - #[serde(rename = "stderr", skip_serializing_if = "Option::is_none")] - pub stderr: Option, - /// Enviromental variables to set within the container. Example: ``` { \"env\" : { \"ENV_CONFIG_PATH\" : \"/data/config.file\", \"BLASTDB\" : \"/data/GRC38\", \"HMMERDB\" : \"/data/hmmer\" } } ``` - #[serde(rename = "env", skip_serializing_if = "Option::is_none")] - pub env: Option>, - /// Default behavior of running an array of executors is that execution stops on the first error. If `ignore_error` is `True`, then the runner will record error exit codes, but will continue on to the next tesExecutor. - #[serde(rename = "ignore_error", skip_serializing_if = "Option::is_none")] - pub ignore_error: Option, -} - -impl TesExecutor { - /// Executor describes a command to be executed, and its environment. - pub fn new(image: String, command: Vec) -> TesExecutor { - TesExecutor { - image, - command, - workdir: None, - stdin: None, - stdout: None, - stderr: None, - env: None, - ignore_error: None, - } - } -} - diff --git a/lib/src/tes/models/tes_executor_log.rs b/lib/src/tes/models/tes_executor_log.rs deleted file mode 100644 index bbf7173..0000000 --- a/lib/src/tes/models/tes_executor_log.rs +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesExecutorLog : ExecutorLog describes logging information related to an Executor. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesExecutorLog { - /// Time the executor started, in RFC 3339 format. - #[serde(rename = "start_time", skip_serializing_if = "Option::is_none")] - pub start_time: Option, - /// Time the executor ended, in RFC 3339 format. - #[serde(rename = "end_time", skip_serializing_if = "Option::is_none")] - pub end_time: Option, - /// Stdout content. This is meant for convenience. No guarantees are made about the content. Implementations may chose different approaches: only the head, only the tail, a URL reference only, etc. In order to capture the full stdout client should set Executor.stdout to a container file path, and use Task.outputs to upload that file to permanent storage. - #[serde(rename = "stdout", skip_serializing_if = "Option::is_none")] - pub stdout: Option, - /// Stderr content. This is meant for convenience. No guarantees are made about the content. Implementations may chose different approaches: only the head, only the tail, a URL reference only, etc. In order to capture the full stderr client should set Executor.stderr to a container file path, and use Task.outputs to upload that file to permanent storage. - #[serde(rename = "stderr", skip_serializing_if = "Option::is_none")] - pub stderr: Option, - /// Exit code. - #[serde(rename = "exit_code")] - pub exit_code: i32, -} - -impl TesExecutorLog { - /// ExecutorLog describes logging information related to an Executor. - pub fn new(exit_code: i32) -> TesExecutorLog { - TesExecutorLog { - start_time: None, - end_time: None, - stdout: None, - stderr: None, - exit_code, - } - } -} - diff --git a/lib/src/tes/models/tes_file_type.rs b/lib/src/tes/models/tes_file_type.rs deleted file mode 100644 index cc794eb..0000000 --- a/lib/src/tes/models/tes_file_type.rs +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesFileType : Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. -/// Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. -#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] -pub enum TesFileType { - #[serde(rename = "FILE")] - File, - #[serde(rename = "DIRECTORY")] - Directory, - -} - -impl ToString for TesFileType { - fn to_string(&self) -> String { - match self { - Self::File => String::from("FILE"), - Self::Directory => String::from("DIRECTORY"), - } - } -} - -impl Default for TesFileType { - fn default() -> TesFileType { - Self::File - } -} - diff --git a/lib/src/tes/models/tes_input.rs b/lib/src/tes/models/tes_input.rs deleted file mode 100644 index e36358a..0000000 --- a/lib/src/tes/models/tes_input.rs +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesInput : Input describes Task input files. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesInput { - #[serde(rename = "name", skip_serializing_if = "Option::is_none")] - pub name: Option, - #[serde(rename = "description", skip_serializing_if = "Option::is_none")] - pub description: Option, - /// REQUIRED, unless \"content\" is set. URL in long term storage, for example: - s3://my-object-store/file1 - gs://my-bucket/file2 - file:///path/to/my/file - /path/to/my/file - #[serde(rename = "url", skip_serializing_if = "Option::is_none")] - pub url: Option, - /// Path of the file inside the container. Must be an absolute path. - #[serde(rename = "path")] - pub path: String, - #[serde(rename = "type", skip_serializing_if = "Option::is_none")] - pub r#type: Option, - /// File content literal. Implementations should support a minimum of 128 KiB in this field and may define their own maximum. UTF-8 encoded If content is not empty, \"url\" must be ignored. - #[serde(rename = "content", skip_serializing_if = "Option::is_none")] - pub content: Option, - /// Indicate that a file resource could be accessed using a streaming interface, ie a FUSE mounted s3 object. This flag indicates that using a streaming mount, as opposed to downloading the whole file to the local scratch space, may be faster despite the latency and overhead. This does not mean that the backend will use a streaming interface, as it may not be provided by the vendor, but if the capacity is avalible it can be used without degrading the performance of the underlying program. - #[serde(rename = "streamable", skip_serializing_if = "Option::is_none")] - pub streamable: Option, -} - -impl TesInput { - /// Input describes Task input files. - pub fn new(path: String) -> TesInput { - TesInput { - name: None, - description: None, - url: None, - path, - r#type: None, - content: None, - streamable: None, - } - } -} - diff --git a/lib/src/tes/models/tes_list_tasks_response.rs b/lib/src/tes/models/tes_list_tasks_response.rs deleted file mode 100644 index a15f832..0000000 --- a/lib/src/tes/models/tes_list_tasks_response.rs +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesListTasksResponse : ListTasksResponse describes a response from the ListTasks endpoint. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesListTasksResponse { - /// List of tasks. These tasks will be based on the original submitted task document, but with other fields, such as the job state and logging info, added/changed as the job progresses. - #[serde(rename = "tasks")] - pub tasks: Vec, - /// Token used to return the next page of results. This value can be used in the `page_token` field of the next ListTasks request. - #[serde(rename = "next_page_token", skip_serializing_if = "Option::is_none")] - pub next_page_token: Option, -} - -impl TesListTasksResponse { - /// ListTasksResponse describes a response from the ListTasks endpoint. - pub fn new(tasks: Vec) -> TesListTasksResponse { - TesListTasksResponse { - tasks, - next_page_token: None, - } - } -} - diff --git a/lib/src/tes/models/tes_output.rs b/lib/src/tes/models/tes_output.rs deleted file mode 100644 index 6afd91c..0000000 --- a/lib/src/tes/models/tes_output.rs +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesOutput : Output describes Task output files. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesOutput { - /// User-provided name of output file - #[serde(rename = "name", skip_serializing_if = "Option::is_none")] - pub name: Option, - /// Optional users provided description field, can be used for documentation. - #[serde(rename = "description", skip_serializing_if = "Option::is_none")] - pub description: Option, - /// URL at which the TES server makes the output accessible after the task is complete. When tesOutput.path contains wildcards, it must be a directory; see `tesOutput.path_prefix` for details on how output URLs are constructed in this case. For Example: - `s3://my-object-store/file1` - `gs://my-bucket/file2` - `file:///path/to/my/file` - #[serde(rename = "url")] - pub url: String, - /// Absolute path of the file inside the container. May contain pattern matching wildcards to select multiple outputs at once, but mind implications for `tesOutput.url` and `tesOutput.path_prefix`. Only wildcards defined in IEEE Std 1003.1-2017 (POSIX), 12.3 are supported; see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13 - #[serde(rename = "path")] - pub path: String, - /// Prefix to be removed from matching outputs if `tesOutput.path` contains wildcards; output URLs are constructed by appending pruned paths to the directory specfied in `tesOutput.url`. Required if `tesOutput.path` contains wildcards, ignored otherwise. - #[serde(rename = "path_prefix", skip_serializing_if = "Option::is_none")] - pub path_prefix: Option, - #[serde(rename = "type", skip_serializing_if = "Option::is_none")] - pub r#type: Option, -} - -impl TesOutput { - /// Output describes Task output files. - pub fn new(url: String, path: String) -> TesOutput { - TesOutput { - name: None, - description: None, - url, - path, - path_prefix: None, - r#type: None, - } - } -} - diff --git a/lib/src/tes/models/tes_output_file_log.rs b/lib/src/tes/models/tes_output_file_log.rs deleted file mode 100644 index ccfe0dc..0000000 --- a/lib/src/tes/models/tes_output_file_log.rs +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesOutputFileLog : OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesOutputFileLog { - /// URL of the file in storage, e.g. s3://bucket/file.txt - #[serde(rename = "url")] - pub url: String, - /// Path of the file inside the container. Must be an absolute path. - #[serde(rename = "path")] - pub path: String, - /// Size of the file in bytes. Note, this is currently coded as a string because official JSON doesn't support int64 numbers. - #[serde(rename = "size_bytes")] - pub size_bytes: String, -} - -impl TesOutputFileLog { - /// OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. - pub fn new(url: String, path: String, size_bytes: String) -> TesOutputFileLog { - TesOutputFileLog { - url, - path, - size_bytes, - } - } -} - diff --git a/lib/src/tes/models/tes_resources.rs b/lib/src/tes/models/tes_resources.rs deleted file mode 100644 index 991aff7..0000000 --- a/lib/src/tes/models/tes_resources.rs +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesResources : Resources describes the resources requested by a task. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesResources { - /// Requested number of CPUs - #[serde(rename = "cpu_cores", skip_serializing_if = "Option::is_none")] - pub cpu_cores: Option, - /// Define if the task is allowed to run on preemptible compute instances, for example, AWS Spot. This option may have no effect when utilized on some backends that don't have the concept of preemptible jobs. - #[serde(rename = "preemptible", skip_serializing_if = "Option::is_none")] - pub preemptible: Option, - /// Requested RAM required in gigabytes (GB) - #[serde(rename = "ram_gb", skip_serializing_if = "Option::is_none")] - pub ram_gb: Option, - /// Requested disk size in gigabytes (GB) - #[serde(rename = "disk_gb", skip_serializing_if = "Option::is_none")] - pub disk_gb: Option, - /// Request that the task be run in these compute zones. How this string is utilized will be dependent on the backend system. For example, a system based on a cluster queueing system may use this string to define priorty queue to which the job is assigned. - #[serde(rename = "zones", skip_serializing_if = "Option::is_none")] - pub zones: Option>, - /// Key/value pairs for backend configuration. ServiceInfo shall return a list of keys that a backend supports. Keys are case insensitive. It is expected that clients pass all runtime or hardware requirement key/values that are not mapped to existing tesResources properties to backend_parameters. Backends shall log system warnings if a key is passed that is unsupported. Backends shall not store or return unsupported keys if included in a task. If backend_parameters_strict equals true, backends should fail the task if any key/values are unsupported, otherwise, backends should attempt to run the task Intended uses include VM size selection, coprocessor configuration, etc. Example: ``` { \"backend_parameters\" : { \"VmSize\" : \"Standard_D64_v3\" } } ``` - #[serde(rename = "backend_parameters", skip_serializing_if = "Option::is_none")] - pub backend_parameters: Option>, - /// If set to true, backends should fail the task if any backend_parameters key/values are unsupported, otherwise, backends should attempt to run the task - #[serde(rename = "backend_parameters_strict", skip_serializing_if = "Option::is_none")] - pub backend_parameters_strict: Option, -} - -impl TesResources { - /// Resources describes the resources requested by a task. - pub fn new() -> TesResources { - TesResources { - cpu_cores: None, - preemptible: None, - ram_gb: None, - disk_gb: None, - zones: None, - backend_parameters: None, - backend_parameters_strict: None, - } - } -} - diff --git a/lib/src/tes/models/tes_service_info.rs b/lib/src/tes/models/tes_service_info.rs deleted file mode 100644 index 4a8196a..0000000 --- a/lib/src/tes/models/tes_service_info.rs +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesServiceInfo { - /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. - #[serde(rename = "id")] - pub id: String, - /// Name of this service. Should be human readable. - #[serde(rename = "name")] - pub name: String, - #[serde(rename = "type")] - pub r#type: Box, - /// Description of the service. Should be human readable and provide information about the service. - #[serde(rename = "description", skip_serializing_if = "Option::is_none")] - pub description: Option, - #[serde(rename = "organization")] - pub organization: Box, - /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). - #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] - pub contact_url: Option, - /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. - #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] - pub documentation_url: Option, - /// Timestamp describing when the service was first deployed and available (RFC 3339 format) - #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] - pub created_at: Option, - /// Timestamp describing when the service was last updated (RFC 3339 format) - #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] - pub updated_at: Option, - /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. - #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] - pub environment: Option, - /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. - #[serde(rename = "version")] - pub version: String, - /// Lists some, but not necessarily all, storage locations supported by the service. - #[serde(rename = "storage", skip_serializing_if = "Option::is_none")] - pub storage: Option>, - /// Lists all tesResources.backend_parameters keys supported by the service - #[serde(rename = "tesResources_backend_parameters", skip_serializing_if = "Option::is_none")] - pub tes_resources_backend_parameters: Option>, -} - -impl TesServiceInfo { - pub fn new(id: String, name: String, r#type: models::TesServiceType, organization: models::ServiceOrganization, version: String) -> TesServiceInfo { - TesServiceInfo { - id, - name, - r#type: Box::new(r#type), - description: None, - organization: Box::new(organization), - contact_url: None, - documentation_url: None, - created_at: None, - updated_at: None, - environment: None, - version, - storage: None, - tes_resources_backend_parameters: None, - } - } -} - diff --git a/lib/src/tes/models/tes_service_type.rs b/lib/src/tes/models/tes_service_type.rs deleted file mode 100644 index 81be8ae..0000000 --- a/lib/src/tes/models/tes_service_type.rs +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesServiceType { - /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). - #[serde(rename = "group")] - pub group: String, - #[serde(rename = "artifact")] - pub artifact: Artifact, - /// Version of the API or specification. GA4GH specifications use semantic versioning. - #[serde(rename = "version")] - pub version: String, -} - -impl TesServiceType { - pub fn new(group: String, artifact: Artifact, version: String) -> TesServiceType { - TesServiceType { - group, - artifact, - version, - } - } -} -/// -#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] -pub enum Artifact { - #[serde(rename = "tes")] - Tes, -} - -impl Default for Artifact { - fn default() -> Artifact { - Self::Tes - } -} - diff --git a/lib/src/tes/models/tes_state.rs b/lib/src/tes/models/tes_state.rs deleted file mode 100644 index 1dfd913..0000000 --- a/lib/src/tes/models/tes_state.rs +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesState : Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. -/// Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. -#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] -pub enum TesState { - #[serde(rename = "UNKNOWN")] - Unknown, - #[serde(rename = "QUEUED")] - Queued, - #[serde(rename = "INITIALIZING")] - Initializing, - #[serde(rename = "RUNNING")] - Running, - #[serde(rename = "PAUSED")] - Paused, - #[serde(rename = "COMPLETE")] - Complete, - #[serde(rename = "EXECUTOR_ERROR")] - ExecutorError, - #[serde(rename = "SYSTEM_ERROR")] - SystemError, - #[serde(rename = "CANCELED")] - Canceled, - #[serde(rename = "PREEMPTED")] - Preempted, - #[serde(rename = "CANCELING")] - Canceling, - -} - -impl ToString for TesState { - fn to_string(&self) -> String { - match self { - Self::Unknown => String::from("UNKNOWN"), - Self::Queued => String::from("QUEUED"), - Self::Initializing => String::from("INITIALIZING"), - Self::Running => String::from("RUNNING"), - Self::Paused => String::from("PAUSED"), - Self::Complete => String::from("COMPLETE"), - Self::ExecutorError => String::from("EXECUTOR_ERROR"), - Self::SystemError => String::from("SYSTEM_ERROR"), - Self::Canceled => String::from("CANCELED"), - Self::Preempted => String::from("PREEMPTED"), - Self::Canceling => String::from("CANCELING"), - } - } -} - -impl Default for TesState { - fn default() -> TesState { - Self::Unknown - } -} - diff --git a/lib/src/tes/models/tes_task.rs b/lib/src/tes/models/tes_task.rs deleted file mode 100644 index 7b27e8a..0000000 --- a/lib/src/tes/models/tes_task.rs +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesTask : Task describes an instance of a task. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesTask { - /// Task identifier assigned by the server. - #[serde(rename = "id", skip_serializing_if = "Option::is_none")] - pub id: Option, - #[serde(rename = "state", skip_serializing_if = "Option::is_none")] - pub state: Option, - /// User-provided task name. - #[serde(rename = "name", skip_serializing_if = "Option::is_none")] - pub name: Option, - /// Optional user-provided description of task for documentation purposes. - #[serde(rename = "description", skip_serializing_if = "Option::is_none")] - pub description: Option, - /// Input files that will be used by the task. Inputs will be downloaded and mounted into the executor container as defined by the task request document. - #[serde(rename = "inputs", skip_serializing_if = "Option::is_none")] - pub inputs: Option>, - /// Output files. Outputs will be uploaded from the executor container to long-term storage. - #[serde(rename = "outputs", skip_serializing_if = "Option::is_none")] - pub outputs: Option>, - #[serde(rename = "resources", skip_serializing_if = "Option::is_none")] - pub resources: Option>, - /// An array of executors to be run. Each of the executors will run one at a time sequentially. Each executor is a different command that will be run, and each can utilize a different docker image. But each of the executors will see the same mapped inputs and volumes that are declared in the parent CreateTask message. Execution stops on the first error. - #[serde(rename = "executors")] - pub executors: Vec, - /// Volumes are directories which may be used to share data between Executors. Volumes are initialized as empty directories by the system when the task starts and are mounted at the same path in each Executor. For example, given a volume defined at `/vol/A`, executor 1 may write a file to `/vol/A/exec1.out.txt`, then executor 2 may read from that file. (Essentially, this translates to a `docker run -v` flag where the container path is the same for each executor). - #[serde(rename = "volumes", skip_serializing_if = "Option::is_none")] - pub volumes: Option>, - /// A key-value map of arbitrary tags. These can be used to store meta-data and annotations about a task. Example: ``` { \"tags\" : { \"WORKFLOW_ID\" : \"cwl-01234\", \"PROJECT_GROUP\" : \"alice-lab\" } } ``` - #[serde(rename = "tags", skip_serializing_if = "Option::is_none")] - pub tags: Option>, - /// Task logging information. Normally, this will contain only one entry, but in the case where a task fails and is retried, an entry will be appended to this list. - #[serde(rename = "logs", skip_serializing_if = "Option::is_none")] - pub logs: Option>, - /// Date + time the task was created, in RFC 3339 format. This is set by the system, not the client. - #[serde(rename = "creation_time", skip_serializing_if = "Option::is_none")] - pub creation_time: Option, -} - -impl TesTask { - /// Task describes an instance of a task. - pub fn new(executors: Vec) -> TesTask { - TesTask { - id: None, - state: None, - name: None, - description: None, - inputs: None, - outputs: None, - resources: None, - executors, - volumes: None, - tags: None, - logs: None, - creation_time: None, - } - } -} - diff --git a/lib/src/tes/models/tes_task_log.rs b/lib/src/tes/models/tes_task_log.rs deleted file mode 100644 index eb8a551..0000000 --- a/lib/src/tes/models/tes_task_log.rs +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Task Execution Service - * - * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - * - * The version of the OpenAPI document: 1.1.0 - * - * Generated by: https://openapi-generator.tech - */ - -use crate::tes::models; - -/// TesTaskLog : TaskLog describes logging information related to a Task. -#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] -pub struct TesTaskLog { - /// Logs for each executor - #[serde(rename = "logs")] - pub logs: Vec, - /// Arbitrary logging metadata included by the implementation. - #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] - pub metadata: Option>, - /// When the task started, in RFC 3339 format. - #[serde(rename = "start_time", skip_serializing_if = "Option::is_none")] - pub start_time: Option, - /// When the task ended, in RFC 3339 format. - #[serde(rename = "end_time", skip_serializing_if = "Option::is_none")] - pub end_time: Option, - /// Information about all output files. Directory outputs are flattened into separate items. - #[serde(rename = "outputs")] - pub outputs: Vec, - /// System logs are any logs the system decides are relevant, which are not tied directly to an Executor process. Content is implementation specific: format, size, etc. System logs may be collected here to provide convenient access. For example, the system may include the name of the host where the task is executing, an error message that caused a SYSTEM_ERROR state (e.g. disk is full), etc. System logs are only included in the FULL task view. - #[serde(rename = "system_logs", skip_serializing_if = "Option::is_none")] - pub system_logs: Option>, -} - -impl TesTaskLog { - /// TaskLog describes logging information related to a Task. - pub fn new( - logs: Vec, - outputs: Vec, - ) -> TesTaskLog { - TesTaskLog { - logs, - metadata: None, - start_time: None, - end_time: None, - outputs, - system_logs: None, - } - } -} diff --git a/openapi/swagger.yaml b/openapi/swagger.yaml deleted file mode 100644 index cfec20b..0000000 --- a/openapi/swagger.yaml +++ /dev/null @@ -1,889 +0,0 @@ - -openapi: 3.0.1 -info: - title: Task Execution Service - version: 1.1.0 - x-logo: - url: 'https://w3id.org/ga4gh/ga4gh-logo.svg' - license: - name: Apache 2.0 - url: 'https://raw.githubusercontent.com/ga4gh/task-execution-schemas/develop/LICENSE' - description: > - ## Executive Summary - - The Task Execution Service (TES) API is a standardized schema and API for - describing and executing batch execution tasks. A task defines a set of - input files, a set of containers and commands to run, a set of - output files and some other logging and metadata. - - - TES servers accept task documents and execute them asynchronously on - available compute resources. A TES server could be built on top of - a traditional HPC queuing system, - such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch - or Kubernetes. - - ## Introduction - - This document describes the TES API and provides details on the specific - endpoints, request formats, and responses. It is intended to provide key - information for developers of TES-compatible services as well as clients - that will call these TES services. Use cases include: - - - Deploying existing workflow engines on new infrastructure. Workflow engines - such as CWL-Tes and Cromwell have extentions for using TES. This will allow - a system engineer to deploy them onto a new infrastructure using a job scheduling - system not previously supported by the engine. - - - Developing a custom workflow management system. This API provides a common - interface to asynchronous batch processing capabilities. A developer can write - new tools against this interface and expect them to work using a variety of - backend solutions that all support the same specification. - - - ## Standards - - The TES API specification is written in OpenAPI and embodies a RESTful service - philosophy. It uses JSON in requests and responses and standard - HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP - except for testing or internal-only purposes. - - ### Authentication and Authorization - - Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. - However, the decision if authentication is required should be taken by TES API implementers. - - - If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. - - - Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. - - ### CORS - - If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). - Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. - - -servers: -- url: /ga4gh/tes/v1 -paths: - /service-info: - get: - tags: - - TaskService - summary: GetServiceInfo - description: |- - Provides information about the service, this structure is based on the - standardized GA4GH service info structure. In addition, this endpoint - will also provide information about customized storage endpoints offered - by the TES server. - operationId: GetServiceInfo - responses: - 200: - description: "" - content: - application/json: - schema: - $ref: '#/components/schemas/tesServiceInfo' - /tasks: - get: - tags: - - TaskService - summary: ListTasks - description: |- - List tasks tracked by the TES server. This includes queued, active and completed tasks. - How long completed tasks are stored by the system may be dependent on the underlying - implementation. - operationId: ListTasks - parameters: - - name: name_prefix - in: query - description: |- - OPTIONAL. Filter the list to include tasks where the name matches this prefix. - If unspecified, no task name filtering is done. - schema: - type: string - - name: state - description: |- - OPTIONAL. Filter tasks by state. If unspecified, - no task state filtering is done. - in: query - required: false - schema: - $ref: '#/components/schemas/tesState' - - name: tag_key - description: |- - OPTIONAL. Provide key tag to filter. The field tag_key is an array - of key values, and will be zipped with an optional tag_value array. - So the query: - ``` - ?tag_key=foo1&tag_value=bar1&tag_key=foo2&tag_value=bar2 - ``` - Should be constructed into the structure { "foo1" : "bar1", "foo2" : "bar2"} - - ``` - ?tag_key=foo1 - ``` - Should be constructed into the structure {"foo1" : ""} - - If the tag_value is empty, it will be treated as matching any possible value. - If a tag value is provided, both the tag's key and value must be exact - matches for a task to be returned. - Filter Tags Match? - ---------------------------------------------------------------------- - {"foo": "bar"} {"foo": "bar"} Yes - {"foo": "bar"} {"foo": "bat"} No - {"foo": ""} {"foo": ""} Yes - {"foo": "bar", "baz": "bat"} {"foo": "bar", "baz": "bat"} Yes - {"foo": "bar"} {"foo": "bar", "baz": "bat"} Yes - {"foo": "bar", "baz": "bat"} {"foo": "bar"} No - {"foo": ""} {"foo": "bar"} Yes - {"foo": ""} {} No - in: query - required: false - schema: - type: array - items: - type: string - - name: tag_value - description: |- - OPTIONAL. The companion value field for tag_key - in: query - required: false - schema: - type: array - items: - type: string - - name: page_size - in: query - description: |- - Optional number of tasks to return in one page. - Must be less than 2048. Defaults to 256. - schema: - type: integer - format: int32 - - name: page_token - in: query - description: |- - OPTIONAL. Page token is used to retrieve the next page of results. - If unspecified, returns the first page of results. The value can be found - in the `next_page_token` field of the last returned result of ListTasks - schema: - type: string - - $ref: '#/components/parameters/view' - - responses: - 200: - description: "" - content: - application/json: - schema: - $ref: '#/components/schemas/tesListTasksResponse' - post: - tags: - - TaskService - summary: CreateTask - description: |- - Create a new task. The user provides a Task document, which the server - uses as a basis and adds additional fields. - operationId: CreateTask - requestBody: - content: - application/json: - schema: - $ref: '#/components/schemas/tesTask' - required: true - responses: - 200: - description: "" - content: - application/json: - schema: - $ref: '#/components/schemas/tesCreateTaskResponse' - x-codegen-request-body-name: body - /tasks/{id}: - get: - tags: - - TaskService - summary: GetTask - description: |- - Get a single task, based on providing the exact task ID string. - operationId: GetTask - parameters: - - name: id - in: path - required: true - description: ID of task to retrieve. - schema: - type: string - - $ref: '#/components/parameters/view' - responses: - 200: - description: "" - content: - application/json: - schema: - $ref: '#/components/schemas/tesTask' - /tasks/{id}:cancel: - post: - tags: - - TaskService - summary: CancelTask - description: Cancel a task based on providing an exact task ID. - operationId: CancelTask - parameters: - - name: id - in: path - description: ID of task to be canceled. - required: true - schema: - type: string - responses: - 200: - description: "" - content: - application/json: - schema: - $ref: '#/components/schemas/tesCancelTaskResponse' -components: - parameters: - view: - name: view - in: query - description: |- - OPTIONAL. Affects the fields included in the returned Task messages. - - `MINIMAL`: Task message will include ONLY the fields: - - `tesTask.Id` - - `tesTask.State` - - `BASIC`: Task message will include all fields EXCEPT: - - `tesTask.ExecutorLog.stdout` - - `tesTask.ExecutorLog.stderr` - - `tesInput.content` - - `tesTaskLog.system_logs` - - `FULL`: Task message includes all fields. - schema: - type: string - default: MINIMAL - enum: - - MINIMAL - - BASIC - - FULL - - schemas: - tesCancelTaskResponse: - type: object - description: CancelTaskResponse describes a response from the CancelTask endpoint. - tesCreateTaskResponse: - required: - - id - type: object - properties: - id: - type: string - description: Task identifier assigned by the server. - description: |- - CreateTaskResponse describes a response from the CreateTask endpoint. It - will include the task ID that can be used to look up the status of the job. - tesExecutor: - required: - - command - - image - type: object - properties: - image: - type: string - example: ubuntu:20.04 - description: |- - Name of the container image. The string will be passed as the image - argument to the containerization run command. Examples: - - `ubuntu` - - `quay.io/aptible/ubuntu` - - `gcr.io/my-org/my-image` - - `myregistryhost:5000/fedora/httpd:version1.0` - command: - type: array - description: |- - A sequence of program arguments to execute, where the first argument - is the program to execute (i.e. argv). Example: - ``` - { - "command" : ["/bin/md5", "/data/file1"] - } - ``` - items: - type: string - example: ["/bin/md5", "/data/file1"] - workdir: - type: string - description: |- - The working directory that the command will be executed in. - If not defined, the system will default to the directory set by - the container image. - example: /data/ - stdin: - type: string - description: |- - Path inside the container to a file which will be piped - to the executor's stdin. This must be an absolute path. This mechanism - could be used in conjunction with the input declaration to process - a data file using a tool that expects STDIN. - - For example, to get the MD5 sum of a file by reading it into the STDIN - ``` - { - "command" : ["/bin/md5"], - "stdin" : "/data/file1" - } - ``` - example: "/data/file1" - stdout: - type: string - description: |- - Path inside the container to a file where the executor's - stdout will be written to. Must be an absolute path. Example: - ``` - { - "stdout" : "/tmp/stdout.log" - } - ``` - example: "/tmp/stdout.log" - stderr: - type: string - description: |- - Path inside the container to a file where the executor's - stderr will be written to. Must be an absolute path. Example: - ``` - { - "stderr" : "/tmp/stderr.log" - } - ``` - example: "/tmp/stderr.log" - env: - type: object - additionalProperties: - type: string - description: |- - Enviromental variables to set within the container. Example: - ``` - { - "env" : { - "ENV_CONFIG_PATH" : "/data/config.file", - "BLASTDB" : "/data/GRC38", - "HMMERDB" : "/data/hmmer" - } - } - ``` - example: - "BLASTDB" : "/data/GRC38" - "HMMERDB" : "/data/hmmer" - ignore_error: - type: boolean - description: |- - Default behavior of running an array of executors is that execution - stops on the first error. If `ignore_error` is `True`, then the - runner will record error exit codes, but will continue on to the next - tesExecutor. - description: Executor describes a command to be executed, and its environment. - tesExecutorLog: - required: - - exit_code - type: object - properties: - start_time: - type: string - description: Time the executor started, in RFC 3339 format. - example: 2020-10-02T10:00:00-05:00 - end_time: - type: string - description: Time the executor ended, in RFC 3339 format. - example: 2020-10-02T11:00:00-05:00 - stdout: - type: string - description: |- - Stdout content. - - This is meant for convenience. No guarantees are made about the content. - Implementations may chose different approaches: only the head, only the tail, - a URL reference only, etc. - - In order to capture the full stdout client should set Executor.stdout - to a container file path, and use Task.outputs to upload that file - to permanent storage. - stderr: - type: string - description: |- - Stderr content. - - This is meant for convenience. No guarantees are made about the content. - Implementations may chose different approaches: only the head, only the tail, - a URL reference only, etc. - - In order to capture the full stderr client should set Executor.stderr - to a container file path, and use Task.outputs to upload that file - to permanent storage. - exit_code: - type: integer - description: Exit code. - format: int32 - description: ExecutorLog describes logging information related to an Executor. - tesFileType: - type: string - description: |- - Define if input/output element is a file or a directory. It is not required - that the user provide this value, but it is required that the server fill in the - value once the information is avalible at run time. - default: FILE - enum: - - FILE - - DIRECTORY - tesInput: - required: - - path - type: object - properties: - name: - type: string - description: - type: string - url: - type: string - description: |- - REQUIRED, unless "content" is set. - - URL in long term storage, for example: - - s3://my-object-store/file1 - - gs://my-bucket/file2 - - file:///path/to/my/file - - /path/to/my/file - example: s3://my-object-store/file1 - path: - type: string - description: |- - Path of the file inside the container. - Must be an absolute path. - example: /data/file1 - type: - $ref: '#/components/schemas/tesFileType' - content: - type: string - description: |- - File content literal. - - Implementations should support a minimum of 128 KiB in this field - and may define their own maximum. - - UTF-8 encoded - - If content is not empty, "url" must be ignored. - streamable: - type: boolean - description: |- - Indicate that a file resource could be accessed using a streaming - interface, ie a FUSE mounted s3 object. This flag indicates that - using a streaming mount, as opposed to downloading the whole file to - the local scratch space, may be faster despite the latency and - overhead. This does not mean that the backend will use a streaming - interface, as it may not be provided by the vendor, but if the - capacity is avalible it can be used without degrading the - performance of the underlying program. - description: Input describes Task input files. - tesListTasksResponse: - required: - - tasks - type: object - properties: - tasks: - type: array - description: |- - List of tasks. These tasks will be based on the original submitted - task document, but with other fields, such as the job state and - logging info, added/changed as the job progresses. - items: - $ref: '#/components/schemas/tesTask' - next_page_token: - type: string - description: |- - Token used to return the next page of results. This value can be used - in the `page_token` field of the next ListTasks request. - description: ListTasksResponse describes a response from the ListTasks endpoint. - tesOutput: - required: - - path - - url - type: object - properties: - name: - type: string - description: User-provided name of output file - description: - type: string - description: Optional users provided description field, can be used for documentation. - url: - type: string - description: |- - URL at which the TES server makes the output accessible after the task is complete. - When tesOutput.path contains wildcards, it must be a directory; see - `tesOutput.path_prefix` for details on how output URLs are constructed in this case. - For Example: - - `s3://my-object-store/file1` - - `gs://my-bucket/file2` - - `file:///path/to/my/file` - path: - type: string - description: |- - Absolute path of the file inside the container. - May contain pattern matching wildcards to select multiple outputs at once, but mind - implications for `tesOutput.url` and `tesOutput.path_prefix`. - Only wildcards defined in IEEE Std 1003.1-2017 (POSIX), 12.3 are supported; see - https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13 - path_prefix: - type: string - description: |- - Prefix to be removed from matching outputs if `tesOutput.path` contains wildcards; - output URLs are constructed by appending pruned paths to the directory specfied - in `tesOutput.url`. - Required if `tesOutput.path` contains wildcards, ignored otherwise. - type: - $ref: '#/components/schemas/tesFileType' - description: Output describes Task output files. - tesOutputFileLog: - required: - - path - - size_bytes - - url - type: object - properties: - url: - type: string - description: URL of the file in storage, e.g. s3://bucket/file.txt - path: - type: string - description: Path of the file inside the container. Must be an absolute - path. - size_bytes: - type: string - description: |- - Size of the file in bytes. Note, this is currently coded as a string - because official JSON doesn't support int64 numbers. - format: int64 - example: - - "1024" - description: |- - OutputFileLog describes a single output file. This describes - file details after the task has completed successfully, - for logging purposes. - tesResources: - type: object - properties: - cpu_cores: - type: integer - description: Requested number of CPUs - format: int32 - example: 4 - preemptible: - type: boolean - description: |- - Define if the task is allowed to run on preemptible compute instances, - for example, AWS Spot. This option may have no effect when utilized - on some backends that don't have the concept of preemptible jobs. - format: boolean - example: false - ram_gb: - type: number - description: Requested RAM required in gigabytes (GB) - format: double - example: 8 - disk_gb: - type: number - description: Requested disk size in gigabytes (GB) - format: double - example: 40 - zones: - type: array - description: |- - Request that the task be run in these compute zones. How this string - is utilized will be dependent on the backend system. For example, a - system based on a cluster queueing system may use this string to define - priorty queue to which the job is assigned. - items: - type: string - example: us-west-1 - backend_parameters: - type: object - additionalProperties: - type: string - description: |- - Key/value pairs for backend configuration. - ServiceInfo shall return a list of keys that a backend supports. - Keys are case insensitive. - It is expected that clients pass all runtime or hardware requirement key/values - that are not mapped to existing tesResources properties to backend_parameters. - Backends shall log system warnings if a key is passed that is unsupported. - Backends shall not store or return unsupported keys if included in a task. - If backend_parameters_strict equals true, - backends should fail the task if any key/values are unsupported, otherwise, - backends should attempt to run the task - Intended uses include VM size selection, coprocessor configuration, etc. - Example: - ``` - { - "backend_parameters" : { - "VmSize" : "Standard_D64_v3" - } - } - ``` - example: - "VmSize" : "Standard_D64_v3" - backend_parameters_strict: - type: boolean - description: |- - If set to true, backends should fail the task if any backend_parameters - key/values are unsupported, otherwise, backends should attempt to run the task - format: boolean - default: false - example: false - description: Resources describes the resources requested by a task. - tesServiceType: - allOf: - - $ref: 'https://raw.githubusercontent.com/ga4gh-discovery/ga4gh-service-info/v1.0.0/service-info.yaml#/components/schemas/ServiceType' - - type: object - required: - - artifact - properties: - artifact: - type: string - enum: [tes] - example: tes - tesServiceInfo: - allOf: - - $ref: 'https://raw.githubusercontent.com/ga4gh-discovery/ga4gh-service-info/v1.0.0/service-info.yaml#/components/schemas/Service' - - type: object - properties: - storage: - type: array - description: |- - Lists some, but not necessarily all, storage locations supported - by the service. - items: - type: string - example: - - file:///path/to/local/funnel-storage - - s3://ohsu-compbio-funnel/storage - tesResources_backend_parameters: - type: array - description: |- - Lists all tesResources.backend_parameters keys supported - by the service - items: - type: string - example: ["VmSize"] - type: - $ref: '#/components/schemas/tesServiceType' - tesState: - type: string - readOnly: True - description: |- - Task state as defined by the server. - - - `UNKNOWN`: The state of the task is unknown. The cause for this status - message may be dependent on the underlying system. The `UNKNOWN` states - provides a safe default for messages where this field is missing so - that a missing field does not accidentally imply that - the state is QUEUED. - - `QUEUED`: The task is queued and awaiting resources to begin computing. - - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. - For example, the worker may be turning on, downloading input files, etc. - - `RUNNING`: The task is running. Input files are downloaded and the first Executor - has been started. - - `PAUSED`: The task is paused. The reasons for this would be tied to - the specific system running the job. An implementation may have the ability - to pause a task, but this is not required. - - `COMPLETE`: The task has completed running. Executors have exited without error - and output files have been successfully uploaded. - - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, - this means that an Executor exited with a non-zero exit code. - - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, - for example an upload failed due to network issues, the worker's ran out - of disk space, etc. - - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - - `CANCELING`: The task was canceled by the user, - but the downstream resources are still awaiting deletion. - - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to - the specific system running the job. Generally, this means that the system reclaimed the compute - capacity for reallocation. - default: UNKNOWN - example: COMPLETE - enum: - - UNKNOWN - - QUEUED - - INITIALIZING - - RUNNING - - PAUSED - - COMPLETE - - EXECUTOR_ERROR - - SYSTEM_ERROR - - CANCELED - - PREEMPTED - - CANCELING - tesTask: - required: - - executors - type: object - properties: - id: - type: string - description: Task identifier assigned by the server. - readOnly: true - example: job-0012345 - state: - $ref: '#/components/schemas/tesState' - name: - type: string - description: User-provided task name. - description: - type: string - description: |- - Optional user-provided description of task for documentation purposes. - inputs: - type: array - description: |- - Input files that will be used by the task. Inputs will be downloaded - and mounted into the executor container as defined by the task request - document. - items: - $ref: '#/components/schemas/tesInput' - example: - - { "url" : "s3://my-object-store/file1", "path" : "/data/file1" } - outputs: - type: array - description: |- - Output files. - Outputs will be uploaded from the executor container to long-term storage. - items: - $ref: '#/components/schemas/tesOutput' - example: - - { "path" : "/data/outfile", "url" : "s3://my-object-store/outfile-1", type: "FILE" } - resources: - $ref: '#/components/schemas/tesResources' - executors: - type: array - description: |- - An array of executors to be run. Each of the executors will run one - at a time sequentially. Each executor is a different command that - will be run, and each can utilize a different docker image. But each of - the executors will see the same mapped inputs and volumes that are declared - in the parent CreateTask message. - - Execution stops on the first error. - items: - $ref: '#/components/schemas/tesExecutor' - volumes: - type: array - example: - - "/vol/A/" - description: |- - Volumes are directories which may be used to share data between - Executors. Volumes are initialized as empty directories by the - system when the task starts and are mounted at the same path - in each Executor. - - For example, given a volume defined at `/vol/A`, - executor 1 may write a file to `/vol/A/exec1.out.txt`, then - executor 2 may read from that file. - - (Essentially, this translates to a `docker run -v` flag where - the container path is the same for each executor). - items: - type: string - tags: - type: object - example: - "WORKFLOW_ID" : "cwl-01234" - "PROJECT_GROUP" : "alice-lab" - - additionalProperties: - type: string - description: |- - A key-value map of arbitrary tags. These can be used to store meta-data - and annotations about a task. Example: - ``` - { - "tags" : { - "WORKFLOW_ID" : "cwl-01234", - "PROJECT_GROUP" : "alice-lab" - } - } - ``` - logs: - type: array - description: |- - Task logging information. - Normally, this will contain only one entry, but in the case where - a task fails and is retried, an entry will be appended to this list. - readOnly: true - items: - $ref: '#/components/schemas/tesTaskLog' - creation_time: - type: string - description: |- - Date + time the task was created, in RFC 3339 format. - This is set by the system, not the client. - example: 2020-10-02T10:00:00-05:00 - readOnly: true - description: Task describes an instance of a task. - tesTaskLog: - required: - - logs - - outputs - type: object - properties: - logs: - type: array - description: Logs for each executor - items: - $ref: '#/components/schemas/tesExecutorLog' - metadata: - type: object - additionalProperties: - type: string - description: Arbitrary logging metadata included by the implementation. - example: - host: worker-001 - slurmm_id: 123456 - start_time: - type: string - description: When the task started, in RFC 3339 format. - example: 2020-10-02T10:00:00-05:00 - end_time: - type: string - description: When the task ended, in RFC 3339 format. - example: 2020-10-02T11:00:00-05:00 - outputs: - type: array - description: |- - Information about all output files. Directory outputs are - flattened into separate items. - items: - $ref: '#/components/schemas/tesOutputFileLog' - system_logs: - type: array - description: |- - System logs are any logs the system decides are relevant, - which are not tied directly to an Executor process. - Content is implementation specific: format, size, etc. - - System logs may be collected here to provide convenient access. - - For example, the system may include the name of the host - where the task is executing, an error message that caused - a SYSTEM_ERROR state (e.g. disk is full), etc. - - System logs are only included in the FULL task view. - items: - type: string - description: TaskLog describes logging information related to a Task. - From 27bab170b9c3cdc578477689cfbe4e7e3440010b Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 10:56:08 +0400 Subject: [PATCH 24/92] refactoring, fixes, tests improvement --- .github/workflows/ci.yml | 4 ++ .gitignore | 2 + Cargo.toml | 1 + README.md | 12 ++-- build-models.sh | 3 +- lib/src/lib.rs | 9 +-- lib/src/serviceinfo/mod.rs | 132 +++++-------------------------------- lib/src/tes/mod.rs | 122 ++++------------------------------ lib/src/test_utils.rs | 35 ++++++++++ lib/src/transport.rs | 83 ++++++----------------- run-tests.sh | 39 +++++++++++ 11 files changed, 146 insertions(+), 296 deletions(-) create mode 100644 lib/src/test_utils.rs create mode 100755 run-tests.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 4f0c603..5b70c76 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -11,8 +11,12 @@ jobs: - uses: actions/checkout@v2 - name: Install Rust run: rustup update stable + - name: Build models + run: ./build-models.sh - name: Build run: cargo build --verbose + - name: Run custom tests + run: ./run-tests.sh - name: Run tests run: cargo test --verbose - name: Lint diff --git a/.gitignore b/.gitignore index 7a66fa9..4b3efcc 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,6 @@ node_modules/ target/ .vscode lib/src/**/models/ +*.log +funnel-work-dir/ diff --git a/Cargo.toml b/Cargo.toml index 94be5cb..f3888cf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ url = "^2.2" uuid = { version = "^1.0", features = ["serde", "v4"] } log = "0.4" env_logger = "0.9" +once_cell = "1.8.0" [dependencies.reqwest] version = "^0.11" diff --git a/README.md b/README.md index 5ee79f6..4eedaf9 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,6 @@ # A Generic SDK and CLI for GA4GH API services - -# Building +## Building First, clone the repository, and then run the following command to auto-generate models using OpenAPI specifications: ``` @@ -13,7 +12,12 @@ To build the project: cargo build ``` -To run the tests: +## Running the tests + +Before running the tests, you need to install Funnel, a task execution system that is compatible with the GA4GH TES API. Follow the instructions in the [Funnel Developer's Guide](https://ohsu-comp-bio.github.io/funnel/docs/development/developers/) to install Funnel. + +Once you have installed Funnel, you can run the tests with: + ``` -cargo test +bash ./run-test.sh ``` \ No newline at end of file diff --git a/build-models.sh b/build-models.sh index 01343ee..d4d77a1 100755 --- a/build-models.sh +++ b/build-models.sh @@ -54,7 +54,8 @@ generate_openapi_models() { # Modify the import statements in each generated file for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do - sed -i '' "s/use crate::models;/use crate::$API_NAME::models;/" "$file" + # sed -i '' "s/use crate::models;/use crate::$API_NAME::models;/" "$file" + sed -i '' "s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" "$file" done rm -rf "$DESTINATION_DIR/models" diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 27da2ce..f6a6bd0 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -1,13 +1,8 @@ -#![allow(unused_imports)] - #[macro_use] extern crate serde_derive; -extern crate serde; -extern crate serde_json; -extern crate url; -extern crate reqwest; - +#[cfg(test)] +mod test_utils; pub mod tes; pub mod transport; diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 10d2ee5..a55cfad 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -1,5 +1,4 @@ -pub(crate) mod models; - +pub mod models; use crate::transport::Transport; use crate::configuration::Configuration; @@ -9,15 +8,16 @@ pub struct ServiceInfo { } impl ServiceInfo { - pub fn new(transport: Transport)-> Self{ - Self { transport } + pub fn new(config: &Configuration) -> Result> { + let transport = &Transport::new(config); + let instance = ServiceInfo { + transport: transport.clone(), + }; + Ok(instance) } - pub async fn get_service_info(&self) -> Result> { - - let configuration = &self.transport.config; - let url = format!("{}/service-info", configuration.base_path); - let response = self.transport.get(&url,None).await; + pub async fn get(&self) -> Result> { + let response = self.transport.get("/service-info", None).await; match response { Ok(response_body) => { match serde_json::from_str::(&response_body) { @@ -41,9 +41,9 @@ impl ServiceInfo { #[cfg(test)] mod tests { - use super::*; - use std::ptr::eq; - use mockall::predicate::*; + use crate::test_utils::{setup, ensure_funnel_running}; + use crate::serviceinfo::ServiceInfo; + use crate::configuration::Configuration; use tokio; #[tokio::test] @@ -64,15 +64,14 @@ mod tests { } #[tokio::test] async fn test_get_service_info_from_funnel() { - // Initialize the Transport struct to point to your local Funnel server - let config = Configuration::new("http://localhost:8000".to_string(), None, None); - let transport = Transport::new(&config); - - // Create a ServiceInfo instance using the local Transport - let service_info = ServiceInfo::new(transport); + setup(); + let mut config = Configuration::default(); + let funnel_url = ensure_funnel_running().await; + config.set_base_path(&funnel_url); + let service_info = ServiceInfo::new(&config).unwrap(); // Call get_service_info and print the result - match service_info.get_service_info().await { + match service_info.get().await { Ok(service) => { println!("Service Info: {:?}", service); }, @@ -82,98 +81,3 @@ mod tests { } } } - -// CHECK WHAT ALL ARE REQUIRED - -// use std::error; -// use std::fmt; - -// #[derive(Debug, Clone)] -// pub struct ResponseContent { -// pub status: reqwest::StatusCode, -// pub content: String, -// pub entity: Option, -// } - -// #[derive(Debug)] -// pub enum Error { -// Reqwest(reqwest::Error), -// Serde(serde_json::Error), -// Io(std::io::Error), -// ResponseError(ResponseContent), -// } - -// impl fmt::Display for Error { -// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -// let (module, e) = match self { -// Error::Reqwest(e) => ("reqwest", e.to_string()), -// Error::Serde(e) => ("serde", e.to_string()), -// Error::Io(e) => ("IO", e.to_string()), -// Error::ResponseError(e) => ("response", format!("status code {}", e.status)), -// }; -// write!(f, "error in {}: {}", module, e) -// } -// } - -// impl error::Error for Error { -// fn source(&self) -> Option<&(dyn error::Error + 'static)> { -// Some(match self { -// Error::Reqwest(e) => e, -// Error::Serde(e) => e, -// Error::Io(e) => e, -// Error::ResponseError(_) => return None, -// }) -// } -// } - -// impl From for Error { -// fn from(e: reqwest::Error) -> Self { -// Error::Reqwest(e) -// } -// } - -// impl From for Error { -// fn from(e: serde_json::Error) -> Self { -// Error::Serde(e) -// } -// } - -// impl From for Error { -// fn from(e: std::io::Error) -> Self { -// Error::Io(e) -// } -// } - -// pub fn urlencode>(s: T) -> String { -// ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() -// } - -// pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { -// if let serde_json::Value::Object(object) = value { -// let mut params = vec![]; - -// for (key, value) in object { -// match value { -// serde_json::Value::Object(_) => params.append(&mut parse_deep_object( -// &format!("{}[{}]", prefix, key), -// value, -// )), -// serde_json::Value::Array(array) => { -// for (i, value) in array.iter().enumerate() { -// params.append(&mut parse_deep_object( -// &format!("{}[{}][{}]", prefix, key, i), -// value, -// )); -// } -// }, -// serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), -// _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), -// } -// } - -// return params; -// } - -// unimplemented!("Only objects are supported with style=deepObject") -// } - diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index a93ee09..fb49cc7 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,9 +1,7 @@ pub mod models; use crate::transport::Transport; use crate::serviceinfo::models::Service; -use models::service; -use reqwest::Response; -use serde::ser; +use serde_json; use serde_json::json; use crate::serviceinfo::ServiceInfo; use crate::configuration::Configuration; @@ -40,8 +38,8 @@ pub struct TES { impl TES { pub async fn new(config: &Configuration) -> Result> { let transport = &Transport::new(config); - let service_info = &ServiceInfo::new(transport.clone()); - let resp = service_info.get_service_info().await; + let service_info = &ServiceInfo::new(config).unwrap(); + let resp = service_info.get().await; // println!("artifact: {}",resp.clone().unwrap().r#type.artifact); let instance = TES { config: config.clone(), @@ -55,6 +53,7 @@ impl TES { Err("The endpoint is not an instance of TES".into()) } } + fn check(&self) -> bool { let resp = &self.service; return resp.as_ref().unwrap().r#type.artifact == "tes" @@ -68,8 +67,7 @@ impl TES { return Err("Service check failed".into()); } // todo: version in url based on serviceinfo or user config - let url = format!("{}/ga4gh/tes/v1/tasks", self.config.base_path); - let response = self.transport.post(&url, json!(task)).await; + let response = self.transport.post("/ga4gh/tes/v1/tasks", json!(task)).await; match response { Ok(response_body) => { match serde_json::from_str::(&response_body) { @@ -91,7 +89,7 @@ impl TES { pub async fn status(&self, task_id: &str, view: &str) -> Result> { // ?? move to Task::status() // todo: version in url based on serviceinfo or user config - let url = format!("{}/ga4gh/tes/v1/tasks/{}", self.config.base_path, task_id); + let url = format!("/ga4gh/tes/v1/tasks/{}", task_id); let params = [("view", view)]; let params_value = serde_json::json!(params); let response = self.transport.get(&url, Some(params_value)).await; @@ -117,14 +115,17 @@ impl TES { #[cfg(test)] mod tests { + use crate::test_utils::{setup, ensure_funnel_running, FUNNEL_PORT}; use crate::tes::TES; use crate::configuration::Configuration; use crate::tes::models::TesTask; - use crate::tes::models::TesCreateTaskResponse; + // use crate::tes::models::TesCreateTaskResponse; async fn create_task() -> Result> { + setup(); let mut config = Configuration::default(); - config.set_base_path("http://localhost:8000"); // expecting TES/Funnel, TODO autorun + let funnel_url = ensure_funnel_running().await; + config.set_base_path(&funnel_url); let tes = TES::new(&config).await; let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); @@ -136,7 +137,8 @@ mod tests { #[tokio::test] async fn test_task_create() { - env_logger::init(); + setup(); + ensure_funnel_running().await; let task = create_task().await.expect("Failed to create task"); assert!(!task.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion @@ -144,106 +146,10 @@ mod tests { // #[tokio::test] // async fn test_task_status() { - // env_logger::init(); + // setup(); // let task = create_task().await.expect("Failed to create task"); // // Now use task to get the task status... // // todo: assert_eq!(task.status().await, which status?); // } } - -// not sure if we need the code bellow, it was autogenerated by openapi-generator as i understand -// struct for typed errors of method [`get_service_info`] -// #[derive(Debug, Clone, Serialize, Deserialize)] -// #[serde(untagged)] -// pub enum GetServiceInfoError { -// UnknownValue(serde_json::Value), -// } -// #[derive(Debug, Clone)] -// pub struct ResponseContent { -// pub status: reqwest::StatusCode, -// pub content: String, -// pub entity: Option, -// } - -// #[derive(Debug)] -// pub enum Error { -// Reqwest(reqwest::Error), -// Serde(serde_json::Error), -// Io(std::io::Error), -// ResponseError(ResponseContent), -// } - -// impl fmt::Display for Error { -// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { -// let (module, e) = match self { -// Error::Reqwest(e) => ("reqwest", e.to_string()), -// Error::Serde(e) => ("serde", e.to_string()), -// Error::Io(e) => ("IO", e.to_string()), -// Error::ResponseError(e) => ("response", format!("status code {}", e.status)), -// }; -// write!(f, "error in {}: {}", module, e) -// } -// } - -// impl error::Error for Error { -// fn source(&self) -> Option<&(dyn error::Error + 'static)> { -// Some(match self { -// Error::Reqwest(e) => e, -// Error::Serde(e) => e, -// Error::Io(e) => e, -// Error::ResponseError(_) => return None, -// }) -// } -// } - -// impl From for Error { -// fn from(e: reqwest::Error) -> Self { -// Error::Reqwest(e) -// } -// } - -// impl From for Error { -// fn from(e: serde_json::Error) -> Self { -// Error::Serde(e) -// } -// } - -// impl From for Error { -// fn from(e: std::io::Error) -> Self { -// Error::Io(e) -// } -// } - -// pub fn urlencode>(s: T) -> String { -// ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() -// } - -// pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { -// if let serde_json::Value::Object(object) = value { -// let mut params = vec![]; - -// for (key, value) in object { -// match value { -// serde_json::Value::Object(_) => params.append(&mut parse_deep_object( -// &format!("{}[{}]", prefix, key), -// value, -// )), -// serde_json::Value::Array(array) => { -// for (i, value) in array.iter().enumerate() { -// params.append(&mut parse_deep_object( -// &format!("{}[{}][{}]", prefix, key, i), -// value, -// )); -// } -// }, -// serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), -// _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), -// } -// } - -// return params; -// } - -// unimplemented!("Only objects are supported with style=deepObject") -// } diff --git a/lib/src/test_utils.rs b/lib/src/test_utils.rs new file mode 100644 index 0000000..5844f7d --- /dev/null +++ b/lib/src/test_utils.rs @@ -0,0 +1,35 @@ +use std::env; +use std::process::Command; +use std::str; +use log::info; +use std::sync::Once; + +pub const FUNNEL_HOST: &str = "http://localhost"; +pub const FUNNEL_PORT: u16 = 8000; +pub static INIT: Once = Once::new(); + +pub fn setup() { + INIT.call_once(|| { + env::set_var("RUST_LOG", "debug"); + env_logger::init(); + }); +} + +pub async fn ensure_funnel_running() -> String { + let output = Command::new("sh") + .arg("-c") + .arg("ps aux | grep '[f]unnel server run'") + .output() + .expect("Failed to execute command"); + + let output_str = str::from_utf8(&output.stdout).unwrap(); + + if output_str.is_empty() { + panic!("Funnel is not running."); + } else { + info!("Funnel is already running."); + } + + let funnel_url = format!("{}:{}", FUNNEL_HOST, FUNNEL_PORT); + funnel_url +} \ No newline at end of file diff --git a/lib/src/transport.rs b/lib/src/transport.rs index b4faca9..3fd53b4 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -1,9 +1,8 @@ -use reqwest::{Client, Response}; -use serde::Serialize; +use reqwest::Client; use serde_json::Value; use std::error::Error; -use std::fmt; use crate::configuration::Configuration; +use log::error; // note: could implement custom certs handling, such as in-TEE generated ephemerial certs #[derive(Clone)] @@ -27,8 +26,15 @@ impl Transport { data: Option, params: Option, ) -> Result> { + let full_url = format!("{}{}", self.config.base_path, endpoint); + let url = reqwest::Url::parse(&full_url); + if url.is_err() { + error!("Invalid endpoint (shouldn't contain base url): {}", endpoint); + return Err(Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid endpoint"))); + } + let resp = self.client - .request(method, endpoint) + .request(method, &full_url) .header(reqwest::header::USER_AGENT, self.config.user_agent.clone().unwrap_or_default()) .json(&data) .query(¶ms) @@ -64,78 +70,31 @@ impl Transport { // other HTTP methods can be added here } - -// impl Default for Transport { -// fn default() -> Self { -// Transport { -// base_path: "/ga4gh/tes/v1".to_owned(), -// user_agent: Some("OpenAPI-Generator/1.1.0/rust".to_owned()), -// client: reqwest::Client::new(), -// basic_auth: None, -// oauth_access_token: None, -// bearer_access_token: None, -// api_key: None, -// password: None, -// } -// } -// } - - - #[cfg(test)] mod tests { - use crate::{configuration::Configuration, transport::Transport}; - use reqwest::Method; - use serde_json::json; - use mockito::{mock, Matcher}; + use crate::test_utils::setup; + use crate::configuration::Configuration; + use crate::transport::Transport; + use mockito::mock; #[tokio::test] - async fn test_request_success() { + async fn test_request() { + setup(); let base_url = &mockito::server_url(); + // effectively no sense in testing various responses, as it's reqwest's responsibility + // we should test Transport's methods let _m = mock("GET", "/test") .with_status(200) .with_header("content-type", "application/json") - .with_body(r#"{"message": "success"}"#) + .with_body(r#"{"message": "success"}"#) .create(); - let config= Configuration::new(base_url.clone(), None, None); - + let config = Configuration::new(base_url.clone(), None, None); let transport = Transport::new(&config.clone()); - - let response = transport.request( - Method::GET, - &format!("{}/test", base_url), - None, - None, - ).await; + let response = transport.get("/test", None).await; assert!(response.is_ok()); let body = response.unwrap(); assert_eq!(body, r#"{"message": "success"}"#); } - - #[tokio::test] - async fn test_request_failure() { - let base_url = &mockito::server_url(); - let _m = mock("GET", "/test") - .with_status(404) - .with_header("content-type", "application/json") - .with_body(r#"{"message": "not found"}"#) - .create(); - - let config= Configuration::new(base_url.clone(), None, None); - - let transport = Transport::new(&config.clone()); - - let response = transport.request( - Method::GET, - &format!("{}/test", base_url), - None, - None, - ).await; - - assert!(response.is_err()); - let error = response.err().unwrap(); - assert_eq!(error.to_string(), r#"{"message": "not found"}"#); - } } \ No newline at end of file diff --git a/run-tests.sh b/run-tests.sh new file mode 100755 index 0000000..ebf2e0b --- /dev/null +++ b/run-tests.sh @@ -0,0 +1,39 @@ +#!/bin/bash + +# # Check if a "funnel" container is already running +# if [ $(docker ps -q -f name=funnel) ]; then +# # If it is, stop and remove it +# docker stop funnel +# docker rm funnel +# fi + +# # Build and run the Dockerized Funnel server +# cd funnel/ +# docker build -t funnel -f ./Dockerfile . +# docker run -d --name funnel -p 8000:8000 funnel +# cd .. + +# Check if a "funnel" process is already running +if ! ps aux | grep '[f]unnel server run'; then + # If it's not running, start it + echo "Funnel server is not running. Starting it now..." + funnel server run --Server.HostName=localhost --Server.HTTPPort=8000 > funnel.log 2>&1 & +else + echo "Funnel server is already running." +fi + +# Wait for the Funnel server to start +echo "Waiting for Funnel server to start..." +while ! curl -s http://localhost:8000/healthz > /dev/null +do + echo "Waiting for Funnel server..." + sleep 1 +done +echo "Funnel server is running." + +# Run the tests +cargo test + +# # Stop and remove the Funnel server container +# docker stop funnel +# docker rm funnel \ No newline at end of file From d656d3b6b82b4551727f36ef75b74a42a8997f7c Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:06:48 +0400 Subject: [PATCH 25/92] CI/CD workflow update --- .github/workflows/ci.yml | 105 +++++++++++++++++++++++++++++++++++---- .gitignore | 2 +- README.md | 7 ++- build-models.sh | 10 +++- 4 files changed, 111 insertions(+), 13 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5b70c76..0cada3d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,20 +6,107 @@ jobs: build: runs-on: ubuntu-latest + container: + image: ubuntu:20.04 + env: + OPENSSL_DIR: /usr/include/openssl + OPENSSL_LIB_DIR: /usr/lib/x86_64-linux-gnu + OPENSSL_INCLUDE_DIR: /usr/include/openssl steps: - - uses: actions/checkout@v2 + + - name: Cache Rust dependencies + uses: actions/cache@v2 + with: + path: ~/.cargo + key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-cargo- + + - name: Cache Rust build output + uses: actions/cache@v2 + with: + path: target + key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-build- + + - name: Cache Node.js dependencies + uses: actions/cache@v2 + with: + path: ~/.npm + key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} + restore-keys: ${{ runner.os }}-node- + + - name: Cache Maven dependencies + uses: actions/cache@v2 + with: + path: ~/.m2/repository + key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-maven- + + - name: Cache Go modules + uses: actions/cache@v2 + with: + path: ~/.cache/go-build + key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} + restore-keys: ${{ runner.os }}-go- + + - name: Cache Funnel dependencies + uses: actions/cache@v2 + with: + path: ~/funnel/build + key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} + restore-keys: ${{ runner.os }}-funnel- + - name: Install Rust - run: rustup update stable + run: | + apt-get update + apt-get install -y curl git build-essential libssl-dev + if ! command -v rustup &> /dev/null # might not be installed while executing using `act` + then + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + . $HOME/.cargo/env + fi + rustup update stable + - name: Install Node.js # required for build-models.sh + run: | + REQUIRED_NODE_VERSION=22 + if command -v node &> /dev/null; then + curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh + bash nodesource_setup.sh + apt-get install -y nodejs + fi + - name: Set up JDK 11 # required for build-models.sh + uses: actions/setup-java@v2 + with: + distribution: 'adopt' + java-version: '11' + - name: Install Go + uses: actions/setup-go@v2 + with: + go-version: '^1.22' + - name: Install Funnel + run: | + if [ -d "funnel" ]; then rm -Rf funnel; fi + git clone https://github.com/ohsu-comp-bio/funnel.git + cd funnel && make && make install && cd .. + - uses: actions/checkout@v2 # checkout the repository - name: Build models - run: ./build-models.sh + run: | + . $HOME/.cargo/env + bash ./build-models.sh - name: Build - run: cargo build --verbose - - name: Run custom tests - run: ./run-tests.sh + run: | + . $HOME/.cargo/env + cargo build --verbose - name: Run tests - run: cargo test --verbose + run: | + . $HOME/.cargo/env + bash ./run-tests.sh - name: Lint - run: cargo clippy -- -D warnings + run: | + . $HOME/.cargo/env + cargo clippy -- -D warnings - name: Format - run: cargo fmt -- --check + run: | + . $HOME/.cargo/env + cargo fmt -- --check \ No newline at end of file diff --git a/.gitignore b/.gitignore index 4b3efcc..f387ce0 100644 --- a/.gitignore +++ b/.gitignore @@ -8,4 +8,4 @@ target/ lib/src/**/models/ *.log funnel-work-dir/ - +funnel/ diff --git a/README.md b/README.md index 4eedaf9..426d8b1 100644 --- a/README.md +++ b/README.md @@ -16,8 +16,13 @@ cargo build Before running the tests, you need to install Funnel, a task execution system that is compatible with the GA4GH TES API. Follow the instructions in the [Funnel Developer's Guide](https://ohsu-comp-bio.github.io/funnel/docs/development/developers/) to install Funnel. -Once you have installed Funnel, you can run the tests with: +Once you have installed Funnel, you can run the tests with (it will automatically run Funnel as well): ``` bash ./run-test.sh +``` + +To test out the CI/CD workflow locally, install `act` and run the following command: +``` +act -j build --container-architecture linux/amd64 -P ubuntu-latest=ubuntu:20.04 --reuse ``` \ No newline at end of file diff --git a/build-models.sh b/build-models.sh index d4d77a1..53a692f 100755 --- a/build-models.sh +++ b/build-models.sh @@ -52,10 +52,16 @@ generate_openapi_models() { # Remove the openapitools.json file rm -f ./openapitools.json + echo "TEMP_OUTPUT_DIR is $TEMP_OUTPUT_DIR" # Modify the import statements in each generated file for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do - # sed -i '' "s/use crate::models;/use crate::$API_NAME::models;/" "$file" - sed -i '' "s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" "$file" + if [[ "$OSTYPE" == "darwin"* ]]; then + # macOS (BSD) sed syntax + sed -i '' "s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" "$file" + else + # Linux (GNU) sed syntax + sed -i "s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" "$file" + fi done rm -rf "$DESTINATION_DIR/models" From afbe68c0bf0a11614961b73a0f9510a168b00ed5 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:13:13 +0400 Subject: [PATCH 26/92] CI/CD workflow fix --- build-models.sh | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/build-models.sh b/build-models.sh index 53a692f..2f9bf5b 100755 --- a/build-models.sh +++ b/build-models.sh @@ -13,14 +13,14 @@ get_git_repo_name() { echo "$repo_name" } -repo_name=$(get_git_repo_name) -if [ "$repo_name" != "ga4gh-sdk" ]; then - echo "This script must be run from the 'ga4gh-sdk' repository." - exit 1 -fi - -cd $(git rev-parse --show-toplevel) -SCRIPT_DIR="$(pwd)" +# repo_name=$(get_git_repo_name) +# if [ "$repo_name" != "ga4gh-sdk" ]; then +# echo "This script must be run from the 'ga4gh-sdk' repository." +# exit 1 +# fi + +# cd $(git rev-parse --show-toplevel) +# SCRIPT_DIR="$(pwd)" generate_openapi_models() { # Parameters From da80b57fcb7fd2cfed4707405033b28c841a513f Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:18:15 +0400 Subject: [PATCH 27/92] CI/CD workflow fix --- build-models.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build-models.sh b/build-models.sh index 2f9bf5b..efaf49a 100755 --- a/build-models.sh +++ b/build-models.sh @@ -20,7 +20,7 @@ get_git_repo_name() { # fi # cd $(git rev-parse --show-toplevel) -# SCRIPT_DIR="$(pwd)" +SCRIPT_DIR="$(pwd)" generate_openapi_models() { # Parameters From a655a905c235433f141d93e55ccf50b854c4b9a3 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:28:46 +0400 Subject: [PATCH 28/92] CI/CD workflow fix --- build-models.sh | 6 ++++-- lib/src/tes/mod.rs | 5 ++++- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/build-models.sh b/build-models.sh index efaf49a..66ae80f 100755 --- a/build-models.sh +++ b/build-models.sh @@ -53,14 +53,16 @@ generate_openapi_models() { rm -f ./openapitools.json echo "TEMP_OUTPUT_DIR is $TEMP_OUTPUT_DIR" + # Modify the import statements in each generated file + SED_RULE="s/use crate::models;/#![allow(unused_imports)]\n#[allow(clippy::empty_docs)]\nuse crate::$API_NAME::models;/" for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do if [[ "$OSTYPE" == "darwin"* ]]; then # macOS (BSD) sed syntax - sed -i '' "s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" "$file" + sed -i '' "$SED_RULE" "$file" else # Linux (GNU) sed syntax - sed -i "s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" "$file" + sed -i "$SED_RULE" "$file" fi done diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index fb49cc7..2623901 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -12,10 +12,12 @@ use crate::tes::models::TesState; // *** // should TES.create return Task? which in turn can do status() and other existing-task-related stuff // instead of TES.status(task_id) we could do task.status() +#[allow(dead_code)] pub struct Task { id: String, } +#[allow(dead_code)] impl Task { pub fn new(id: String) -> Self { Task { @@ -29,7 +31,8 @@ impl Task { } pub struct TES { - config: Configuration, + #[allow(dead_code)] + config: Configuration, // not used yet service: Result>, transport: Transport, } From 6514f6e26c6bae1f5e30b4442b970d140c122b32 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:35:36 +0400 Subject: [PATCH 29/92] CI/CD workflow fix --- build-models.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build-models.sh b/build-models.sh index 66ae80f..071f6f2 100755 --- a/build-models.sh +++ b/build-models.sh @@ -55,7 +55,7 @@ generate_openapi_models() { echo "TEMP_OUTPUT_DIR is $TEMP_OUTPUT_DIR" # Modify the import statements in each generated file - SED_RULE="s/use crate::models;/#![allow(unused_imports)]\n#[allow(clippy::empty_docs)]\nuse crate::$API_NAME::models;/" + SED_RULE="s/use crate::models;/#![allow(unused_imports)]\n#![allow(clippy::empty_docs)]\nuse crate::$API_NAME::models;/" for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do if [[ "$OSTYPE" == "darwin"* ]]; then # macOS (BSD) sed syntax From e0bdcf5839cc139c322c43a37ed3afb45ddff6e4 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:41:05 +0400 Subject: [PATCH 30/92] commenting out non-finished Task struct that fails CI/CD --- lib/src/tes/mod.rs | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 2623901..b73f79f 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -12,23 +12,23 @@ use crate::tes::models::TesState; // *** // should TES.create return Task? which in turn can do status() and other existing-task-related stuff // instead of TES.status(task_id) we could do task.status() -#[allow(dead_code)] -pub struct Task { - id: String, -} +// #[allow(dead_code)] +// pub struct Task { +// id: String, +// } -#[allow(dead_code)] -impl Task { - pub fn new(id: String) -> Self { - Task { - id: id, - } - } +// #[allow(dead_code)] +// impl Task { +// pub fn new(id: String) -> Self { +// Task { +// id: id, +// } +// } - pub fn status(&self) -> Result> { - Ok(TesState::Running) - } -} +// pub fn status(&self) -> Result> { +// Ok(TesState::Running) +// } +// } pub struct TES { #[allow(dead_code)] From a1cd3bf901bd683dbd2c862fd9bc1cccf7ef3f27 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:50:20 +0400 Subject: [PATCH 31/92] applying code formating using --- .github/workflows/ci.yml | 2 +- lib/src/configuration.rs | 11 +++--- lib/src/lib.rs | 4 +-- lib/src/serviceinfo/mod.rs | 29 +++++++--------- lib/src/tes/mod.rs | 69 +++++++++++++++++++++----------------- lib/src/test_utils.rs | 4 +-- lib/src/transport.rs | 51 +++++++++++++++++++--------- 7 files changed, 98 insertions(+), 72 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0cada3d..17d6406 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -109,4 +109,4 @@ jobs: - name: Format run: | . $HOME/.cargo/env - cargo fmt -- --check \ No newline at end of file + cargo fmt \ No newline at end of file diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs index 2c5acab..8e2b8bd 100644 --- a/lib/src/configuration.rs +++ b/lib/src/configuration.rs @@ -1,5 +1,3 @@ - - #[derive(Debug, Clone)] pub struct Configuration { pub base_path: String, @@ -19,9 +17,12 @@ pub struct ApiKey { pub key: String, } - impl Configuration { - pub fn new(base_path: String, user_agent: Option, oauth_access_token: Option) -> Self { + pub fn new( + base_path: String, + user_agent: Option, + oauth_access_token: Option, + ) -> Self { Configuration { base_path, user_agent, @@ -49,4 +50,4 @@ impl Default for Configuration { api_key: None, } } -} \ No newline at end of file +} diff --git a/lib/src/lib.rs b/lib/src/lib.rs index f6a6bd0..5a3f1f7 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -4,7 +4,7 @@ extern crate serde_derive; #[cfg(test)] mod test_utils; +pub mod configuration; +pub mod serviceinfo; pub mod tes; pub mod transport; -pub mod serviceinfo; -pub mod configuration; \ No newline at end of file diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index a55cfad..23fc5ef 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -1,6 +1,6 @@ pub mod models; -use crate::transport::Transport; use crate::configuration::Configuration; +use crate::transport::Transport; #[derive(Clone)] pub struct ServiceInfo { @@ -19,31 +19,26 @@ impl ServiceInfo { pub async fn get(&self) -> Result> { let response = self.transport.get("/service-info", None).await; match response { - Ok(response_body) => { - match serde_json::from_str::(&response_body) { - Ok(tes_create_task_response) => Ok(tes_create_task_response), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - }, + Ok(response_body) => match serde_json::from_str::(&response_body) { + Ok(tes_create_task_response) => Ok(tes_create_task_response), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) } }, Err(e) => { log::error!("Error: {}", e); Err(e) - }, + } } } - } - - #[cfg(test)] mod tests { - use crate::test_utils::{setup, ensure_funnel_running}; - use crate::serviceinfo::ServiceInfo; use crate::configuration::Configuration; + use crate::serviceinfo::ServiceInfo; + use crate::test_utils::{ensure_funnel_running, setup}; use tokio; #[tokio::test] @@ -62,7 +57,7 @@ mod tests { // assert_eq!(result.unwrap().id, "test"); // assert_eq!(result.unwrap().name, "test"); } - #[tokio::test] + #[tokio::test] async fn test_get_service_info_from_funnel() { setup(); let mut config = Configuration::default(); @@ -74,10 +69,10 @@ mod tests { match service_info.get().await { Ok(service) => { println!("Service Info: {:?}", service); - }, + } Err(e) => { println!("Failed to get service info: {}", e); - }, + } } } } diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index b73f79f..195293a 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,13 +1,13 @@ pub mod models; -use crate::transport::Transport; +use crate::configuration::Configuration; use crate::serviceinfo::models::Service; -use serde_json; -use serde_json::json; use crate::serviceinfo::ServiceInfo; -use crate::configuration::Configuration; -use crate::tes::models::TesTask; use crate::tes::models::TesCreateTaskResponse; use crate::tes::models::TesState; +use crate::tes::models::TesTask; +use crate::transport::Transport; +use serde_json; +use serde_json::json; // *** // should TES.create return Task? which in turn can do status() and other existing-task-related stuff @@ -59,18 +59,24 @@ impl TES { fn check(&self) -> bool { let resp = &self.service; - return resp.as_ref().unwrap().r#type.artifact == "tes" + return resp.as_ref().unwrap().r#type.artifact == "tes"; } - pub async fn create(&self, task: TesTask/*, params: models::TesTask*/) -> Result> { + pub async fn create( + &self, + task: TesTask, /*, params: models::TesTask*/ + ) -> Result> { // First, check if the service is of TES class if !self.check() { - // If check fails, log an error and return an Err immediately - log::error!("Service check failed"); - return Err("Service check failed".into()); + // If check fails, log an error and return an Err immediately + log::error!("Service check failed"); + return Err("Service check failed".into()); } // todo: version in url based on serviceinfo or user config - let response = self.transport.post("/ga4gh/tes/v1/tasks", json!(task)).await; + let response = self + .transport + .post("/ga4gh/tes/v1/tasks", json!(task)) + .await; match response { Ok(response_body) => { match serde_json::from_str::(&response_body) { @@ -78,18 +84,22 @@ impl TES { Err(e) => { log::error!("Failed to deserialize response: {}", e); Err("Failed to deserialize response".into()) - }, + } } - }, + } Err(e) => { log::error!("Error: {}", e); Err(e) - }, + } } } // pub async fn status(&self, task: &TesCreateTaskResponse) -> Result> { - pub async fn status(&self, task_id: &str, view: &str) -> Result> { + pub async fn status( + &self, + task_id: &str, + view: &str, + ) -> Result> { // ?? move to Task::status() // todo: version in url based on serviceinfo or user config let url = format!("/ga4gh/tes/v1/tasks/{}", task_id); @@ -97,19 +107,17 @@ impl TES { let params_value = serde_json::json!(params); let response = self.transport.get(&url, Some(params_value)).await; match response { - Ok(response_body) => { - match serde_json::from_str::(&response_body) { - Ok(tes_state) => Ok(tes_state), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - }, + Ok(response_body) => match serde_json::from_str::(&response_body) { + Ok(tes_state) => Ok(tes_state), + Err(e) => { + log::error!("Failed to deserialize response: {}", e); + Err("Failed to deserialize response".into()) } }, Err(e) => { log::error!("Error: {}", e); Err(e) - }, + } } } @@ -118,10 +126,10 @@ impl TES { #[cfg(test)] mod tests { - use crate::test_utils::{setup, ensure_funnel_running, FUNNEL_PORT}; - use crate::tes::TES; use crate::configuration::Configuration; use crate::tes::models::TesTask; + use crate::tes::TES; + use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; async fn create_task() -> Result> { @@ -130,10 +138,11 @@ mod tests { let funnel_url = ensure_funnel_running().await; config.set_base_path(&funnel_url); let tes = TES::new(&config).await; - - let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); + + let task_json = + std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); - + let task = tes?.create(task).await?; Ok(task.id) } @@ -142,7 +151,7 @@ mod tests { async fn test_task_create() { setup(); ensure_funnel_running().await; - + let task = create_task().await.expect("Failed to create task"); assert!(!task.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion } @@ -150,7 +159,7 @@ mod tests { // #[tokio::test] // async fn test_task_status() { // setup(); - + // let task = create_task().await.expect("Failed to create task"); // // Now use task to get the task status... // // todo: assert_eq!(task.status().await, which status?); diff --git a/lib/src/test_utils.rs b/lib/src/test_utils.rs index 5844f7d..2f44482 100644 --- a/lib/src/test_utils.rs +++ b/lib/src/test_utils.rs @@ -1,7 +1,7 @@ +use log::info; use std::env; use std::process::Command; use std::str; -use log::info; use std::sync::Once; pub const FUNNEL_HOST: &str = "http://localhost"; @@ -32,4 +32,4 @@ pub async fn ensure_funnel_running() -> String { let funnel_url = format!("{}:{}", FUNNEL_HOST, FUNNEL_PORT); funnel_url -} \ No newline at end of file +} diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 3fd53b4..5bd434b 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -1,8 +1,8 @@ +use crate::configuration::Configuration; +use log::error; use reqwest::Client; use serde_json::Value; use std::error::Error; -use crate::configuration::Configuration; -use log::error; // note: could implement custom certs handling, such as in-TEE generated ephemerial certs #[derive(Clone)] @@ -29,13 +29,23 @@ impl Transport { let full_url = format!("{}{}", self.config.base_path, endpoint); let url = reqwest::Url::parse(&full_url); if url.is_err() { - error!("Invalid endpoint (shouldn't contain base url): {}", endpoint); - return Err(Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid endpoint"))); + error!( + "Invalid endpoint (shouldn't contain base url): {}", + endpoint + ); + return Err(Box::new(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "Invalid endpoint", + ))); } - let resp = self.client + let resp = self + .client .request(method, &full_url) - .header(reqwest::header::USER_AGENT, self.config.user_agent.clone().unwrap_or_default()) + .header( + reqwest::header::USER_AGENT, + self.config.user_agent.clone().unwrap_or_default(), + ) .json(&data) .query(¶ms) .send() @@ -47,24 +57,35 @@ impl Transport { if status.is_success() { Ok(content) } else { - Err(Box::new(std::io::Error::new(std::io::ErrorKind::Other, content))) + Err(Box::new(std::io::Error::new( + std::io::ErrorKind::Other, + content, + ))) } } - pub async fn get(&self, endpoint: &str, params: Option) -> Result> { - self.request(reqwest::Method::GET, endpoint, None, params).await + pub async fn get( + &self, + endpoint: &str, + params: Option, + ) -> Result> { + self.request(reqwest::Method::GET, endpoint, None, params) + .await } pub async fn post(&self, endpoint: &str, data: Value) -> Result> { - self.request(reqwest::Method::POST, endpoint, Some(data), None).await + self.request(reqwest::Method::POST, endpoint, Some(data), None) + .await } pub async fn put(&self, endpoint: &str, data: Value) -> Result> { - self.request(reqwest::Method::PUT, endpoint, Some(data), None).await + self.request(reqwest::Method::PUT, endpoint, Some(data), None) + .await } pub async fn delete(&self, endpoint: &str) -> Result> { - self.request(reqwest::Method::DELETE, endpoint, None, None).await + self.request(reqwest::Method::DELETE, endpoint, None, None) + .await } // other HTTP methods can be added here @@ -72,8 +93,8 @@ impl Transport { #[cfg(test)] mod tests { - use crate::test_utils::setup; use crate::configuration::Configuration; + use crate::test_utils::setup; use crate::transport::Transport; use mockito::mock; @@ -86,7 +107,7 @@ mod tests { let _m = mock("GET", "/test") .with_status(200) .with_header("content-type", "application/json") - .with_body(r#"{"message": "success"}"#) + .with_body(r#"{"message": "success"}"#) .create(); let config = Configuration::new(base_url.clone(), None, None); @@ -97,4 +118,4 @@ mod tests { let body = response.unwrap(); assert_eq!(body, r#"{"message": "success"}"#); } -} \ No newline at end of file +} From 97595e02c9f824b8a111b19cd703b7e5334e7c60 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 24 Jun 2024 16:54:54 +0400 Subject: [PATCH 32/92] rustfmt.toml: ignore code formatting checks of the autogenerated models --- .github/workflows/ci.yml | 6 +++++- rustfmt.toml | 4 ++++ 2 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 rustfmt.toml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 17d6406..de45f35 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -109,4 +109,8 @@ jobs: - name: Format run: | . $HOME/.cargo/env - cargo fmt \ No newline at end of file + # rustup install nightly – fails for some reason + # rustup default nightly + cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting + cargo fmt -- ./lib/src/tes/models/*.rs + cargo fmt -- --check # --config-path ./rustfmt.toml \ No newline at end of file diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..62437b6 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,4 @@ +ignore = [ + "lib/serviceinfo/models", + "lib/tes/models", +] \ No newline at end of file From a6b63aca0055014fdc5c8519b7df4dc4f2995ca6 Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 26 Jun 2024 12:35:08 +0530 Subject: [PATCH 33/92] changed return type of create to Task --- lib/src/tes/mod.rs | 43 +++++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 195293a..abedb71 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -2,7 +2,6 @@ pub mod models; use crate::configuration::Configuration; use crate::serviceinfo::models::Service; use crate::serviceinfo::ServiceInfo; -use crate::tes::models::TesCreateTaskResponse; use crate::tes::models::TesState; use crate::tes::models::TesTask; use crate::transport::Transport; @@ -12,23 +11,22 @@ use serde_json::json; // *** // should TES.create return Task? which in turn can do status() and other existing-task-related stuff // instead of TES.status(task_id) we could do task.status() -// #[allow(dead_code)] -// pub struct Task { -// id: String, -// } - -// #[allow(dead_code)] -// impl Task { -// pub fn new(id: String) -> Self { -// Task { -// id: id, -// } -// } - -// pub fn status(&self) -> Result> { -// Ok(TesState::Running) -// } -// } +#[derive(Serialize, Deserialize)] +pub struct Task { + id: String, +} + +impl Task { + pub fn new(id: String) -> Self { + Task { + id, + } + } + + pub fn status(&self) -> Result> { + Ok(TesState::Running) + } +} pub struct TES { #[allow(dead_code)] @@ -65,7 +63,7 @@ impl TES { pub async fn create( &self, task: TesTask, /*, params: models::TesTask*/ - ) -> Result> { + ) -> Result> { // First, check if the service is of TES class if !self.check() { // If check fails, log an error and return an Err immediately @@ -79,7 +77,7 @@ impl TES { .await; match response { Ok(response_body) => { - match serde_json::from_str::(&response_body) { + match serde_json::from_str::(&response_body) { Ok(tes_create_task_response) => Ok(tes_create_task_response), Err(e) => { log::error!("Failed to deserialize response: {}", e); @@ -98,7 +96,7 @@ impl TES { pub async fn status( &self, task_id: &str, - view: &str, + view: &str,// 'view' controls the level of detail in the response. Expected values: "MINIMAL","BASIC" or "FULL". ) -> Result> { // ?? move to Task::status() // todo: version in url based on serviceinfo or user config @@ -129,7 +127,8 @@ mod tests { use crate::configuration::Configuration; use crate::tes::models::TesTask; use crate::tes::TES; - use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; + use crate::test_utils::{ensure_funnel_running, setup}; + // use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; async fn create_task() -> Result> { From 431a83114695f62ce4910642a13206457735d2dc Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 26 Jun 2024 15:56:11 +0530 Subject: [PATCH 34/92] added status to Task --- build-models.sh | 2 +- lib/src/tes/mod.rs | 8 ++++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/build-models.sh b/build-models.sh index 071f6f2..d16ea4d 100755 --- a/build-models.sh +++ b/build-models.sh @@ -55,7 +55,7 @@ generate_openapi_models() { echo "TEMP_OUTPUT_DIR is $TEMP_OUTPUT_DIR" # Modify the import statements in each generated file - SED_RULE="s/use crate::models;/#![allow(unused_imports)]\n#![allow(clippy::empty_docs)]\nuse crate::$API_NAME::models;/" + SED_RULE="s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do if [[ "$OSTYPE" == "darwin"* ]]; then # macOS (BSD) sed syntax diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index abedb71..bc14c8d 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -23,8 +23,12 @@ impl Task { } } - pub fn status(&self) -> Result> { - Ok(TesState::Running) + pub async fn status(&self) -> Result> { + let task_id=&self.id; + let url = format!("/ga4gh/tes/v1/tasks/{}", task_id.clone()); + let config = Configuration::new(url, None, None); + let tes=TES::new(&config).await; + tes?.status(&task_id.clone(), "BASIC").await } } From e447b5a2267ef74e7641c5e3b38acb367878fe96 Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 26 Jun 2024 16:00:49 +0530 Subject: [PATCH 35/92] corrected CI/CD --- build-models.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build-models.sh b/build-models.sh index d16ea4d..071f6f2 100755 --- a/build-models.sh +++ b/build-models.sh @@ -55,7 +55,7 @@ generate_openapi_models() { echo "TEMP_OUTPUT_DIR is $TEMP_OUTPUT_DIR" # Modify the import statements in each generated file - SED_RULE="s/use crate::models;/#![allow(unused_imports)]\nuse crate::$API_NAME::models;/" + SED_RULE="s/use crate::models;/#![allow(unused_imports)]\n#![allow(clippy::empty_docs)]\nuse crate::$API_NAME::models;/" for file in $(find "$TEMP_OUTPUT_DIR" -name '*.rs'); do if [[ "$OSTYPE" == "darwin"* ]]; then # macOS (BSD) sed syntax From bcce6ecc7b091e3cb90c44a8686a9c5359fc7686 Mon Sep 17 00:00:00 2001 From: aaravm Date: Wed, 26 Jun 2024 18:55:27 +0530 Subject: [PATCH 36/92] trying out tes_status unit tests --- README.md | 2 +- lib/src/serviceinfo/mod.rs | 4 ++-- lib/src/tes/mod.rs | 42 +++++++++++++++++++++++--------------- 3 files changed, 28 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 426d8b1..ec17429 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ Before running the tests, you need to install Funnel, a task execution system th Once you have installed Funnel, you can run the tests with (it will automatically run Funnel as well): ``` -bash ./run-test.sh +bash ./run-tests.sh ``` To test out the CI/CD workflow locally, install `act` and run the following command: diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index 23fc5ef..beae67f 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -20,10 +20,10 @@ impl ServiceInfo { let response = self.transport.get("/service-info", None).await; match response { Ok(response_body) => match serde_json::from_str::(&response_body) { - Ok(tes_create_task_response) => Ok(tes_create_task_response), + Ok(service) => Ok(service), Err(e) => { log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) + Err(e.into()) } }, Err(e) => { diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index bc14c8d..1ebcace 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -25,8 +25,7 @@ impl Task { pub async fn status(&self) -> Result> { let task_id=&self.id; - let url = format!("/ga4gh/tes/v1/tasks/{}", task_id.clone()); - let config = Configuration::new(url, None, None); + let config = Configuration::default(); let tes=TES::new(&config).await; tes?.status(&task_id.clone(), "BASIC").await } @@ -42,13 +41,15 @@ pub struct TES { impl TES { pub async fn new(config: &Configuration) -> Result> { - let transport = &Transport::new(config); - let service_info = &ServiceInfo::new(config).unwrap(); + let transport = Transport::new(config); + let service_info = ServiceInfo::new(config).unwrap(); + let resp = service_info.get().await; + // println!("artifact: {}",resp.clone().unwrap().r#type.artifact); let instance = TES { config: config.clone(), - transport: transport.clone(), + transport, service: resp, }; @@ -62,6 +63,7 @@ impl TES { fn check(&self) -> bool { let resp = &self.service; return resp.as_ref().unwrap().r#type.artifact == "tes"; + // true } pub async fn create( @@ -69,11 +71,11 @@ impl TES { task: TesTask, /*, params: models::TesTask*/ ) -> Result> { // First, check if the service is of TES class - if !self.check() { - // If check fails, log an error and return an Err immediately - log::error!("Service check failed"); - return Err("Service check failed".into()); - } + // if !self.check() { + // // If check fails, log an error and return an Err immediately + // log::error!("Service check failed"); + // return Err("Service check failed".into()); + // } // todo: version in url based on serviceinfo or user config let response = self .transport @@ -129,6 +131,7 @@ impl TES { #[cfg(test)] mod tests { use crate::configuration::Configuration; + // use crate::tes::Task; use crate::tes::models::TesTask; use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; @@ -159,12 +162,17 @@ mod tests { assert!(!task.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion } - // #[tokio::test] - // async fn test_task_status() { - // setup(); + #[tokio::test] + async fn test_task_status() { + // setup(); - // let task = create_task().await.expect("Failed to create task"); - // // Now use task to get the task status... - // // todo: assert_eq!(task.status().await, which status?); - // } + // let taskid = &create_task().await.expect("Failed to create task"); + // assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + + // let task=Task::new(taskid.clone()); + // let status= task.status().await; + // println!("Task: {:?}", status); + // // Now use task to get the task status... + // // todo: assert_eq!(task.status().await, which status?); + } } From f08c9dc67e776cf4cc8c0d1c77d12dafe9c409f5 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 27 Jun 2024 17:06:01 +0530 Subject: [PATCH 37/92] unit test working, with no params --- lib/src/tes/mod.rs | 79 +++++++++++++++++++++++++------------------- lib/src/transport.rs | 2 +- 2 files changed, 46 insertions(+), 35 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 1ebcace..fcb9d78 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -7,6 +7,8 @@ use crate::tes::models::TesTask; use crate::transport::Transport; use serde_json; use serde_json::json; +use serde_json::from_str; + // *** // should TES.create return Task? which in turn can do status() and other existing-task-related stuff @@ -23,14 +25,14 @@ impl Task { } } - pub async fn status(&self) -> Result> { + pub async fn status(&self, tes: &TES) -> Result> { let task_id=&self.id; - let config = Configuration::default(); - let tes=TES::new(&config).await; - tes?.status(&task_id.clone(), "BASIC").await + // let config = Configuration::default(); + // let tes=TES::new(config).await; + tes.status(&task_id.clone(), "BASIC").await } } - +#[derive(Debug)] pub struct TES { #[allow(dead_code)] config: Configuration, // not used yet @@ -62,8 +64,8 @@ impl TES { fn check(&self) -> bool { let resp = &self.service; - return resp.as_ref().unwrap().r#type.artifact == "tes"; - // true + // return resp.as_ref().unwrap().r#type.artifact == "tes"; + true } pub async fn create( @@ -71,11 +73,11 @@ impl TES { task: TesTask, /*, params: models::TesTask*/ ) -> Result> { // First, check if the service is of TES class - // if !self.check() { - // // If check fails, log an error and return an Err immediately - // log::error!("Service check failed"); - // return Err("Service check failed".into()); - // } + if !self.check() { + // If check fails, log an error and return an Err immediately + log::error!("Service check failed"); + return Err("Service check failed".into()); + } // todo: version in url based on serviceinfo or user config let response = self .transport @@ -106,23 +108,20 @@ impl TES { ) -> Result> { // ?? move to Task::status() // todo: version in url based on serviceinfo or user config - let url = format!("/ga4gh/tes/v1/tasks/{}", task_id); + let url = format!("/tasks/{}", task_id); let params = [("view", view)]; let params_value = serde_json::json!(params); - let response = self.transport.get(&url, Some(params_value)).await; + // println!("{:?}", &self); + // let response = self.transport.get(&url, Some(params_value)).await; + let response = self.transport.get(&url, None).await; + println!("{:?}", response); match response { - Ok(response_body) => match serde_json::from_str::(&response_body) { - Ok(tes_state) => Ok(tes_state), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - } - }, - Err(e) => { - log::error!("Error: {}", e); - Err(e) - } + Ok(resp_str) => { + let task: TesTask = from_str(&resp_str)?; + Ok(task.state.unwrap()) } + Err(e) => Err(e), + } } // TODO: pub fn list() @@ -131,7 +130,7 @@ impl TES { #[cfg(test)] mod tests { use crate::configuration::Configuration; - // use crate::tes::Task; + use crate::tes::Task; use crate::tes::models::TesTask; use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; @@ -164,15 +163,27 @@ mod tests { #[tokio::test] async fn test_task_status() { - // setup(); + setup(); + + let taskid = &create_task().await.expect("Failed to create task"); + assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - // let taskid = &create_task().await.expect("Failed to create task"); - // assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + let task=Task::new(taskid.clone()); - // let task=Task::new(taskid.clone()); - // let status= task.status().await; - // println!("Task: {:?}", status); - // // Now use task to get the task status... - // // todo: assert_eq!(task.status().await, which status?); + let mut config = Configuration::default(); + let funnel_url = ensure_funnel_running().await; + config.set_base_path(&funnel_url); + match TES::new(&config).await { + Ok(tes) => { + let status = task.status(&tes).await; + println!("Task: {:?}", status); + }, + Err(e) => { + // Handle the error e + println!("Error creating TES instance: {:?}", e); + } +} + // Now use task to get the task status... + // todo: assert_eq!(task.status().await, which status?); } } diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 5bd434b..c19a5c0 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -5,7 +5,7 @@ use serde_json::Value; use std::error::Error; // note: could implement custom certs handling, such as in-TEE generated ephemerial certs -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct Transport { pub config: Configuration, pub client: reqwest::Client, From d8ef075c40b65b6ea1d1598251f0598d43ea738d Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 27 Jun 2024 17:28:35 +0530 Subject: [PATCH 38/92] completed the unit test of tes_status --- lib/src/tes/mod.rs | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index fcb9d78..d61d93f 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -29,7 +29,7 @@ impl Task { let task_id=&self.id; // let config = Configuration::default(); // let tes=TES::new(config).await; - tes.status(&task_id.clone(), "BASIC").await + tes.status(&task_id.clone(), "FULL").await } } #[derive(Debug)] @@ -64,8 +64,8 @@ impl TES { fn check(&self) -> bool { let resp = &self.service; - // return resp.as_ref().unwrap().r#type.artifact == "tes"; - true + return resp.as_ref().unwrap().r#type.artifact == "tes"; + // true } pub async fn create( @@ -108,13 +108,12 @@ impl TES { ) -> Result> { // ?? move to Task::status() // todo: version in url based on serviceinfo or user config - let url = format!("/tasks/{}", task_id); - let params = [("view", view)]; - let params_value = serde_json::json!(params); + let url = format!("/tasks/{}?view={}", task_id, view); + // let params = [("view", view)]; + // let params_value = serde_json::json!(params); // println!("{:?}", &self); // let response = self.transport.get(&url, Some(params_value)).await; let response = self.transport.get(&url, None).await; - println!("{:?}", response); match response { Ok(resp_str) => { let task: TesTask = from_str(&resp_str)?; @@ -134,6 +133,7 @@ mod tests { use crate::tes::models::TesTask; use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; + use crate::tes::TesState; // use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; @@ -177,6 +177,24 @@ mod tests { Ok(tes) => { let status = task.status(&tes).await; println!("Task: {:?}", status); + // Adding an assertion for the Ok variant + match status { + Ok(state) => { + match state { + TesState::Initializing | TesState::Queued => { + // Assertion passes if state is Initializing or Queued + } + _ => { + panic!("Unexpected state: {:?}", state); + } + } + + } + Err(err) => { + panic!("Task status returned an error: {:?}", err); + } + } + }, Err(e) => { // Handle the error e From 49a702d7abb3f3f9bbba71dd4a1ecd94a9bf8092 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 27 Jun 2024 17:33:47 +0530 Subject: [PATCH 39/92] CI/CD framework --- lib/src/tes/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index d61d93f..e931a1c 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -181,7 +181,7 @@ mod tests { match status { Ok(state) => { match state { - TesState::Initializing | TesState::Queued => { + TesState::Initializing | TesState::Queued | TesState::Running => { // Assertion passes if state is Initializing or Queued } _ => { From c1103790c543e2b3179c4eed0b29547d23cb2e12 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 27 Jun 2024 17:34:48 +0530 Subject: [PATCH 40/92] CI/CD --- lib/src/tes/mod.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index e931a1c..dc70100 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -182,7 +182,8 @@ mod tests { Ok(state) => { match state { TesState::Initializing | TesState::Queued | TesState::Running => { - // Assertion passes if state is Initializing or Queued + // Assertion passes if state is Initializing or Queued (When ran locally, the response is Initializing or Queued) + // In Github Workflow, the state is Running } _ => { panic!("Unexpected state: {:?}", state); From 4d88c44a088efde29ecbf8f90779691fa8857390 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 28 Jun 2024 14:36:07 +0530 Subject: [PATCH 41/92] added cancel function --- lib/src/tes/mod.rs | 22 ++++++++++++++++++++-- lib/src/transport.rs | 5 ++--- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index dc70100..cfc751f 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -81,7 +81,7 @@ impl TES { // todo: version in url based on serviceinfo or user config let response = self .transport - .post("/ga4gh/tes/v1/tasks", json!(task)) + .post("/ga4gh/tes/v1/tasks", Some(json!(task))) .await; match response { Ok(response_body) => { @@ -123,7 +123,25 @@ impl TES { } } - // TODO: pub fn list() + pub async fn cancel( + &self, + task_id: &str, + ) -> Result< serde_json::Value, Box> { + // ?? move to Task::cancel() + // todo: version in url based on serviceinfo or user config + let url = format!("/tasks/{}:cancel", task_id); + let response = self.transport.post(&url, None).await; + match response { + Ok(resp_str) => { + let parsed_json = serde_json::from_str::(&resp_str); + match parsed_json { + Ok(json) => Ok(json), + Err(e) => Err(Box::new(e)), + } + } + Err(e) => Err(e), + } + } } #[cfg(test)] diff --git a/lib/src/transport.rs b/lib/src/transport.rs index c19a5c0..9aaeb37 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -73,9 +73,8 @@ impl Transport { .await } - pub async fn post(&self, endpoint: &str, data: Value) -> Result> { - self.request(reqwest::Method::POST, endpoint, Some(data), None) - .await + pub async fn post(&self, endpoint: &str, data: Option) -> Result> { + self.request(reqwest::Method::POST, endpoint, data, None).await } pub async fn put(&self, endpoint: &str, data: Value) -> Result> { From dda27a7415ac80f7da8d8c433f87149e431b0304 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 28 Jun 2024 14:37:36 +0530 Subject: [PATCH 42/92] added cancel fn in Task --- lib/src/tes/mod.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index cfc751f..a35b00e 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -31,6 +31,11 @@ impl Task { // let tes=TES::new(config).await; tes.status(&task_id.clone(), "FULL").await } + + pub async fn cancel(&self, tes: &TES) -> Result> { + let task_id=&self.id; + tes.cancel(&task_id.clone()).await + } } #[derive(Debug)] pub struct TES { From df1fc623e8d1e21b96e3050edcb0d1e70837ad34 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 28 Jun 2024 14:56:19 +0530 Subject: [PATCH 43/92] adding cancel unit test --- lib/src/tes/mod.rs | 43 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 35 insertions(+), 8 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index a35b00e..da64142 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -10,9 +10,10 @@ use serde_json::json; use serde_json::from_str; -// *** -// should TES.create return Task? which in turn can do status() and other existing-task-related stuff -// instead of TES.status(task_id) we could do task.status() +pub fn urlencode>(s: T) -> String { + ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +} + #[derive(Serialize, Deserialize)] pub struct Task { id: String, @@ -130,12 +131,16 @@ impl TES { pub async fn cancel( &self, - task_id: &str, + id: &str, ) -> Result< serde_json::Value, Box> { // ?? move to Task::cancel() // todo: version in url based on serviceinfo or user config - let url = format!("/tasks/{}:cancel", task_id); + let id=&urlencode(id); + let url = format!("/tasks/{}:cancel", id); + + println!("{:?}",url); let response = self.transport.post(&url, None).await; + println!("the response is: {:?}",response); match response { Ok(resp_str) => { let parsed_json = serde_json::from_str::(&resp_str); @@ -224,8 +229,30 @@ mod tests { // Handle the error e println!("Error creating TES instance: {:?}", e); } -} - // Now use task to get the task status... - // todo: assert_eq!(task.status().await, which status?); + } + } + + #[tokio::test] + async fn test_cancel_task() { + setup(); + + let taskid = &create_task().await.expect("Failed to create task"); + assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + + let task=Task::new(taskid.clone()); + + let mut config = Configuration::default(); + let funnel_url = ensure_funnel_running().await; + config.set_base_path(&funnel_url); + match TES::new(&config).await { + Ok(tes) => { + let cancel= task.cancel(&tes).await; + println!("{:?}", cancel); + }, + Err(e) => { + // Handle the error e + println!("Error creating TES instance: {:?}", e); + } + } } } From a25c49901b91ad4753e2aa372cb87afb419b1cc8 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 28 Jun 2024 17:55:20 +0530 Subject: [PATCH 44/92] changed transport struct for optional params and data --- lib/src/tes/mod.rs | 3 ++- lib/src/transport.rs | 18 ++++++++++++------ 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index da64142..b43da23 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -17,6 +17,7 @@ pub fn urlencode>(s: T) -> String { #[derive(Serialize, Deserialize)] pub struct Task { id: String, + // transport: Transport, } impl Task { @@ -137,7 +138,7 @@ impl TES { // todo: version in url based on serviceinfo or user config let id=&urlencode(id); let url = format!("/tasks/{}:cancel", id); - + // let url= &urlencode(url); println!("{:?}",url); let response = self.transport.post(&url, None).await; println!("the response is: {:?}",response); diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 9aaeb37..cc4bee5 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -39,17 +39,23 @@ impl Transport { ))); } - let resp = self + let mut request_builder = self .client .request(method, &full_url) .header( reqwest::header::USER_AGENT, self.config.user_agent.clone().unwrap_or_default(), - ) - .json(&data) - .query(¶ms) - .send() - .await?; + ); + + if let Some(ref params_value) = params { + request_builder = request_builder.query(params_value); + } + + if let Some(ref data_value) = data { + request_builder = request_builder.json(data_value); + } + + let resp = request_builder.send().await?; let status = resp.status(); let content = resp.text().await?; From 3c92b7093292ab2e0a46dc71fc458d95c4ecba54 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 28 Jun 2024 18:38:25 +0530 Subject: [PATCH 45/92] changed the status fn to Task struct --- lib/src/tes/mod.rs | 80 +++++++++++++++++++++++----------------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index b43da23..55a63e2 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -4,6 +4,7 @@ use crate::serviceinfo::models::Service; use crate::serviceinfo::ServiceInfo; use crate::tes::models::TesState; use crate::tes::models::TesTask; +use crate::transport; use crate::transport::Transport; use serde_json; use serde_json::json; @@ -14,24 +15,34 @@ pub fn urlencode>(s: T) -> String { ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() } -#[derive(Serialize, Deserialize)] +#[derive(Debug)] pub struct Task { id: String, - // transport: Transport, + transport: Transport, } impl Task { - pub fn new(id: String) -> Self { + pub fn new(id: String, transport: Transport) -> Self { Task { id, + transport, } } - pub async fn status(&self, tes: &TES) -> Result> { + pub async fn status(&self, view: &str) -> Result> { let task_id=&self.id; - // let config = Configuration::default(); - // let tes=TES::new(config).await; - tes.status(&task_id.clone(), "FULL").await + let url = format!("/tasks/{}?view={}", task_id, view); + // let params = [("view", view)]; + // let params_value = serde_json::json!(params); + // let response = self.transport.get(&url, Some(params_value)).await; + let response = self.transport.get(&url, None).await; + match response { + Ok(resp_str) => { + let task: TesTask = from_str(&resp_str)?; + Ok(task.state.unwrap()) + } + Err(e) => Err(e), + } } pub async fn cancel(&self, tes: &TES) -> Result> { @@ -92,13 +103,16 @@ impl TES { .await; match response { Ok(response_body) => { - match serde_json::from_str::(&response_body) { - Ok(tes_create_task_response) => Ok(tes_create_task_response), - Err(e) => { - log::error!("Failed to deserialize response: {}", e); - Err("Failed to deserialize response".into()) - } - } + let v: serde_json::Value = serde_json::from_str(&response_body)?; + + // Access the `id` field + let task_id = v.get("id").and_then(|v| v.as_str()).unwrap_or_default().trim_matches('"').to_string();; + + let task=Task{ + id: task_id, + transport: self.transport.clone(), + }; + Ok(task) } Err(e) => { log::error!("Error: {}", e); @@ -113,21 +127,11 @@ impl TES { task_id: &str, view: &str,// 'view' controls the level of detail in the response. Expected values: "MINIMAL","BASIC" or "FULL". ) -> Result> { - // ?? move to Task::status() - // todo: version in url based on serviceinfo or user config - let url = format!("/tasks/{}?view={}", task_id, view); - // let params = [("view", view)]; - // let params_value = serde_json::json!(params); - // println!("{:?}", &self); - // let response = self.transport.get(&url, Some(params_value)).await; - let response = self.transport.get(&url, None).await; - match response { - Ok(resp_str) => { - let task: TesTask = from_str(&resp_str)?; - Ok(task.state.unwrap()) - } - Err(e) => Err(e), - } + let task= Task{ + id: task_id.to_string(), + transport: self.transport.clone(), + }; + task.status(view).await } pub async fn cancel( @@ -139,9 +143,9 @@ impl TES { let id=&urlencode(id); let url = format!("/tasks/{}:cancel", id); // let url= &urlencode(url); - println!("{:?}",url); + // println!("{:?}",url); let response = self.transport.post(&url, None).await; - println!("the response is: {:?}",response); + // println!("the response is: {:?}",response); match response { Ok(resp_str) => { let parsed_json = serde_json::from_str::(&resp_str); @@ -196,15 +200,13 @@ mod tests { let taskid = &create_task().await.expect("Failed to create task"); assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - - let task=Task::new(taskid.clone()); - let mut config = Configuration::default(); let funnel_url = ensure_funnel_running().await; config.set_base_path(&funnel_url); match TES::new(&config).await { Ok(tes) => { - let status = task.status(&tes).await; + let task=Task::new(taskid.clone(),tes.transport); + let status = task.status("FULL").await; println!("Task: {:?}", status); // Adding an assertion for the Ok variant match status { @@ -239,16 +241,14 @@ mod tests { let taskid = &create_task().await.expect("Failed to create task"); assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - - let task=Task::new(taskid.clone()); - let mut config = Configuration::default(); let funnel_url = ensure_funnel_running().await; config.set_base_path(&funnel_url); match TES::new(&config).await { Ok(tes) => { - let cancel= task.cancel(&tes).await; - println!("{:?}", cancel); + let task=Task::new(taskid.clone(), tes.transport); + // let cancel= task.cancel(&tes).await; + // println!("{:?}", cancel); }, Err(e) => { // Handle the error e From bc07b6518e82cd0f1e9585573909fdaeea6469e8 Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 28 Jun 2024 18:52:16 +0530 Subject: [PATCH 46/92] moved cancel to Task, added get in TES --- lib/src/tes/mod.rs | 75 ++++++++++++++++++++++------------------------ 1 file changed, 35 insertions(+), 40 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 55a63e2..339fcb2 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -4,7 +4,6 @@ use crate::serviceinfo::models::Service; use crate::serviceinfo::ServiceInfo; use crate::tes::models::TesState; use crate::tes::models::TesTask; -use crate::transport; use crate::transport::Transport; use serde_json; use serde_json::json; @@ -29,8 +28,9 @@ impl Task { } } - pub async fn status(&self, view: &str) -> Result> { + pub async fn status(&self) -> Result> { let task_id=&self.id; + let view= "FULL"; let url = format!("/tasks/{}?view={}", task_id, view); // let params = [("view", view)]; // let params_value = serde_json::json!(params); @@ -45,9 +45,25 @@ impl Task { } } - pub async fn cancel(&self, tes: &TES) -> Result> { - let task_id=&self.id; - tes.cancel(&task_id.clone()).await + pub async fn cancel(&self) -> Result> { + + let id=&self.id; + let id=&urlencode(id); + let url = format!("/tasks/{}:cancel", id); + // let url= &urlencode(url); + // println!("{:?}",url); + let response = self.transport.post(&url, None).await; + // println!("the response is: {:?}",response); + match response { + Ok(resp_str) => { + let parsed_json = serde_json::from_str::(&resp_str); + match parsed_json { + Ok(json) => Ok(json), + Err(e) => Err(Box::new(e)), + } + } + Err(e) => Err(e), + } } } #[derive(Debug)] @@ -106,7 +122,7 @@ impl TES { let v: serde_json::Value = serde_json::from_str(&response_body)?; // Access the `id` field - let task_id = v.get("id").and_then(|v| v.as_str()).unwrap_or_default().trim_matches('"').to_string();; + let task_id = v.get("id").and_then(|v| v.as_str()).unwrap_or_default().trim_matches('"').to_string(); let task=Task{ id: task_id, @@ -121,41 +137,20 @@ impl TES { } } - // pub async fn status(&self, task: &TesCreateTaskResponse) -> Result> { - pub async fn status( - &self, - task_id: &str, - view: &str,// 'view' controls the level of detail in the response. Expected values: "MINIMAL","BASIC" or "FULL". - ) -> Result> { - let task= Task{ - id: task_id.to_string(), - transport: self.transport.clone(), - }; - task.status(view).await - } - - pub async fn cancel( - &self, - id: &str, - ) -> Result< serde_json::Value, Box> { - // ?? move to Task::cancel() - // todo: version in url based on serviceinfo or user config - let id=&urlencode(id); - let url = format!("/tasks/{}:cancel", id); - // let url= &urlencode(url); - // println!("{:?}",url); - let response = self.transport.post(&url, None).await; - // println!("the response is: {:?}",response); + pub async fn get(&self, view: &str, id: &str) -> Result> { + let task_id=id; + let url = format!("/tasks/{}?view={}", task_id, view); + // let params = [("view", view)]; + // let params_value = serde_json::json!(params); + // let response = self.transport.get(&url, Some(params_value)).await; + let response = self.transport.get(&url, None).await; match response { Ok(resp_str) => { - let parsed_json = serde_json::from_str::(&resp_str); - match parsed_json { - Ok(json) => Ok(json), - Err(e) => Err(Box::new(e)), - } + let task: TesTask = from_str(&resp_str)?; + Ok(task) } Err(e) => Err(e), - } + } } } @@ -206,7 +201,7 @@ mod tests { match TES::new(&config).await { Ok(tes) => { let task=Task::new(taskid.clone(),tes.transport); - let status = task.status("FULL").await; + let status = task.status().await; println!("Task: {:?}", status); // Adding an assertion for the Ok variant match status { @@ -247,8 +242,8 @@ mod tests { match TES::new(&config).await { Ok(tes) => { let task=Task::new(taskid.clone(), tes.transport); - // let cancel= task.cancel(&tes).await; - // println!("{:?}", cancel); + let cancel= task.cancel().await; + assert!(cancel.is_ok()); }, Err(e) => { // Handle the error e From 0f7decc24452cd210faf5ce1f59f49fe3dafac99 Mon Sep 17 00:00:00 2001 From: aaravm Date: Sun, 30 Jun 2024 02:21:43 +0530 Subject: [PATCH 47/92] added list tasks fn --- lib/src/tes/mod.rs | 74 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 339fcb2..a2ac8fc 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,5 +1,6 @@ pub mod models; use crate::configuration::Configuration; +use crate::tes::models::TesListTasksResponse; use crate::serviceinfo::models::Service; use crate::serviceinfo::ServiceInfo; use crate::tes::models::TesState; @@ -14,6 +15,25 @@ pub fn urlencode>(s: T) -> String { ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() } +/// struct for passing parameters to the method [`list_tasks`] +#[derive(Clone, Debug)] +pub struct ListTasksParams { + /// OPTIONAL. Filter the list to include tasks where the name matches this prefix. If unspecified, no task name filtering is done. + pub name_prefix: Option, + /// OPTIONAL. Filter tasks by state. If unspecified, no task state filtering is done. + pub state: Option, + /// OPTIONAL. Provide key tag to filter. The field tag_key is an array of key values, and will be zipped with an optional tag_value array. So the query: ``` ?tag_key=foo1&tag_value=bar1&tag_key=foo2&tag_value=bar2 ``` Should be constructed into the structure { \"foo1\" : \"bar1\", \"foo2\" : \"bar2\"} ``` ?tag_key=foo1 ``` Should be constructed into the structure {\"foo1\" : \"\"} If the tag_value is empty, it will be treated as matching any possible value. If a tag value is provided, both the tag's key and value must be exact matches for a task to be returned. Filter Tags Match? ---------------------------------------------------------------------- {\"foo\": \"bar\"} {\"foo\": \"bar\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bat\"} No {\"foo\": \"\"} {\"foo\": \"\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\"} No {\"foo\": \"\"} {\"foo\": \"bar\"} Yes {\"foo\": \"\"} {} No + pub tag_key: Option>, + /// OPTIONAL. The companion value field for tag_key + pub tag_value: Option>, + /// Optional number of tasks to return in one page. Must be less than 2048. Defaults to 256. + pub page_size: Option, + /// OPTIONAL. Page token is used to retrieve the next page of results. If unspecified, returns the first page of results. The value can be found in the `next_page_token` field of the last returned result of ListTasks + pub page_token: Option, + /// OPTIONAL. Affects the fields included in the returned Task messages. `MINIMAL`: Task message will include ONLY the fields: - `tesTask.Id` - `tesTask.State` `BASIC`: Task message will include all fields EXCEPT: - `tesTask.ExecutorLog.stdout` - `tesTask.ExecutorLog.stderr` - `tesInput.content` - `tesTaskLog.system_logs` `FULL`: Task message includes all fields. + pub view: Option +} + #[derive(Debug)] pub struct Task { id: String, @@ -152,6 +172,27 @@ impl TES { Err(e) => Err(e), } } + pub async fn list_tasks(&self, params: Option) -> Result> { + let params_value = json!({ + "name_prefix": params.as_ref().map(|p| &p.name_prefix), + "state": params.as_ref().map(|p| &p.state), + "tag_key": params.as_ref().map(|p| &p.tag_key), + "tag_value": params.as_ref().map(|p| &p.tag_value), + "page_size": params.as_ref().map(|p| &p.page_size), + "page_token": params.as_ref().map(|p| &p.page_token), + "view": params.as_ref().map(|p| &p.view), + }); + + let response = self.transport.get("/tasks", Some(params_value)).await; + match response { + Ok(resp_str) => { + let task: TesListTasksResponse = from_str(&resp_str)?; + Ok(task) + } + Err(e) => Err(e), + } + } + } #[cfg(test)] @@ -162,6 +203,7 @@ mod tests { use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; use crate::tes::TesState; + // use crate::tes::ListTasksParams; // use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; @@ -243,6 +285,7 @@ mod tests { Ok(tes) => { let task=Task::new(taskid.clone(), tes.transport); let cancel= task.cancel().await; + println!("Cancel response: {:?}", cancel); // Log the cancel response assert!(cancel.is_ok()); }, Err(e) => { @@ -251,4 +294,35 @@ mod tests { } } } + + #[tokio::test] + async fn test_list_task() { + setup(); + + let taskid = &create_task().await.expect("Failed to create task"); + assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + let mut config = Configuration::default(); + let funnel_url = ensure_funnel_running().await; + config.set_base_path(&funnel_url); + match TES::new(&config).await { + Ok(tes) => { + // let params: ListTasksParams = ListTasksParams { + // name_prefix: None, + // state: None, + // tag_key: None, + // tag_value: None, + // page_size: None, + // page_token: None, + // view: None, + // }; + + let list= tes.list_tasks(None).await; + println!("{:?}",list); + }, + Err(e) => { + // Handle the error e + println!("Error creating TES instance: {:?}", e); + } + } + } } From 19ece9673044c5ff482d70e67d0471775e391b54 Mon Sep 17 00:00:00 2001 From: aaravm Date: Sun, 30 Jun 2024 03:51:17 +0530 Subject: [PATCH 48/92] correcting get list() fn --- lib/src/tes/mod.rs | 54 +++++++++++++++++++++++++------------------- lib/src/transport.rs | 3 ++- 2 files changed, 33 insertions(+), 24 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index a2ac8fc..2fde395 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -173,17 +173,26 @@ impl TES { } } pub async fn list_tasks(&self, params: Option) -> Result> { - let params_value = json!({ - "name_prefix": params.as_ref().map(|p| &p.name_prefix), - "state": params.as_ref().map(|p| &p.state), - "tag_key": params.as_ref().map(|p| &p.tag_key), - "tag_value": params.as_ref().map(|p| &p.tag_value), - "page_size": params.as_ref().map(|p| &p.page_size), - "page_token": params.as_ref().map(|p| &p.page_token), - "view": params.as_ref().map(|p| &p.view), - }); - - let response = self.transport.get("/tasks", Some(params_value)).await; + + let params_value = params.map(|p| { + json!({ + "name_prefix": p.name_prefix, + "state": p.state, + "tag_key": p.tag_key, + "tag_value": p.tag_value, + "page_size": p.page_size, + "page_token": p.page_token, + "view": p.view, + }) + }); + // println!("{:?}",params_value); + // Make the request with or without parameters based on the presence of params + let response = if let Some(params_value) = params_value { + self.transport.get("/tasks", Some(params_value)).await + } else { + self.transport.get("/tasks", None).await + }; + match response { Ok(resp_str) => { let task: TesListTasksResponse = from_str(&resp_str)?; @@ -203,7 +212,7 @@ mod tests { use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; use crate::tes::TesState; - // use crate::tes::ListTasksParams; + use crate::tes::ListTasksParams; // use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; @@ -285,7 +294,6 @@ mod tests { Ok(tes) => { let task=Task::new(taskid.clone(), tes.transport); let cancel= task.cancel().await; - println!("Cancel response: {:?}", cancel); // Log the cancel response assert!(cancel.is_ok()); }, Err(e) => { @@ -306,17 +314,17 @@ mod tests { config.set_base_path(&funnel_url); match TES::new(&config).await { Ok(tes) => { - // let params: ListTasksParams = ListTasksParams { - // name_prefix: None, - // state: None, - // tag_key: None, - // tag_value: None, - // page_size: None, - // page_token: None, - // view: None, - // }; + let params: ListTasksParams = ListTasksParams { + name_prefix: None, + state: None, + tag_key: None, + tag_value: None, + page_size: None, + page_token: None, + view: Some("BASIC".to_string()), + }; - let list= tes.list_tasks(None).await; + let list= tes.list_tasks(Some(params)).await; println!("{:?}",list); }, Err(e) => { diff --git a/lib/src/transport.rs b/lib/src/transport.rs index cc4bee5..937a5df 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -52,7 +52,8 @@ impl Transport { } if let Some(ref data_value) = data { - request_builder = request_builder.json(data_value); + // Figure out some way to filter out `Null` values of data_value + request_builder = request_builder.json(&data_value); } let resp = request_builder.send().await?; From 4e415a5937b565682561e5f2ed88e2046be5ce39 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 1 Jul 2024 11:14:48 +0400 Subject: [PATCH 49/92] cargo fmt: code formatting --- lib/src/tes/mod.rs | 127 +++++++++++++++++++++---------------------- lib/src/transport.rs | 24 ++++---- 2 files changed, 76 insertions(+), 75 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 2fde395..139eeb4 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,15 +1,14 @@ pub mod models; use crate::configuration::Configuration; -use crate::tes::models::TesListTasksResponse; use crate::serviceinfo::models::Service; use crate::serviceinfo::ServiceInfo; +use crate::tes::models::TesListTasksResponse; use crate::tes::models::TesState; use crate::tes::models::TesTask; use crate::transport::Transport; use serde_json; -use serde_json::json; use serde_json::from_str; - +use serde_json::json; pub fn urlencode>(s: T) -> String { ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() @@ -31,7 +30,7 @@ pub struct ListTasksParams { /// OPTIONAL. Page token is used to retrieve the next page of results. If unspecified, returns the first page of results. The value can be found in the `next_page_token` field of the last returned result of ListTasks pub page_token: Option, /// OPTIONAL. Affects the fields included in the returned Task messages. `MINIMAL`: Task message will include ONLY the fields: - `tesTask.Id` - `tesTask.State` `BASIC`: Task message will include all fields EXCEPT: - `tesTask.ExecutorLog.stdout` - `tesTask.ExecutorLog.stderr` - `tesInput.content` - `tesTaskLog.system_logs` `FULL`: Task message includes all fields. - pub view: Option + pub view: Option, } #[derive(Debug)] @@ -42,48 +41,44 @@ pub struct Task { impl Task { pub fn new(id: String, transport: Transport) -> Self { - Task { - id, - transport, - } + Task { id, transport } } pub async fn status(&self) -> Result> { - let task_id=&self.id; - let view= "FULL"; + let task_id = &self.id; + let view = "FULL"; let url = format!("/tasks/{}?view={}", task_id, view); // let params = [("view", view)]; // let params_value = serde_json::json!(params); // let response = self.transport.get(&url, Some(params_value)).await; let response = self.transport.get(&url, None).await; match response { - Ok(resp_str) => { - let task: TesTask = from_str(&resp_str)?; - Ok(task.state.unwrap()) - } - Err(e) => Err(e), + Ok(resp_str) => { + let task: TesTask = from_str(&resp_str)?; + Ok(task.state.unwrap()) + } + Err(e) => Err(e), } } - - pub async fn cancel(&self) -> Result> { - - let id=&self.id; - let id=&urlencode(id); + + pub async fn cancel(&self) -> Result> { + let id = &self.id; + let id = &urlencode(id); let url = format!("/tasks/{}:cancel", id); - // let url= &urlencode(url); + // let url= &urlencode(url); // println!("{:?}",url); let response = self.transport.post(&url, None).await; // println!("the response is: {:?}",response); match response { - Ok(resp_str) => { - let parsed_json = serde_json::from_str::(&resp_str); - match parsed_json { - Ok(json) => Ok(json), - Err(e) => Err(Box::new(e)), + Ok(resp_str) => { + let parsed_json = serde_json::from_str::(&resp_str); + match parsed_json { + Ok(json) => Ok(json), + Err(e) => Err(Box::new(e)), + } } + Err(e) => Err(e), } - Err(e) => Err(e), - } } } #[derive(Debug)] @@ -101,7 +96,7 @@ impl TES { let service_info = ServiceInfo::new(config).unwrap(); let resp = service_info.get().await; - + // println!("artifact: {}",resp.clone().unwrap().r#type.artifact); let instance = TES { config: config.clone(), @@ -140,15 +135,20 @@ impl TES { match response { Ok(response_body) => { let v: serde_json::Value = serde_json::from_str(&response_body)?; - + // Access the `id` field - let task_id = v.get("id").and_then(|v| v.as_str()).unwrap_or_default().trim_matches('"').to_string(); - - let task=Task{ + let task_id = v + .get("id") + .and_then(|v| v.as_str()) + .unwrap_or_default() + .trim_matches('"') + .to_string(); + + let task = Task { id: task_id, transport: self.transport.clone(), }; - Ok(task) + Ok(task) } Err(e) => { log::error!("Error: {}", e); @@ -158,22 +158,24 @@ impl TES { } pub async fn get(&self, view: &str, id: &str) -> Result> { - let task_id=id; + let task_id = id; let url = format!("/tasks/{}?view={}", task_id, view); // let params = [("view", view)]; // let params_value = serde_json::json!(params); // let response = self.transport.get(&url, Some(params_value)).await; let response = self.transport.get(&url, None).await; match response { - Ok(resp_str) => { - let task: TesTask = from_str(&resp_str)?; - Ok(task) - } - Err(e) => Err(e), + Ok(resp_str) => { + let task: TesTask = from_str(&resp_str)?; + Ok(task) + } + Err(e) => Err(e), } } - pub async fn list_tasks(&self, params: Option) -> Result> { - + pub async fn list_tasks( + &self, + params: Option, + ) -> Result> { let params_value = params.map(|p| { json!({ "name_prefix": p.name_prefix, @@ -192,27 +194,26 @@ impl TES { } else { self.transport.get("/tasks", None).await }; - + match response { - Ok(resp_str) => { - let task: TesListTasksResponse = from_str(&resp_str)?; - Ok(task) - } - Err(e) => Err(e), + Ok(resp_str) => { + let task: TesListTasksResponse = from_str(&resp_str)?; + Ok(task) + } + Err(e) => Err(e), } } - } #[cfg(test)] mod tests { use crate::configuration::Configuration; - use crate::tes::Task; use crate::tes::models::TesTask; + use crate::tes::ListTasksParams; + use crate::tes::Task; + use crate::tes::TesState; use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; - use crate::tes::TesState; - use crate::tes::ListTasksParams; // use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; @@ -251,7 +252,7 @@ mod tests { config.set_base_path(&funnel_url); match TES::new(&config).await { Ok(tes) => { - let task=Task::new(taskid.clone(),tes.transport); + let task = Task::new(taskid.clone(), tes.transport); let status = task.status().await; println!("Task: {:?}", status); // Adding an assertion for the Ok variant @@ -266,14 +267,12 @@ mod tests { panic!("Unexpected state: {:?}", state); } } - } Err(err) => { panic!("Task status returned an error: {:?}", err); } } - - }, + } Err(e) => { // Handle the error e println!("Error creating TES instance: {:?}", e); @@ -292,15 +291,15 @@ mod tests { config.set_base_path(&funnel_url); match TES::new(&config).await { Ok(tes) => { - let task=Task::new(taskid.clone(), tes.transport); - let cancel= task.cancel().await; + let task = Task::new(taskid.clone(), tes.transport); + let cancel = task.cancel().await; assert!(cancel.is_ok()); - }, + } Err(e) => { // Handle the error e println!("Error creating TES instance: {:?}", e); } - } + } } #[tokio::test] @@ -324,13 +323,13 @@ mod tests { view: Some("BASIC".to_string()), }; - let list= tes.list_tasks(Some(params)).await; - println!("{:?}",list); - }, + let list = tes.list_tasks(Some(params)).await; + println!("{:?}", list); + } Err(e) => { // Handle the error e println!("Error creating TES instance: {:?}", e); } - } + } } } diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 937a5df..4921e66 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -39,20 +39,17 @@ impl Transport { ))); } - let mut request_builder = self - .client - .request(method, &full_url) - .header( - reqwest::header::USER_AGENT, - self.config.user_agent.clone().unwrap_or_default(), - ); - + let mut request_builder = self.client.request(method, &full_url).header( + reqwest::header::USER_AGENT, + self.config.user_agent.clone().unwrap_or_default(), + ); + if let Some(ref params_value) = params { request_builder = request_builder.query(params_value); } if let Some(ref data_value) = data { - // Figure out some way to filter out `Null` values of data_value + // Figure out some way to filter out `Null` values of data_value request_builder = request_builder.json(&data_value); } @@ -80,8 +77,13 @@ impl Transport { .await } - pub async fn post(&self, endpoint: &str, data: Option) -> Result> { - self.request(reqwest::Method::POST, endpoint, data, None).await + pub async fn post( + &self, + endpoint: &str, + data: Option, + ) -> Result> { + self.request(reqwest::Method::POST, endpoint, data, None) + .await } pub async fn put(&self, endpoint: &str, data: Value) -> Result> { From ac64bb348c4b977d7fc3a01acd95617c96e3c4a9 Mon Sep 17 00:00:00 2001 From: Pavel Nikonorov <4646953+pavelnikonorov@users.noreply.github.com> Date: Mon, 1 Jul 2024 11:41:40 +0400 Subject: [PATCH 50/92] tests simplifaction though TES and Task objects reuse --- lib/src/serviceinfo/mod.rs | 16 ----- lib/src/tes/mod.rs | 125 +++++++++++++------------------------ lib/src/test_utils.rs | 2 - run-tests.sh | 4 +- 4 files changed, 47 insertions(+), 100 deletions(-) diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index beae67f..dbf532f 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -41,22 +41,6 @@ mod tests { use crate::test_utils::{ensure_funnel_running, setup}; use tokio; - #[tokio::test] - async fn test_get_service_info() { - // let mut mock_transport = MockTransport::new(); - - // // Set up the mock to return a specific value when `get` is called - // mock_transport.expect_get() - // .with(eq("http://localhost/service-info"), eq(None)) - // .returning(|_, _| Ok(String::from("{\"id\": \"test\", \"name\": \"test\"}"))); - - // let service_info = ServiceInfo::new(mock_transport); - // let result = service_info.get_service_info().await; - - // assert!(result.is_ok()); - // assert_eq!(result.unwrap().id, "test"); - // assert_eq!(result.unwrap().name, "test"); - } #[tokio::test] async fn test_get_service_info_from_funnel() { setup(); diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 139eeb4..3b348e4 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -214,68 +214,54 @@ mod tests { use crate::tes::TesState; use crate::tes::TES; use crate::test_utils::{ensure_funnel_running, setup}; - // use crate::test_utils::{ensure_funnel_running, setup, FUNNEL_PORT}; // use crate::tes::models::TesCreateTaskResponse; - async fn create_task() -> Result> { - setup(); + async fn create_task() -> Result<(Task, TES), Box> { + // setup(); – should be run once in the test function let mut config = Configuration::default(); let funnel_url = ensure_funnel_running().await; config.set_base_path(&funnel_url); - let tes = TES::new(&config).await; + let tes = match TES::new(&config).await { + Ok(tes) => tes, + Err(e) => { + println!("Error creating TES instance: {:?}", e); + return Err(e.into()); + } + }; let task_json = std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); - let task = tes?.create(task).await?; - Ok(task.id) + let task = tes.create(task).await?; + Ok((task, tes)) } #[tokio::test] async fn test_task_create() { setup(); - ensure_funnel_running().await; - - let task = create_task().await.expect("Failed to create task"); - assert!(!task.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + let (task, _tes) = create_task().await.expect("Failed to create task"); + assert!(!task.id.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion } #[tokio::test] async fn test_task_status() { setup(); - let taskid = &create_task().await.expect("Failed to create task"); - assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - let mut config = Configuration::default(); - let funnel_url = ensure_funnel_running().await; - config.set_base_path(&funnel_url); - match TES::new(&config).await { - Ok(tes) => { - let task = Task::new(taskid.clone(), tes.transport); - let status = task.status().await; - println!("Task: {:?}", status); - // Adding an assertion for the Ok variant - match status { - Ok(state) => { - match state { - TesState::Initializing | TesState::Queued | TesState::Running => { - // Assertion passes if state is Initializing or Queued (When ran locally, the response is Initializing or Queued) - // In Github Workflow, the state is Running - } - _ => { - panic!("Unexpected state: {:?}", state); - } - } - } - Err(err) => { - panic!("Task status returned an error: {:?}", err); - } - } + let (task, _tes) = create_task().await.expect("Failed to create task"); + assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + + let status = task.status().await; + match status { + Ok(state) => { + assert!( + matches!(state, TesState::Initializing | TesState::Queued | TesState::Running), + "Unexpected state: {:?}", + state + ); } - Err(e) => { - // Handle the error e - println!("Error creating TES instance: {:?}", e); + Err(err) => { + panic!("Task status returned an error: {:?}", err); } } } @@ -284,52 +270,31 @@ mod tests { async fn test_cancel_task() { setup(); - let taskid = &create_task().await.expect("Failed to create task"); - assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - let mut config = Configuration::default(); - let funnel_url = ensure_funnel_running().await; - config.set_base_path(&funnel_url); - match TES::new(&config).await { - Ok(tes) => { - let task = Task::new(taskid.clone(), tes.transport); - let cancel = task.cancel().await; - assert!(cancel.is_ok()); - } - Err(e) => { - // Handle the error e - println!("Error creating TES instance: {:?}", e); - } - } + let (task, _tes) = &create_task().await.expect("Failed to create task"); + assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + + let cancel = task.cancel().await; + assert!(cancel.is_ok()); } #[tokio::test] async fn test_list_task() { setup(); - let taskid = &create_task().await.expect("Failed to create task"); - assert!(!taskid.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - let mut config = Configuration::default(); - let funnel_url = ensure_funnel_running().await; - config.set_base_path(&funnel_url); - match TES::new(&config).await { - Ok(tes) => { - let params: ListTasksParams = ListTasksParams { - name_prefix: None, - state: None, - tag_key: None, - tag_value: None, - page_size: None, - page_token: None, - view: Some("BASIC".to_string()), - }; + let (task, tes) = &create_task().await.expect("Failed to create task"); + assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - let list = tes.list_tasks(Some(params)).await; - println!("{:?}", list); - } - Err(e) => { - // Handle the error e - println!("Error creating TES instance: {:?}", e); - } - } + let params: ListTasksParams = ListTasksParams { + name_prefix: None, + state: None, + tag_key: None, + tag_value: None, + page_size: None, + page_token: None, + view: Some("BASIC".to_string()), + }; + + let list = tes.list_tasks(Some(params)).await; + println!("{:?}", list); } } diff --git a/lib/src/test_utils.rs b/lib/src/test_utils.rs index 2f44482..19e7f89 100644 --- a/lib/src/test_utils.rs +++ b/lib/src/test_utils.rs @@ -26,8 +26,6 @@ pub async fn ensure_funnel_running() -> String { if output_str.is_empty() { panic!("Funnel is not running."); - } else { - info!("Funnel is already running."); } let funnel_url = format!("{}:{}", FUNNEL_HOST, FUNNEL_PORT); diff --git a/run-tests.sh b/run-tests.sh index ebf2e0b..9d32617 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -32,8 +32,8 @@ done echo "Funnel server is running." # Run the tests -cargo test +RUST_BACKTRACE=1 RUST_LOG=debug cargo test # # Stop and remove the Funnel server container # docker stop funnel -# docker rm funnel \ No newline at end of file +# docker rm funnel From 1487961a4eba1bbe5815e4d8a4bf0338f95ad2e8 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 1 Jul 2024 14:46:47 +0530 Subject: [PATCH 51/92] corrected the list fn --- lib/src/tes/mod.rs | 35 ++++++++++++++++++++++++++--------- lib/src/transport.rs | 1 - 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 2fde395..f075ff8 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -175,15 +175,31 @@ impl TES { pub async fn list_tasks(&self, params: Option) -> Result> { let params_value = params.map(|p| { - json!({ - "name_prefix": p.name_prefix, - "state": p.state, - "tag_key": p.tag_key, - "tag_value": p.tag_value, - "page_size": p.page_size, - "page_token": p.page_token, - "view": p.view, - }) + let mut map = serde_json::Map::new(); + + if let Some(name_prefix) = p.name_prefix { + map.insert("name_prefix".to_string(), json!(name_prefix)); + } + if let Some(state) = p.state { + map.insert("state".to_string(), json!(state)); + } + if let Some(tag_key) = p.tag_key { + map.insert("tag_key".to_string(), json!(tag_key)); + } + if let Some(tag_value) = p.tag_value { + map.insert("tag_value".to_string(), json!(tag_value)); + } + if let Some(page_size) = p.page_size { + map.insert("page_size".to_string(), json!(page_size)); + } + if let Some(page_token) = p.page_token { + map.insert("page_token".to_string(), json!(page_token)); + } + if let Some(view) = p.view { + map.insert("view".to_string(), json!(view)); + } + + json!(map) }); // println!("{:?}",params_value); // Make the request with or without parameters based on the presence of params @@ -325,6 +341,7 @@ mod tests { }; let list= tes.list_tasks(Some(params)).await; + assert!(list.is_ok()); println!("{:?}",list); }, Err(e) => { diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 937a5df..c49ecf3 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -52,7 +52,6 @@ impl Transport { } if let Some(ref data_value) = data { - // Figure out some way to filter out `Null` values of data_value request_builder = request_builder.json(&data_value); } From c96b6368fa7ea6df05932e545ccf1241ea73f6cf Mon Sep 17 00:00:00 2001 From: Aarav Mehta <32593731+aaravm@users.noreply.github.com> Date: Mon, 1 Jul 2024 16:24:22 +0530 Subject: [PATCH 52/92] Sorcery-ai suggestion Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com> --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ec17429..8f37ee3 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ Once you have installed Funnel, you can run the tests with (it will automaticall bash ./run-tests.sh ``` -To test out the CI/CD workflow locally, install `act` and run the following command: +To test the CI/CD workflow locally, install `act` and run the following command: ``` act -j build --container-architecture linux/amd64 -P ubuntu-latest=ubuntu:20.04 --reuse ``` \ No newline at end of file From d613722b2b09ab012f987f74c7a9923395458af4 Mon Sep 17 00:00:00 2001 From: Aarav Mehta <32593731+aaravm@users.noreply.github.com> Date: Mon, 1 Jul 2024 16:24:46 +0530 Subject: [PATCH 53/92] Sorcery-ai suggestion Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com> --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8f37ee3..a7e5ee6 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ cargo build Before running the tests, you need to install Funnel, a task execution system that is compatible with the GA4GH TES API. Follow the instructions in the [Funnel Developer's Guide](https://ohsu-comp-bio.github.io/funnel/docs/development/developers/) to install Funnel. -Once you have installed Funnel, you can run the tests with (it will automatically run Funnel as well): +Once you have installed Funnel, you can run the tests. This will automatically run Funnel as well: ``` bash ./run-tests.sh From 4f482d3bed4057d85e3bdcb5266786c349324303 Mon Sep 17 00:00:00 2001 From: Aarav Mehta <32593731+aaravm@users.noreply.github.com> Date: Mon, 1 Jul 2024 16:38:56 +0530 Subject: [PATCH 54/92] Apply suggestions from code review Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com> --- README.md | 2 +- lib/src/tes/mod.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a7e5ee6..2db7c23 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ## Building -First, clone the repository, and then run the following command to auto-generate models using OpenAPI specifications: +First, clone the repository, and then run the following command to automatically generate models using OpenAPI specifications: ``` bash ./build-models.sh ``` diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index e68d9b1..1a78a34 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -265,8 +265,8 @@ mod tests { setup(); let (task, _tes) = create_task().await.expect("Failed to create task"); - assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion - + assert!(!task.id.is_empty(), "Task ID should not be empty"); + let status = task.status().await; match status { Ok(state) => { From ebc9bec67d1094271032531db301c6f1ec7895a0 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 1 Jul 2024 17:08:44 +0530 Subject: [PATCH 55/92] sorcery-ai suggestions --- lib/src/tes/mod.rs | 41 +++++++++++++++++++++-------------------- lib/src/transport.rs | 30 +++++++++++++----------------- 2 files changed, 34 insertions(+), 37 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 1a78a34..2a2046b 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -70,15 +70,15 @@ impl Task { let response = self.transport.post(&url, None).await; // println!("the response is: {:?}",response); match response { - Ok(resp_str) => { - let parsed_json = serde_json::from_str::(&resp_str); - match parsed_json { - Ok(json) => Ok(json), - Err(e) => Err(Box::new(e)), - } - } - Err(e) => Err(e), - } + Ok(resp_str) => { + let parsed_json = serde_json::from_str::(&resp_str); + match parsed_json { + Ok(json) => Ok(json), + Err(e) => Err(format!("Failed to parse JSON: {}", e).into()), + } + } + Err(e) => Err(format!("HTTP request failed: {}", e).into()), + } } } #[derive(Debug)] @@ -93,7 +93,7 @@ pub struct TES { impl TES { pub async fn new(config: &Configuration) -> Result> { let transport = Transport::new(config); - let service_info = ServiceInfo::new(config).unwrap(); + let service_info = ServiceInfo::new(config)?; let resp = service_info.get().await; @@ -113,8 +113,10 @@ impl TES { fn check(&self) -> bool { let resp = &self.service; - return resp.as_ref().unwrap().r#type.artifact == "tes"; - // true + match resp.as_ref() { + Ok(service) => service.r#type.artifact == "tes", + Err(_) => false, // or handle the error as appropriate + } } pub async fn create( @@ -150,10 +152,10 @@ impl TES { }; Ok(task) } - Err(e) => { - log::error!("Error: {}", e); - Err(e) - } + Err(e) => Err(Box::new(std::io::Error::new( + std::io::ErrorKind::Other, + format!("Failed to post task: {}", e), + ))), } } @@ -244,9 +246,8 @@ mod tests { return Err(e); } }; - - let task_json = - std::fs::read_to_string("./lib/sample/grape.tes").expect("Unable to read file"); + let file_path = std::env::var("TASK_FILE_PATH").unwrap_or_else(|_| "./lib/sample/grape.tes".to_string()); + let task_json = std::fs::read_to_string(file_path).expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); let task = tes.create(task).await?; @@ -287,7 +288,7 @@ mod tests { setup(); let (task, _tes) = &create_task().await.expect("Failed to create task"); - assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion let cancel = task.cancel().await; assert!(cancel.is_ok()); diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 0a3d2e7..15349c4 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -27,19 +27,12 @@ impl Transport { params: Option, ) -> Result> { let full_url = format!("{}{}", self.config.base_path, endpoint); - let url = reqwest::Url::parse(&full_url); - if url.is_err() { - error!( - "Invalid endpoint (shouldn't contain base url): {}", - endpoint - ); - return Err(Box::new(std::io::Error::new( - std::io::ErrorKind::InvalidInput, - "Invalid endpoint", - ))); - } + let url = reqwest::Url::parse(&full_url).map_err(|_| { + error!("Invalid endpoint (shouldn't contain base url): {}", endpoint); + Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid endpoint")) as Box + })?; - let mut request_builder = self.client.request(method, &full_url).header( + let mut request_builder = self.client.request(method, url).header( reqwest::header::USER_AGENT, self.config.user_agent.clone().unwrap_or_default(), ); @@ -48,21 +41,24 @@ impl Transport { request_builder = request_builder.query(params_value); } - if let Some(ref data_value) = data { - request_builder = request_builder.json(&data_value); + if let Some(ref data) = data { + request_builder = request_builder.json(&data); } - let resp = request_builder.send().await?; + let resp = request_builder.send().await.map_err(|e| { + eprintln!("HTTP request failed: {}", e); + e + })?; let status = resp.status(); - let content = resp.text().await?; + let content = resp.text().await.map_err(|e| format!("Failed to read response text: {}", e))?; if status.is_success() { Ok(content) } else { Err(Box::new(std::io::Error::new( std::io::ErrorKind::Other, - content, + format!("Request failed with status: {}. Response: {}", status, content), ))) } } From e56a623906686653e29925e1d47bf54d72c0e7c9 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 1 Jul 2024 17:26:19 +0530 Subject: [PATCH 56/92] sorcery-ai suggestions --- lib/src/tes/mod.rs | 16 +++++++++++++--- lib/src/transport.rs | 8 +++++++- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 2a2046b..567b98d 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -57,7 +57,11 @@ impl Task { let task: TesTask = from_str(&resp_str)?; Ok(task.state.unwrap()) } - Err(e) => Err(e), + Err(e) => { + let err_msg = format!("HTTP request failed: {}", e); + eprintln!("{}", err_msg); + Err(Box::new(std::io::Error::new(std::io::ErrorKind::Other, err_msg))) + } } } @@ -218,7 +222,13 @@ impl TES { let task: TesListTasksResponse = from_str(&resp_str)?; Ok(task) } - Err(e) => Err(e), + Err(e) => { + eprintln!("HTTP request failed: {:?}", e); + Err(Box::new(std::io::Error::new( + std::io::ErrorKind::Other, + format!("HTTP request failed: {:?}", e), + ))) + } } } } @@ -258,7 +268,7 @@ mod tests { async fn test_task_create() { setup(); let (task, _tes) = create_task().await.expect("Failed to create task"); - assert!(!task.id.is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + assert!(!task.id.is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion } #[tokio::test] diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 15349c4..8cef17f 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -38,7 +38,13 @@ impl Transport { ); if let Some(ref params_value) = params { - request_builder = request_builder.query(params_value); + // Validate or log params_value before setting it as query parameters + if params_value.is_object() { + request_builder = request_builder.query(params_value); + } else { + error!("params_value is not an object and cannot be used as query parameters: {:?}", params_value); + return Err(Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "params_value must be an object"))); + } } if let Some(ref data) = data { From d37b0003e6d4f91d8670e2247b7ed23e003a3efd Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 1 Jul 2024 18:16:06 +0530 Subject: [PATCH 57/92] sorcery-ai suggestions --- lib/src/tes/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 567b98d..4520979 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -309,7 +309,7 @@ mod tests { setup(); let (task, tes) = &create_task().await.expect("Failed to create task"); - assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // doube check if it's a correct assertion + assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion let params: ListTasksParams = ListTasksParams { name_prefix: None, From 7725298af0b3df789184b3ebc79cd96ea22bcf4f Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 4 Jul 2024 10:45:40 +0530 Subject: [PATCH 58/92] added some Pavel's suggestions --- .github/workflows/ci.yml | 116 -------------------------------- Cargo.toml | 6 +- lib/src/tes/mod.rs | 34 ++++------ tests/Readme.md | 3 + {lib/sample => tests}/grape.tes | 0 5 files changed, 19 insertions(+), 140 deletions(-) delete mode 100644 .github/workflows/ci.yml create mode 100644 tests/Readme.md rename {lib/sample => tests}/grape.tes (100%) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml deleted file mode 100644 index de45f35..0000000 --- a/.github/workflows/ci.yml +++ /dev/null @@ -1,116 +0,0 @@ -name: CI - -on: [push, pull_request] - -jobs: - build: - - runs-on: ubuntu-latest - container: - image: ubuntu:20.04 - env: - OPENSSL_DIR: /usr/include/openssl - OPENSSL_LIB_DIR: /usr/lib/x86_64-linux-gnu - OPENSSL_INCLUDE_DIR: /usr/include/openssl - - steps: - - - name: Cache Rust dependencies - uses: actions/cache@v2 - with: - path: ~/.cargo - key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} - restore-keys: ${{ runner.os }}-cargo- - - - name: Cache Rust build output - uses: actions/cache@v2 - with: - path: target - key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} - restore-keys: ${{ runner.os }}-build- - - - name: Cache Node.js dependencies - uses: actions/cache@v2 - with: - path: ~/.npm - key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} - restore-keys: ${{ runner.os }}-node- - - - name: Cache Maven dependencies - uses: actions/cache@v2 - with: - path: ~/.m2/repository - key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} - restore-keys: ${{ runner.os }}-maven- - - - name: Cache Go modules - uses: actions/cache@v2 - with: - path: ~/.cache/go-build - key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} - restore-keys: ${{ runner.os }}-go- - - - name: Cache Funnel dependencies - uses: actions/cache@v2 - with: - path: ~/funnel/build - key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} - restore-keys: ${{ runner.os }}-funnel- - - - name: Install Rust - run: | - apt-get update - apt-get install -y curl git build-essential libssl-dev - if ! command -v rustup &> /dev/null # might not be installed while executing using `act` - then - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - . $HOME/.cargo/env - fi - rustup update stable - - name: Install Node.js # required for build-models.sh - run: | - REQUIRED_NODE_VERSION=22 - if command -v node &> /dev/null; then - curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh - bash nodesource_setup.sh - apt-get install -y nodejs - fi - - name: Set up JDK 11 # required for build-models.sh - uses: actions/setup-java@v2 - with: - distribution: 'adopt' - java-version: '11' - - name: Install Go - uses: actions/setup-go@v2 - with: - go-version: '^1.22' - - name: Install Funnel - run: | - if [ -d "funnel" ]; then rm -Rf funnel; fi - git clone https://github.com/ohsu-comp-bio/funnel.git - cd funnel && make && make install && cd .. - - uses: actions/checkout@v2 # checkout the repository - - name: Build models - run: | - . $HOME/.cargo/env - bash ./build-models.sh - - name: Build - run: | - . $HOME/.cargo/env - cargo build --verbose - - name: Run tests - run: | - . $HOME/.cargo/env - bash ./run-tests.sh - - name: Lint - run: | - . $HOME/.cargo/env - cargo clippy -- -D warnings - - name: Format - run: | - . $HOME/.cargo/env - # rustup install nightly – fails for some reason - # rustup default nightly - cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting - cargo fmt -- ./lib/src/tes/models/*.rs - cargo fmt -- --check # --config-path ./rustfmt.toml \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index f3888cf..3602693 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,9 +1,9 @@ [package] -name = "lib" +name = "ga4gh-sdk" version = "0.1.0" authors = ["Aarav Mehta"] edition = "2021" -description = "A library to interact with the different API's of GA4GH" +description = "Generic SDK and CLI for GA4GH API services" license = "Apache-2.0" repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk.git" @@ -27,5 +27,5 @@ mockito = "0.31" mockall = "0.10.2" [lib] -name = "my_project" +name = "ga4gh_sdk" path = "lib/src/lib.rs" \ No newline at end of file diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 4520979..4f92289 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -69,10 +69,7 @@ impl Task { let id = &self.id; let id = &urlencode(id); let url = format!("/tasks/{}:cancel", id); - // let url= &urlencode(url); - // println!("{:?}",url); let response = self.transport.post(&url, None).await; - // println!("the response is: {:?}",response); match response { Ok(resp_str) => { let parsed_json = serde_json::from_str::(&resp_str); @@ -92,7 +89,6 @@ pub struct TES { service: Result>, transport: Transport, } -// *** see question above impl TES { pub async fn new(config: &Configuration) -> Result> { @@ -101,25 +97,22 @@ impl TES { let resp = service_info.get().await; - // println!("artifact: {}",resp.clone().unwrap().r#type.artifact); let instance = TES { config: config.clone(), transport, service: resp, }; - if instance.check() { - Ok(instance) - } else { - Err("The endpoint is not an instance of TES".into()) - } + instance.check()?; // Propagate the error if check() fails + Ok(instance) } - fn check(&self) -> bool { + fn check(&self) -> Result<(), String> { let resp = &self.service; match resp.as_ref() { - Ok(service) => service.r#type.artifact == "tes", - Err(_) => false, // or handle the error as appropriate + Ok(service) if service.r#type.artifact == "tes" => Ok(()), + Ok(_) => Err("The endpoint is not an instance of TES".into()), + Err(_) => Err("Error accessing the service".into()), } } @@ -128,11 +121,10 @@ impl TES { task: TesTask, /*, params: models::TesTask*/ ) -> Result> { // First, check if the service is of TES class - if !self.check() { - // If check fails, log an error and return an Err immediately - log::error!("Service check failed"); - return Err("Service check failed".into()); - } + self.check().map_err(|e| { + log::error!("Service check failed: {}", e); + e + })?; // todo: version in url based on serviceinfo or user config let response = self .transport @@ -256,7 +248,7 @@ mod tests { return Err(e); } }; - let file_path = std::env::var("TASK_FILE_PATH").unwrap_or_else(|_| "./lib/sample/grape.tes".to_string()); + let file_path = "./tests/grape.tes".to_string(); let task_json = std::fs::read_to_string(file_path).expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); @@ -298,7 +290,7 @@ mod tests { setup(); let (task, _tes) = &create_task().await.expect("Failed to create task"); - assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion + assert!(!task.id.is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion let cancel = task.cancel().await; assert!(cancel.is_ok()); @@ -309,7 +301,7 @@ mod tests { setup(); let (task, tes) = &create_task().await.expect("Failed to create task"); - assert!(!task.id.clone().is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion + assert!(!task.id.is_empty(), "Task ID should not be empty"); // double check if it's a correct assertion let params: ListTasksParams = ListTasksParams { name_prefix: None, diff --git a/tests/Readme.md b/tests/Readme.md new file mode 100644 index 0000000..8d2d257 --- /dev/null +++ b/tests/Readme.md @@ -0,0 +1,3 @@ +# A folder for adding the files being used in unit tests + +grape.tes: a sample file containing JSON task data for the GA4GH (Task Execution Service)[https://github.com/ga4gh/task-execution-schemas] in the file lib/src/tes/mod.rs. Notably, it has placeholders like "${AWS_ACCESS_KEY_ID}" which is out of the standard and implies implementing a pre-processor, might be useful to note and implement in future as it avoids storing credentials in such .tes files \ No newline at end of file diff --git a/lib/sample/grape.tes b/tests/grape.tes similarity index 100% rename from lib/sample/grape.tes rename to tests/grape.tes From bad81eb0c3a62787b7689877d7210ff1718cceb7 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 4 Jul 2024 10:48:24 +0530 Subject: [PATCH 59/92] readding accidently deleted workflows folder --- .github/workflows/ci.yml | 116 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..c553d56 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,116 @@ +name: CI + +on: [push, pull_request] + +jobs: + build: + + runs-on: ubuntu-latest + container: + image: ubuntu:20.04 + env: + OPENSSL_DIR: /usr/include/openssl + OPENSSL_LIB_DIR: /usr/lib/x86_64-linux-gnu + OPENSSL_INCLUDE_DIR: /usr/include/openssl + + steps: + + - name: Cache Rust dependencies + uses: actions/cache@v2 + with: + path: ~/.cargo + key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-cargo- + + - name: Cache Rust build output + uses: actions/cache@v2 + with: + path: target + key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-build- + + - name: Cache Node.js dependencies + uses: actions/cache@v2 + with: + path: ~/.npm + key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} + restore-keys: ${{ runner.os }}-node- + + - name: Cache Maven dependencies + uses: actions/cache@v2 + with: + path: ~/.m2/repository + key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-maven- + + - name: Cache Go modules + uses: actions/cache@v2 + with: + path: ~/.cache/go-build + key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} + restore-keys: ${{ runner.os }}-go- + + - name: Cache Funnel dependencies + uses: actions/cache@v2 + with: + path: ~/funnel/build + key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} + restore-keys: ${{ runner.os }}-funnel- + + - name: Install Rust + run: | + apt-get update + apt-get install -y curl git build-essential libssl-dev + if ! command -v rustup &> /dev/null # might not be installed while executing using `act` + then + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + . $HOME/.cargo/env + fi + rustup update stable + - name: Install Node.js # required for build-models.sh + run: | + REQUIRED_NODE_VERSION=22 + if command -v node &> /dev/null; then + curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh + bash nodesource_setup.sh + apt-get install -y nodejs + fi + - name: Set up JDK 11 # required for build-models.sh + uses: actions/setup-java@v2 + with: + distribution: 'adopt' + java-version: '11' + - name: Install Go + uses: actions/setup-go@v2 + with: + go-version: '^1.22' + - name: Install Funnel + run: | + if [ -d "funnel" ]; then rm -Rf funnel; fi + git clone https://github.com/ohsu-comp-bio/funnel.git + cd funnel && make && make install && cd .. + - uses: actions/checkout@v2 # checkout the repository + - name: Build models + run: | + . $HOME/.cargo/env + bash ./build-models.sh + - name: Build + run: | + . $HOME/.cargo/env + cargo build --verbose + - name: Run tests + run: | + . $HOME/.cargo/env + bash ./run-tests.sh + - name: Lint + run: | + . $HOME/.cargo/env + cargo clippy -- -D warnings + - name: Format + run: | + . $HOME/.cargo/env + # rustup install nightly – fails for some reason + # rustup default nightly + cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting + cargo fmt -- ./lib/src/tes/models/*.rs + cargo fmt -- --check # --config-path ./rustfmt.toml \ No newline at end of file From c95ac80f078cc60b78b184350c523e7fff8e3f37 Mon Sep 17 00:00:00 2001 From: Aarav Mehta <32593731+aaravm@users.noreply.github.com> Date: Thu, 4 Jul 2024 10:51:37 +0530 Subject: [PATCH 60/92] Update Readme.md --- tests/Readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/Readme.md b/tests/Readme.md index 8d2d257..0129a10 100644 --- a/tests/Readme.md +++ b/tests/Readme.md @@ -1,3 +1,3 @@ # A folder for adding the files being used in unit tests -grape.tes: a sample file containing JSON task data for the GA4GH (Task Execution Service)[https://github.com/ga4gh/task-execution-schemas] in the file lib/src/tes/mod.rs. Notably, it has placeholders like "${AWS_ACCESS_KEY_ID}" which is out of the standard and implies implementing a pre-processor, might be useful to note and implement in future as it avoids storing credentials in such .tes files \ No newline at end of file +grape.tes: a sample file containing JSON task data for the GA4GH [Task Execution Service](https://github.com/ga4gh/task-execution-schemas) in the file lib/src/tes/mod.rs. Notably, it has placeholders like "${AWS_ACCESS_KEY_ID}" which is out of the standard and implies implementing a pre-processor, might be useful to note and implement in future as it avoids storing credentials in such .tes files From 198e0f84f47526ee1abf3dcafdced497cbbfa4ff Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 4 Jul 2024 11:10:57 +0530 Subject: [PATCH 61/92] changed Cargo.toml --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 3602693..860cb37 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "ga4gh-sdk" version = "0.1.0" -authors = ["Aarav Mehta"] +authors = ["Aarav Mehta ", "ELIXIR Cloud & AAI ", "GENXT "] edition = "2021" description = "Generic SDK and CLI for GA4GH API services" license = "Apache-2.0" From 206c6c44f92155268e27066cc8132bb9f677bdf4 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 4 Jul 2024 16:45:20 +0530 Subject: [PATCH 62/92] changed the sample file, changed author name --- Cargo.toml | 2 +- lib/src/tes/mod.rs | 2 +- tests/Readme.md | 6 +++++- tests/sample.tes | 16 ++++++++++++++++ 4 files changed, 23 insertions(+), 3 deletions(-) create mode 100644 tests/sample.tes diff --git a/Cargo.toml b/Cargo.toml index 860cb37..28456b4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "ga4gh-sdk" version = "0.1.0" -authors = ["Aarav Mehta ", "ELIXIR Cloud & AAI ", "GENXT "] +authors = ["Aarav Mehta ", "Pavel Nikonorov", "ELIXIR Cloud & AAI "] edition = "2021" description = "Generic SDK and CLI for GA4GH API services" license = "Apache-2.0" diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 4f92289..e13977e 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -248,7 +248,7 @@ mod tests { return Err(e); } }; - let file_path = "./tests/grape.tes".to_string(); + let file_path = "./tests/sample.tes".to_string(); let task_json = std::fs::read_to_string(file_path).expect("Unable to read file"); let task: TesTask = serde_json::from_str(&task_json).expect("JSON was not well-formatted"); diff --git a/tests/Readme.md b/tests/Readme.md index 0129a10..21ba62f 100644 --- a/tests/Readme.md +++ b/tests/Readme.md @@ -1,3 +1,7 @@ # A folder for adding the files being used in unit tests -grape.tes: a sample file containing JSON task data for the GA4GH [Task Execution Service](https://github.com/ga4gh/task-execution-schemas) in the file lib/src/tes/mod.rs. Notably, it has placeholders like "${AWS_ACCESS_KEY_ID}" which is out of the standard and implies implementing a pre-processor, might be useful to note and implement in future as it avoids storing credentials in such .tes files + +sample.tes: This is a sample file, taken from the [funnel docs](https://ohsu-comp-bio.github.io/funnel/docs/tasks/), and this file is being used in the file lib/src/tes/mod.rs + + +grape.tes: a sample file containing JSON task data for the GA4GH [Task Execution Service](https://github.com/ga4gh/task-execution-schemas), which can be used in the file lib/src/tes/mod.rs instead of sample.tes. Notably, it has placeholders like "${AWS_ACCESS_KEY_ID}" which is out of the standard and implies implementing a pre-processor, might be useful to note and implement in future as it avoids storing credentials in such .tes files diff --git a/tests/sample.tes b/tests/sample.tes new file mode 100644 index 0000000..e663c3a --- /dev/null +++ b/tests/sample.tes @@ -0,0 +1,16 @@ +{ + "name": "Hello world", + "inputs": [{ + "url": "s3://funnel-bucket/hello.txt", + "path": "/inputs/hello.txt" + }], + "outputs": [{ + "url": "s3://funnel-bucket/output.txt", + "path": "/outputs/stdout" + }], + "executors": [{ + "image": "alpine", + "command": ["cat", "/inputs/hello.txt"], + "stdout": "/outputs/stdout" + }] +} From 2f2b6a8c7d6e1d10ce05cef04aaae99e03e2e02d Mon Sep 17 00:00:00 2001 From: aaravm Date: Fri, 5 Jul 2024 19:49:53 +0530 Subject: [PATCH 63/92] changed versions of ci.yml --- .github/workflows/ci.yml | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c553d56..cb14d19 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -7,7 +7,7 @@ jobs: runs-on: ubuntu-latest container: - image: ubuntu:20.04 + image: ubuntu:24.04 env: OPENSSL_DIR: /usr/include/openssl OPENSSL_LIB_DIR: /usr/lib/x86_64-linux-gnu @@ -16,42 +16,42 @@ jobs: steps: - name: Cache Rust dependencies - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: ~/.cargo key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} restore-keys: ${{ runner.os }}-cargo- - name: Cache Rust build output - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: target key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} restore-keys: ${{ runner.os }}-build- - name: Cache Node.js dependencies - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: ~/.npm key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} restore-keys: ${{ runner.os }}-node- - name: Cache Maven dependencies - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: ~/.m2/repository key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} restore-keys: ${{ runner.os }}-maven- - name: Cache Go modules - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: ~/.cache/go-build key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} restore-keys: ${{ runner.os }}-go- - name: Cache Funnel dependencies - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: ~/funnel/build key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} @@ -67,21 +67,20 @@ jobs: . $HOME/.cargo/env fi rustup update stable - - name: Install Node.js # required for build-models.sh - run: | - REQUIRED_NODE_VERSION=22 - if command -v node &> /dev/null; then - curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh - bash nodesource_setup.sh - apt-get install -y nodejs - fi + + - name: Install Node.js # required for build-models.sh + run: | + curl -fsSL https://deb.nodesource.com/setup_22.x | bash - + apt-get install -y nodejs + - name: Set up JDK 11 # required for build-models.sh - uses: actions/setup-java@v2 + uses: actions/setup-java@v3 with: distribution: 'adopt' java-version: '11' + - name: Install Go - uses: actions/setup-go@v2 + uses: actions/setup-go@v4 with: go-version: '^1.22' - name: Install Funnel @@ -89,7 +88,7 @@ jobs: if [ -d "funnel" ]; then rm -Rf funnel; fi git clone https://github.com/ohsu-comp-bio/funnel.git cd funnel && make && make install && cd .. - - uses: actions/checkout@v2 # checkout the repository + - uses: actions/checkout@v4 # checkout the repository - name: Build models run: | . $HOME/.cargo/env From 4a4154802352c3f729f1b943a1a208f47c35bcde Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 02:21:53 +0530 Subject: [PATCH 64/92] added parameters in a much easier manner --- lib/src/configuration.rs | 11 ++++++++-- lib/src/tes/mod.rs | 43 +++++++++++++++------------------------- lib/src/transport.rs | 2 +- 3 files changed, 26 insertions(+), 30 deletions(-) diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs index 8e2b8bd..6cacca2 100644 --- a/lib/src/configuration.rs +++ b/lib/src/configuration.rs @@ -9,7 +9,13 @@ pub struct Configuration { // TODO: take an oauth2 token source, similar to the go one } -pub type BasicAuth = (String, Option); +// Check whether defining BasicAuth works like this or not, else revert to the basic definition commented out +#[derive(Debug, Clone)] +pub struct BasicAuth { + pub username: String, + pub password: Option, +} +// pub type BasicAuth = (String, Option); #[derive(Debug, Clone)] pub struct ApiKey { @@ -21,12 +27,13 @@ impl Configuration { pub fn new( base_path: String, user_agent: Option, + basic_auth: Option, oauth_access_token: Option, ) -> Self { Configuration { base_path, user_agent, - basic_auth: None, + basic_auth, oauth_access_token, bearer_access_token: None, api_key: None, diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index e13977e..9b9c390 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -9,27 +9,41 @@ use crate::transport::Transport; use serde_json; use serde_json::from_str; use serde_json::json; +use serde::Serialize; +use serde_json::Value; + + +fn serialize_to_json(item: T) -> Value { + serde_json::to_value(&item).unwrap() +} pub fn urlencode>(s: T) -> String { ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() } /// struct for passing parameters to the method [`list_tasks`] -#[derive(Clone, Debug)] +#[derive(Serialize, Clone, Debug)] pub struct ListTasksParams { /// OPTIONAL. Filter the list to include tasks where the name matches this prefix. If unspecified, no task name filtering is done. + #[serde(skip_serializing_if = "Option::is_none")] pub name_prefix: Option, /// OPTIONAL. Filter tasks by state. If unspecified, no task state filtering is done. + #[serde(skip_serializing_if = "Option::is_none")] pub state: Option, /// OPTIONAL. Provide key tag to filter. The field tag_key is an array of key values, and will be zipped with an optional tag_value array. So the query: ``` ?tag_key=foo1&tag_value=bar1&tag_key=foo2&tag_value=bar2 ``` Should be constructed into the structure { \"foo1\" : \"bar1\", \"foo2\" : \"bar2\"} ``` ?tag_key=foo1 ``` Should be constructed into the structure {\"foo1\" : \"\"} If the tag_value is empty, it will be treated as matching any possible value. If a tag value is provided, both the tag's key and value must be exact matches for a task to be returned. Filter Tags Match? ---------------------------------------------------------------------- {\"foo\": \"bar\"} {\"foo\": \"bar\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bat\"} No {\"foo\": \"\"} {\"foo\": \"\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\"} No {\"foo\": \"\"} {\"foo\": \"bar\"} Yes {\"foo\": \"\"} {} No + #[serde(skip_serializing_if = "Option::is_none")] pub tag_key: Option>, /// OPTIONAL. The companion value field for tag_key + #[serde(skip_serializing_if = "Option::is_none")] pub tag_value: Option>, /// Optional number of tasks to return in one page. Must be less than 2048. Defaults to 256. + #[serde(skip_serializing_if = "Option::is_none")] pub page_size: Option, /// OPTIONAL. Page token is used to retrieve the next page of results. If unspecified, returns the first page of results. The value can be found in the `next_page_token` field of the last returned result of ListTasks + #[serde(skip_serializing_if = "Option::is_none")] pub page_token: Option, /// OPTIONAL. Affects the fields included in the returned Task messages. `MINIMAL`: Task message will include ONLY the fields: - `tesTask.Id` - `tesTask.State` `BASIC`: Task message will include all fields EXCEPT: - `tesTask.ExecutorLog.stdout` - `tesTask.ExecutorLog.stderr` - `tesInput.content` - `tesTaskLog.system_logs` `FULL`: Task message includes all fields. + #[serde(skip_serializing_if = "Option::is_none")] pub view: Option, } @@ -174,33 +188,8 @@ impl TES { &self, params: Option, ) -> Result> { - let params_value = params.map(|p| { - let mut map = serde_json::Map::new(); - - if let Some(name_prefix) = p.name_prefix { - map.insert("name_prefix".to_string(), json!(name_prefix)); - } - if let Some(state) = p.state { - map.insert("state".to_string(), json!(state)); - } - if let Some(tag_key) = p.tag_key { - map.insert("tag_key".to_string(), json!(tag_key)); - } - if let Some(tag_value) = p.tag_value { - map.insert("tag_value".to_string(), json!(tag_value)); - } - if let Some(page_size) = p.page_size { - map.insert("page_size".to_string(), json!(page_size)); - } - if let Some(page_token) = p.page_token { - map.insert("page_token".to_string(), json!(page_token)); - } - if let Some(view) = p.view { - map.insert("view".to_string(), json!(view)); - } + let params_value = params.map(serialize_to_json); - json!(map) - }); // println!("{:?}",params_value); // Make the request with or without parameters based on the presence of params let response = if let Some(params_value) = params_value { diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 8cef17f..36389b9 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -119,7 +119,7 @@ mod tests { .with_body(r#"{"message": "success"}"#) .create(); - let config = Configuration::new(base_url.clone(), None, None); + let config = Configuration::new(base_url.clone(),None, None, None); let transport = Transport::new(&config.clone()); let response = transport.get("/test", None).await; From 2d48bdd2f504a6f6d7dfb97ba6c99356290b48ef Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 02:35:34 +0530 Subject: [PATCH 65/92] changing git ignore file --- .gitignore | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index f387ce0..8c999f8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,10 +1,10 @@ +target/ +debug/ Cargo.lock openapitools.json package.json package-lock.json node_modules/ -target/ -.vscode lib/src/**/models/ *.log funnel-work-dir/ From a5b484eccd79e48b5c635b253488e652e2838dbc Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 14:38:58 +0530 Subject: [PATCH 66/92] changed local and github workflows --- .github/workflows/ci.yml | 55 +---------------- .github/workflows/local.yml | 115 ++++++++++++++++++++++++++++++++++++ README.md | 2 +- lib/src/configuration.rs | 1 - 4 files changed, 117 insertions(+), 56 deletions(-) create mode 100644 .github/workflows/local.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cb14d19..1b2fcdb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,4 +1,4 @@ -name: CI +name: GitHub CI/CD Workflow on: [push, pull_request] @@ -15,59 +15,6 @@ jobs: steps: - - name: Cache Rust dependencies - uses: actions/cache@v3 - with: - path: ~/.cargo - key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} - restore-keys: ${{ runner.os }}-cargo- - - - name: Cache Rust build output - uses: actions/cache@v3 - with: - path: target - key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} - restore-keys: ${{ runner.os }}-build- - - - name: Cache Node.js dependencies - uses: actions/cache@v3 - with: - path: ~/.npm - key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} - restore-keys: ${{ runner.os }}-node- - - - name: Cache Maven dependencies - uses: actions/cache@v3 - with: - path: ~/.m2/repository - key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} - restore-keys: ${{ runner.os }}-maven- - - - name: Cache Go modules - uses: actions/cache@v3 - with: - path: ~/.cache/go-build - key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} - restore-keys: ${{ runner.os }}-go- - - - name: Cache Funnel dependencies - uses: actions/cache@v3 - with: - path: ~/funnel/build - key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} - restore-keys: ${{ runner.os }}-funnel- - - - name: Install Rust - run: | - apt-get update - apt-get install -y curl git build-essential libssl-dev - if ! command -v rustup &> /dev/null # might not be installed while executing using `act` - then - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - . $HOME/.cargo/env - fi - rustup update stable - - name: Install Node.js # required for build-models.sh run: | curl -fsSL https://deb.nodesource.com/setup_22.x | bash - diff --git a/.github/workflows/local.yml b/.github/workflows/local.yml new file mode 100644 index 0000000..6d6775b --- /dev/null +++ b/.github/workflows/local.yml @@ -0,0 +1,115 @@ +name: Local CI/CD Workflow + +on: workflow_dispatch + +jobs: + build: + + runs-on: ubuntu-latest + container: + image: ubuntu:24.04 + env: + OPENSSL_DIR: /usr/include/openssl + OPENSSL_LIB_DIR: /usr/lib/x86_64-linux-gnu + OPENSSL_INCLUDE_DIR: /usr/include/openssl + + steps: + + - name: Cache Rust dependencies + uses: actions/cache@v3 + with: + path: ~/.cargo + key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-cargo- + + - name: Cache Rust build output + uses: actions/cache@v3 + with: + path: target + key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-build- + + - name: Cache Node.js dependencies + uses: actions/cache@v3 + with: + path: ~/.npm + key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} + restore-keys: ${{ runner.os }}-node- + + - name: Cache Maven dependencies + uses: actions/cache@v3 + with: + path: ~/.m2/repository + key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-maven- + + - name: Cache Go modules + uses: actions/cache@v3 + with: + path: ~/.cache/go-build + key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} + restore-keys: ${{ runner.os }}-go- + + - name: Cache Funnel dependencies + uses: actions/cache@v3 + with: + path: ~/funnel/build + key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} + restore-keys: ${{ runner.os }}-funnel- + + - name: Install Rust + run: | + apt-get update + apt-get install -y curl git build-essential libssl-dev + if ! command -v rustup &> /dev/null # might not be installed while executing using `act` + then + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + . $HOME/.cargo/env + fi + rustup update stable + + - name: Install Node.js # required for build-models.sh + run: | + curl -fsSL https://deb.nodesource.com/setup_22.x | bash - + apt-get install -y nodejs + + - name: Set up JDK 11 # required for build-models.sh + uses: actions/setup-java@v3 + with: + distribution: 'adopt' + java-version: '11' + + - name: Install Go + uses: actions/setup-go@v4 + with: + go-version: '^1.22' + - name: Install Funnel + run: | + if [ -d "funnel" ]; then rm -Rf funnel; fi + git clone https://github.com/ohsu-comp-bio/funnel.git + cd funnel && make && make install && cd .. + - uses: actions/checkout@v4 # checkout the repository + - name: Build models + run: | + . $HOME/.cargo/env + bash ./build-models.sh + - name: Build + run: | + . $HOME/.cargo/env + cargo build --verbose + - name: Run tests + run: | + . $HOME/.cargo/env + bash ./run-tests.sh + - name: Lint + run: | + . $HOME/.cargo/env + cargo clippy -- -D warnings + - name: Format + run: | + . $HOME/.cargo/env + # rustup install nightly – fails for some reason + # rustup default nightly + cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting + cargo fmt -- ./lib/src/tes/models/*.rs + cargo fmt -- --check # --config-path ./rustfmt.toml \ No newline at end of file diff --git a/README.md b/README.md index 2db7c23..d7fb810 100644 --- a/README.md +++ b/README.md @@ -24,5 +24,5 @@ bash ./run-tests.sh To test the CI/CD workflow locally, install `act` and run the following command: ``` -act -j build --container-architecture linux/amd64 -P ubuntu-latest=ubuntu:20.04 --reuse +act -j build --container-architecture linux/amd64 -P ubuntu-latest=ubuntu:24.04 --reuse ``` \ No newline at end of file diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs index 6cacca2..c823b2c 100644 --- a/lib/src/configuration.rs +++ b/lib/src/configuration.rs @@ -6,7 +6,6 @@ pub struct Configuration { pub oauth_access_token: Option, pub bearer_access_token: Option, pub api_key: Option, - // TODO: take an oauth2 token source, similar to the go one } // Check whether defining BasicAuth works like this or not, else revert to the basic definition commented out From 598646f1eca699542987a709d0fd14d747f138aa Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 14:41:38 +0530 Subject: [PATCH 67/92] correct github workflows --- .github/workflows/ci.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1b2fcdb..6f66991 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,6 +14,10 @@ jobs: OPENSSL_INCLUDE_DIR: /usr/include/openssl steps: + - name: Install dependencies + run: | + apt-get update + apt-get install -y curl git build-essential libssl-dev - name: Install Node.js # required for build-models.sh run: | From 1369f7e94b07d8e0c0ec2b05543819df240020a1 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 14:49:33 +0530 Subject: [PATCH 68/92] correct github workflows --- .github/workflows/ci.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6f66991..eb33cfb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,10 +14,16 @@ jobs: OPENSSL_INCLUDE_DIR: /usr/include/openssl steps: - - name: Install dependencies + - name: Install Rust run: | apt-get update apt-get install -y curl git build-essential libssl-dev + if ! command -v rustup &> /dev/null # might not be installed while executing using `act` + then + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + . $HOME/.cargo/env + fi + rustup update stable - name: Install Node.js # required for build-models.sh run: | From 8ec57ccdc66735f801844ba638809a7e88a09906 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 15:42:16 +0530 Subject: [PATCH 69/92] using cargo nextest for tests --- Cargo.toml | 1 + README.md | 4 ++++ lib/src/lib.rs | 3 +-- nextest.toml | 15 +++++++++++++++ run-tests.sh | 1 + 5 files changed, 22 insertions(+), 2 deletions(-) create mode 100644 nextest.toml diff --git a/Cargo.toml b/Cargo.toml index 28456b4..e1ed8f7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,6 +25,7 @@ features = ["json", "multipart"] [dev-dependencies] mockito = "0.31" mockall = "0.10.2" +cargo-nextest = "0.9.30" [lib] name = "ga4gh_sdk" diff --git a/README.md b/README.md index d7fb810..f1521c6 100644 --- a/README.md +++ b/README.md @@ -21,6 +21,10 @@ Once you have installed Funnel, you can run the tests. This will automatically r ``` bash ./run-tests.sh ``` +or, you can run using cargo nextest using +``` +cargo nextest run +``` To test the CI/CD workflow locally, install `act` and run the following command: ``` diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 5a3f1f7..e9fc376 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -1,5 +1,4 @@ -#[macro_use] -extern crate serde_derive; +// extern crate serde_derive; #[cfg(test)] mod test_utils; diff --git a/nextest.toml b/nextest.toml new file mode 100644 index 0000000..02d1453 --- /dev/null +++ b/nextest.toml @@ -0,0 +1,15 @@ +[profile.default] +retries = 1 + +[script-pre-commands] +[[profile.default]] +commands = [ + { cmd = "sh", args = ["-c", "if ! ps aux | grep '[f]unnel server run'; then echo 'Funnel server is not running. Starting it now...'; export PATH=$PATH:~/go/bin; funnel server run --Server.HostName=localhost --Server.HTTPPort=8000 > funnel.log 2>&1 & fi"] }, + { cmd = "sh", args = ["-c", "while ! curl -s http://localhost:8000/healthz > /dev/null; do echo 'Waiting for Funnel server...'; sleep 1; done; echo 'Funnel server is running.'"] } +] + +[script-post-commands] +[[profile.default]] +commands = [ + # Add any post-test teardown commands here if needed +] diff --git a/run-tests.sh b/run-tests.sh index 9d32617..ea1a154 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -17,6 +17,7 @@ if ! ps aux | grep '[f]unnel server run'; then # If it's not running, start it echo "Funnel server is not running. Starting it now..." + export PATH=$PATH:~/go/bin funnel server run --Server.HostName=localhost --Server.HTTPPort=8000 > funnel.log 2>&1 & else echo "Funnel server is already running." From 1913d3dfc54cd41e5d2daa52850ca1eeea6285d1 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 15:50:20 +0530 Subject: [PATCH 70/92] correcting ci/cd --- lib/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/src/lib.rs b/lib/src/lib.rs index e9fc376..454b52e 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -1,4 +1,4 @@ -// extern crate serde_derive; +extern crate serde_derive; #[cfg(test)] mod test_utils; From ee0948c189a502ff0ccd925b6d9614e63abb2ebd Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 15:58:38 +0530 Subject: [PATCH 71/92] correcting ci/cd --- lib/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 454b52e..5a3f1f7 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -1,3 +1,4 @@ +#[macro_use] extern crate serde_derive; #[cfg(test)] From 44a1d643670972587d105182e5ceee663cc10dbc Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 16:04:55 +0530 Subject: [PATCH 72/92] removing commented out code --- .github/workflows/ci.yml | 4 +--- build-models.sh | 12 ------------ lib/src/lib.rs | 1 + run-tests.sh | 18 ------------------ 4 files changed, 2 insertions(+), 33 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index eb33cfb..ba5204d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -65,8 +65,6 @@ jobs: - name: Format run: | . $HOME/.cargo/env - # rustup install nightly – fails for some reason - # rustup default nightly cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting cargo fmt -- ./lib/src/tes/models/*.rs - cargo fmt -- --check # --config-path ./rustfmt.toml \ No newline at end of file + cargo fmt -- --check \ No newline at end of file diff --git a/build-models.sh b/build-models.sh index 071f6f2..dc3c28b 100755 --- a/build-models.sh +++ b/build-models.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Exit immediately if a command exits with a non-zero status. set -e @@ -13,13 +11,6 @@ get_git_repo_name() { echo "$repo_name" } -# repo_name=$(get_git_repo_name) -# if [ "$repo_name" != "ga4gh-sdk" ]; then -# echo "This script must be run from the 'ga4gh-sdk' repository." -# exit 1 -# fi - -# cd $(git rev-parse --show-toplevel) SCRIPT_DIR="$(pwd)" generate_openapi_models() { @@ -39,9 +30,6 @@ generate_openapi_models() { -i "$OPENAPI_SPEC_PATH" \ -o "$TEMP_OUTPUT_DIR" \ --additional-properties=useSingleRequestParameter=true - #--skip-validate-spec - # --global-property models,modelDocs=false,apiDocs=false,apiTests=false,modelTests=false \ - #,packageName=$API_NAME # Check if the generation was successful if [ $? -ne 0 ]; then diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 5a3f1f7..012b141 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -1,3 +1,4 @@ +#[allow(unused_imports)] #[macro_use] extern crate serde_derive; diff --git a/run-tests.sh b/run-tests.sh index ea1a154..4361c36 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -1,18 +1,3 @@ -#!/bin/bash - -# # Check if a "funnel" container is already running -# if [ $(docker ps -q -f name=funnel) ]; then -# # If it is, stop and remove it -# docker stop funnel -# docker rm funnel -# fi - -# # Build and run the Dockerized Funnel server -# cd funnel/ -# docker build -t funnel -f ./Dockerfile . -# docker run -d --name funnel -p 8000:8000 funnel -# cd .. - # Check if a "funnel" process is already running if ! ps aux | grep '[f]unnel server run'; then # If it's not running, start it @@ -35,6 +20,3 @@ echo "Funnel server is running." # Run the tests RUST_BACKTRACE=1 RUST_LOG=debug cargo test -# # Stop and remove the Funnel server container -# docker stop funnel -# docker rm funnel From 5a13d19f8269afbe0dfe6e00744e7eb5107a5de7 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 16:20:26 +0530 Subject: [PATCH 73/92] moved ListTaskParam to model.rs --- lib/src/tes/mod.rs | 29 ++--------------------------- lib/src/tes/model.rs | 27 +++++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 27 deletions(-) create mode 100644 lib/src/tes/model.rs diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 9b9c390..3ae5823 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -1,4 +1,5 @@ pub mod models; +pub mod model; use crate::configuration::Configuration; use crate::serviceinfo::models::Service; use crate::serviceinfo::ServiceInfo; @@ -6,13 +7,13 @@ use crate::tes::models::TesListTasksResponse; use crate::tes::models::TesState; use crate::tes::models::TesTask; use crate::transport::Transport; +use crate::tes::model::ListTasksParams; use serde_json; use serde_json::from_str; use serde_json::json; use serde::Serialize; use serde_json::Value; - fn serialize_to_json(item: T) -> Value { serde_json::to_value(&item).unwrap() } @@ -21,32 +22,6 @@ pub fn urlencode>(s: T) -> String { ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() } -/// struct for passing parameters to the method [`list_tasks`] -#[derive(Serialize, Clone, Debug)] -pub struct ListTasksParams { - /// OPTIONAL. Filter the list to include tasks where the name matches this prefix. If unspecified, no task name filtering is done. - #[serde(skip_serializing_if = "Option::is_none")] - pub name_prefix: Option, - /// OPTIONAL. Filter tasks by state. If unspecified, no task state filtering is done. - #[serde(skip_serializing_if = "Option::is_none")] - pub state: Option, - /// OPTIONAL. Provide key tag to filter. The field tag_key is an array of key values, and will be zipped with an optional tag_value array. So the query: ``` ?tag_key=foo1&tag_value=bar1&tag_key=foo2&tag_value=bar2 ``` Should be constructed into the structure { \"foo1\" : \"bar1\", \"foo2\" : \"bar2\"} ``` ?tag_key=foo1 ``` Should be constructed into the structure {\"foo1\" : \"\"} If the tag_value is empty, it will be treated as matching any possible value. If a tag value is provided, both the tag's key and value must be exact matches for a task to be returned. Filter Tags Match? ---------------------------------------------------------------------- {\"foo\": \"bar\"} {\"foo\": \"bar\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bat\"} No {\"foo\": \"\"} {\"foo\": \"\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\"} No {\"foo\": \"\"} {\"foo\": \"bar\"} Yes {\"foo\": \"\"} {} No - #[serde(skip_serializing_if = "Option::is_none")] - pub tag_key: Option>, - /// OPTIONAL. The companion value field for tag_key - #[serde(skip_serializing_if = "Option::is_none")] - pub tag_value: Option>, - /// Optional number of tasks to return in one page. Must be less than 2048. Defaults to 256. - #[serde(skip_serializing_if = "Option::is_none")] - pub page_size: Option, - /// OPTIONAL. Page token is used to retrieve the next page of results. If unspecified, returns the first page of results. The value can be found in the `next_page_token` field of the last returned result of ListTasks - #[serde(skip_serializing_if = "Option::is_none")] - pub page_token: Option, - /// OPTIONAL. Affects the fields included in the returned Task messages. `MINIMAL`: Task message will include ONLY the fields: - `tesTask.Id` - `tesTask.State` `BASIC`: Task message will include all fields EXCEPT: - `tesTask.ExecutorLog.stdout` - `tesTask.ExecutorLog.stderr` - `tesInput.content` - `tesTaskLog.system_logs` `FULL`: Task message includes all fields. - #[serde(skip_serializing_if = "Option::is_none")] - pub view: Option, -} - #[derive(Debug)] pub struct Task { id: String, diff --git a/lib/src/tes/model.rs b/lib/src/tes/model.rs new file mode 100644 index 0000000..a67190d --- /dev/null +++ b/lib/src/tes/model.rs @@ -0,0 +1,27 @@ +use crate::tes::models; + +/// struct for passing parameters to the method [`list_tasks`] +#[derive(Serialize, Clone, Debug)] +pub struct ListTasksParams { + /// OPTIONAL. Filter the list to include tasks where the name matches this prefix. If unspecified, no task name filtering is done. + #[serde(skip_serializing_if = "Option::is_none")] + pub name_prefix: Option, + /// OPTIONAL. Filter tasks by state. If unspecified, no task state filtering is done. + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option, + /// OPTIONAL. Provide key tag to filter. The field tag_key is an array of key values, and will be zipped with an optional tag_value array. So the query: ``` ?tag_key=foo1&tag_value=bar1&tag_key=foo2&tag_value=bar2 ``` Should be constructed into the structure { \"foo1\" : \"bar1\", \"foo2\" : \"bar2\"} ``` ?tag_key=foo1 ``` Should be constructed into the structure {\"foo1\" : \"\"} If the tag_value is empty, it will be treated as matching any possible value. If a tag value is provided, both the tag's key and value must be exact matches for a task to be returned. Filter Tags Match? ---------------------------------------------------------------------- {\"foo\": \"bar\"} {\"foo\": \"bar\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bat\"} No {\"foo\": \"\"} {\"foo\": \"\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\"} {\"foo\": \"bar\", \"baz\": \"bat\"} Yes {\"foo\": \"bar\", \"baz\": \"bat\"} {\"foo\": \"bar\"} No {\"foo\": \"\"} {\"foo\": \"bar\"} Yes {\"foo\": \"\"} {} No + #[serde(skip_serializing_if = "Option::is_none")] + pub tag_key: Option>, + /// OPTIONAL. The companion value field for tag_key + #[serde(skip_serializing_if = "Option::is_none")] + pub tag_value: Option>, + /// Optional number of tasks to return in one page. Must be less than 2048. Defaults to 256. + #[serde(skip_serializing_if = "Option::is_none")] + pub page_size: Option, + /// OPTIONAL. Page token is used to retrieve the next page of results. If unspecified, returns the first page of results. The value can be found in the `next_page_token` field of the last returned result of ListTasks + #[serde(skip_serializing_if = "Option::is_none")] + pub page_token: Option, + /// OPTIONAL. Affects the fields included in the returned Task messages. `MINIMAL`: Task message will include ONLY the fields: - `tesTask.Id` - `tesTask.State` `BASIC`: Task message will include all fields EXCEPT: - `tesTask.ExecutorLog.stdout` - `tesTask.ExecutorLog.stderr` - `tesInput.content` - `tesTaskLog.system_logs` `FULL`: Task message includes all fields. + #[serde(skip_serializing_if = "Option::is_none")] + pub view: Option, +} From 0e29df7572cdcb3126e6b72942fd3a7119963646 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 16:53:42 +0530 Subject: [PATCH 74/92] added unit coverage --- README.md | 4 ++++ build-models.sh | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index f1521c6..6db902b 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,10 @@ or, you can run using cargo nextest using ``` cargo nextest run ``` +For checking the unit converage, you can run: +``` +cargo llvm-cov nextest +``` To test the CI/CD workflow locally, install `act` and run the following command: ``` diff --git a/build-models.sh b/build-models.sh index dc3c28b..f1c7385 100755 --- a/build-models.sh +++ b/build-models.sh @@ -24,7 +24,7 @@ generate_openapi_models() { # Remove the temporary directory at the end of the script trap 'rm -rf "$TEMP_OUTPUT_DIR"' EXIT - + # Run the OpenAPI generator CLI npx openapi-generator-cli generate -g rust \ -i "$OPENAPI_SPEC_PATH" \ From e02346cdaa47381d7dfb9adf7ebb7987b5f28cde Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:11:43 +0530 Subject: [PATCH 75/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ba5204d..a8a8b08 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -18,12 +18,12 @@ jobs: run: | apt-get update apt-get install -y curl git build-essential libssl-dev - if ! command -v rustup &> /dev/null # might not be installed while executing using `act` - then - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - . $HOME/.cargo/env - fi - rustup update stable + # if ! command -v rustup &> /dev/null # might not be installed while executing using `act` + # then + # curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + # . $HOME/.cargo/env + # fi + # rustup update stable - name: Install Node.js # required for build-models.sh run: | @@ -48,23 +48,23 @@ jobs: - uses: actions/checkout@v4 # checkout the repository - name: Build models run: | - . $HOME/.cargo/env + # . $HOME/.cargo/env bash ./build-models.sh - name: Build run: | - . $HOME/.cargo/env + # . $HOME/.cargo/env cargo build --verbose - name: Run tests run: | - . $HOME/.cargo/env + # . $HOME/.cargo/env bash ./run-tests.sh - name: Lint run: | - . $HOME/.cargo/env + # . $HOME/.cargo/env cargo clippy -- -D warnings - name: Format run: | - . $HOME/.cargo/env + # . $HOME/.cargo/env cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting cargo fmt -- ./lib/src/tes/models/*.rs cargo fmt -- --check \ No newline at end of file From dff1a21ff1ef0c5ba37bb5fbf263390f44e58f04 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:17:26 +0530 Subject: [PATCH 76/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a8a8b08..359b425 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,7 +23,7 @@ jobs: # curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y # . $HOME/.cargo/env # fi - # rustup update stable + rustup update stable - name: Install Node.js # required for build-models.sh run: | From bedf68f8cf3b6fcd769cf773bf3d58f5171ecb48 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:21:58 +0530 Subject: [PATCH 77/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 359b425..6582084 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,15 +14,14 @@ jobs: OPENSSL_INCLUDE_DIR: /usr/include/openssl steps: - - name: Install Rust + - name: Install dependencies run: | apt-get update apt-get install -y curl git build-essential libssl-dev - # if ! command -v rustup &> /dev/null # might not be installed while executing using `act` - # then - # curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - # . $HOME/.cargo/env - # fi + + - uses: actions/checkout@v4 # checkout the repository + - name: Install Rust + run: | rustup update stable - name: Install Node.js # required for build-models.sh From 4ee33024f65a64f960a3e10684899038e07f8085 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:24:51 +0530 Subject: [PATCH 78/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6582084..93a50aa 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -18,10 +18,10 @@ jobs: run: | apt-get update apt-get install -y curl git build-essential libssl-dev - - - uses: actions/checkout@v4 # checkout the repository + + - uses: actions/checkout@v2 # checkout the repository - name: Install Rust - run: | + run: | rustup update stable - name: Install Node.js # required for build-models.sh From b8ea6584813956970c4faa87bcaf7b47cb06f164 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:28:08 +0530 Subject: [PATCH 79/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 93a50aa..8645fba 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -19,10 +19,11 @@ jobs: apt-get update apt-get install -y curl git build-essential libssl-dev - - uses: actions/checkout@v2 # checkout the repository + - uses: actions/checkout@v4 # checkout the repository - name: Install Rust run: | - rustup update stable + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + echo 'source $HOME/.cargo/env' >> $GITHUB_ENV - name: Install Node.js # required for build-models.sh run: | From 2d24c434ca278aa3f28c80b037ee317131bd025c Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:29:09 +0530 Subject: [PATCH 80/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8645fba..1af4975 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,7 +23,8 @@ jobs: - name: Install Rust run: | curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - echo 'source $HOME/.cargo/env' >> $GITHUB_ENV + source $HOME/.cargo/env + rustup update stable - name: Install Node.js # required for build-models.sh run: | From f6ef2313e26e5da3d8d6a271ec86ee449a5ad93a Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:32:22 +0530 Subject: [PATCH 81/92] trying to remove installing rust in ci/cd --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1af4975..b768fd2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,8 +23,8 @@ jobs: - name: Install Rust run: | curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - source $HOME/.cargo/env - rustup update stable + echo "$HOME/.cargo/bin" >> $GITHUB_PATH + - name: Install Node.js # required for build-models.sh run: | From 5d9c4bf196a24ca274a58b84b41eccb243f12fba Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 8 Jul 2024 17:37:33 +0530 Subject: [PATCH 82/92] remove comments --- .github/workflows/ci.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b768fd2..40ed117 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -49,23 +49,18 @@ jobs: - uses: actions/checkout@v4 # checkout the repository - name: Build models run: | - # . $HOME/.cargo/env bash ./build-models.sh - name: Build run: | - # . $HOME/.cargo/env cargo build --verbose - name: Run tests run: | - # . $HOME/.cargo/env bash ./run-tests.sh - name: Lint run: | - # . $HOME/.cargo/env cargo clippy -- -D warnings - name: Format run: | - # . $HOME/.cargo/env cargo fmt -- ./lib/src/serviceinfo/models/*.rs # workaround to fix autogenerated code formatting cargo fmt -- ./lib/src/tes/models/*.rs cargo fmt -- --check \ No newline at end of file From 0d8d25cf32933cb8745130cd701d69a191a70d8c Mon Sep 17 00:00:00 2001 From: aaravm Date: Tue, 9 Jul 2024 10:41:08 +0530 Subject: [PATCH 83/92] changed openapi generator to Bash Launcher --- .gitignore | 3 --- build-models.sh | 19 ++++++++++--------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/.gitignore b/.gitignore index 8c999f8..04b8825 100644 --- a/.gitignore +++ b/.gitignore @@ -2,9 +2,6 @@ target/ debug/ Cargo.lock openapitools.json -package.json -package-lock.json -node_modules/ lib/src/**/models/ *.log funnel-work-dir/ diff --git a/build-models.sh b/build-models.sh index f1c7385..ec122d0 100755 --- a/build-models.sh +++ b/build-models.sh @@ -1,6 +1,13 @@ # Exit immediately if a command exits with a non-zero status. set -e +# Ensure the OpenAPI Generator JAR file is set up +mkdir -p ~/bin/openapitools +OPENAPI_GENERATOR_JAR=~/bin/openapitools/openapi-generator-cli.jar +if [ ! -f "$OPENAPI_GENERATOR_JAR" ]; then + curl -L https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/7.7.0/openapi-generator-cli-7.7.0.jar -o "$OPENAPI_GENERATOR_JAR" +fi + get_git_repo_name() { # Extract the URL of the remote "origin" url=$(git config --get remote.origin.url) @@ -25,8 +32,8 @@ generate_openapi_models() { # Remove the temporary directory at the end of the script trap 'rm -rf "$TEMP_OUTPUT_DIR"' EXIT - # Run the OpenAPI generator CLI - npx openapi-generator-cli generate -g rust \ + # Run the OpenAPI generator CLI using the JAR file + java -jar "$OPENAPI_GENERATOR_JAR" generate -g rust \ -i "$OPENAPI_SPEC_PATH" \ -o "$TEMP_OUTPUT_DIR" \ --additional-properties=useSingleRequestParameter=true @@ -61,16 +68,10 @@ generate_openapi_models() { echo "OpenAPI generation complete. Models copied to $DESTINATION_DIR" } -# Check if OpenAPI Generator CLI is installed -if ! npx openapi-generator-cli version > /dev/null 2>&1; then - # Install OpenAPI Generator CLI locally - npm install -g @openapitools/openapi-generator-cli -fi - generate_openapi_models \ "https://raw.githubusercontent.com/ga4gh-discovery/ga4gh-service-info/develop/service-info.yaml" \ "serviceinfo" "$SCRIPT_DIR/lib/src/serviceinfo/" generate_openapi_models \ "https://raw.githubusercontent.com/ga4gh/task-execution-schemas/develop/openapi/task_execution_service.openapi.yaml" \ - "tes" "$SCRIPT_DIR/lib/src/tes/" + "tes" "$SCRIPT_DIR/lib/src/tes/" \ No newline at end of file From 7fa6bd65b4d73a26ad0c729d7d44f671bd691b6b Mon Sep 17 00:00:00 2001 From: aaravm Date: Tue, 9 Jul 2024 13:25:25 +0530 Subject: [PATCH 84/92] remove nodejs --- .github/workflows/ci.yml | 6 ------ .github/workflows/local.yml | 27 +++++---------------------- 2 files changed, 5 insertions(+), 28 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 40ed117..177567f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -25,12 +25,6 @@ jobs: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y echo "$HOME/.cargo/bin" >> $GITHUB_PATH - - - name: Install Node.js # required for build-models.sh - run: | - curl -fsSL https://deb.nodesource.com/setup_22.x | bash - - apt-get install -y nodejs - - name: Set up JDK 11 # required for build-models.sh uses: actions/setup-java@v3 with: diff --git a/.github/workflows/local.yml b/.github/workflows/local.yml index 6d6775b..d0b039f 100644 --- a/.github/workflows/local.yml +++ b/.github/workflows/local.yml @@ -27,14 +27,7 @@ jobs: with: path: target key: ${{ runner.os }}-build-${{ hashFiles('**/Cargo.lock') }} - restore-keys: ${{ runner.os }}-build- - - - name: Cache Node.js dependencies - uses: actions/cache@v3 - with: - path: ~/.npm - key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }} - restore-keys: ${{ runner.os }}-node- + restore-keys: ${{ runner.os }}-build- - name: Cache Maven dependencies uses: actions/cache@v3 @@ -56,22 +49,12 @@ jobs: path: ~/funnel/build key: ${{ runner.os }}-funnel-${{ hashFiles('**/funnel/*') }} restore-keys: ${{ runner.os }}-funnel- - + + - uses: actions/checkout@v4 # checkout the repository - name: Install Rust - run: | - apt-get update - apt-get install -y curl git build-essential libssl-dev - if ! command -v rustup &> /dev/null # might not be installed while executing using `act` - then - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - . $HOME/.cargo/env - fi - rustup update stable - - - name: Install Node.js # required for build-models.sh run: | - curl -fsSL https://deb.nodesource.com/setup_22.x | bash - - apt-get install -y nodejs + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y + echo "$HOME/.cargo/bin" >> $GITHUB_PATH - name: Set up JDK 11 # required for build-models.sh uses: actions/setup-java@v3 From 00b636799b116f434baba390de06ed1b3823f7b8 Mon Sep 17 00:00:00 2001 From: aaravm Date: Tue, 9 Jul 2024 18:08:01 +0530 Subject: [PATCH 85/92] changed gitignore --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 04b8825..61675d2 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,6 @@ target/ debug/ Cargo.lock openapitools.json -lib/src/**/models/ *.log funnel-work-dir/ funnel/ From 6566d7d9abf454a13ac0dcfd0472629bf0af6591 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 11 Jul 2024 14:26:06 +0530 Subject: [PATCH 86/92] sorcery suggestions --- lib/src/serviceinfo/mod.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index dbf532f..cf9b27c 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -9,7 +9,7 @@ pub struct ServiceInfo { impl ServiceInfo { pub fn new(config: &Configuration) -> Result> { - let transport = &Transport::new(config); + let transport = Transport::new(config); let instance = ServiceInfo { transport: transport.clone(), }; @@ -22,12 +22,12 @@ impl ServiceInfo { Ok(response_body) => match serde_json::from_str::(&response_body) { Ok(service) => Ok(service), Err(e) => { - log::error!("Failed to deserialize response: {}", e); + log::error!("Failed to deserialize response: {}. Response body: {}", e, response_body); Err(e.into()) } }, Err(e) => { - log::error!("Error: {}", e); + log::error!("Error getting response: {}", e); Err(e) } } @@ -55,7 +55,7 @@ mod tests { println!("Service Info: {:?}", service); } Err(e) => { - println!("Failed to get service info: {}", e); + log::error!("ServiceInfo error in module 'mod.rs': {}", e); } } } From 9e9a4a72e15d76ecea4d8e23f2354410429e9353 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 11 Jul 2024 14:40:32 +0530 Subject: [PATCH 87/92] sorcery-ai suggestions --- lib/src/transport.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 36389b9..7c13d54 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -27,8 +27,8 @@ impl Transport { params: Option, ) -> Result> { let full_url = format!("{}{}", self.config.base_path, endpoint); - let url = reqwest::Url::parse(&full_url).map_err(|_| { - error!("Invalid endpoint (shouldn't contain base url): {}", endpoint); + let url = reqwest::Url::parse(&full_url).map_err(|e| { + error!("Invalid endpoint (shouldn't contain base url): {}. Error: {}", endpoint, e); Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid endpoint")) as Box })?; @@ -48,7 +48,11 @@ impl Transport { } if let Some(ref data) = data { - request_builder = request_builder.json(&data); + if serde_json::to_string(&data).is_ok() { + request_builder = request_builder.json(&data); + } else { + eprintln!("Parameters are invalid, and can't convert to JSON"); + } } let resp = request_builder.send().await.map_err(|e| { @@ -57,7 +61,9 @@ impl Transport { })?; let status = resp.status(); - let content = resp.text().await.map_err(|e| format!("Failed to read response text: {}", e))?; + let content = resp.text().await.map_err(|e| { + std::io::Error::new(std::io::ErrorKind::InvalidData, format!("Failed to read response text: {}", e)) + })?; if status.is_success() { Ok(content) From 81e26e6124dbba20214205a33e9c8566d2845ee8 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 11 Jul 2024 14:42:36 +0530 Subject: [PATCH 88/92] sorcery-ai suggestions --- lib/src/configuration.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs index c823b2c..01026b9 100644 --- a/lib/src/configuration.rs +++ b/lib/src/configuration.rs @@ -40,6 +40,9 @@ impl Configuration { } pub fn set_base_path(&mut self, base_path: &str) -> &mut Self { + if base_path.is_empty() { + panic!("Empty base path"); + } self.base_path = base_path.to_string(); self } From 816e47c25964284de9f9f91bb9e1afd1a5e75a06 Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 11 Jul 2024 14:58:13 +0530 Subject: [PATCH 89/92] sorcery ai suggestion --- lib/src/transport.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 7c13d54..98690e4 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -32,11 +32,12 @@ impl Transport { Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid endpoint")) as Box })?; - let mut request_builder = self.client.request(method, url).header( - reqwest::header::USER_AGENT, - self.config.user_agent.clone().unwrap_or_default(), - ); + let mut request_builder = self.client.request(method, url); + if let Some(ref user_agent) = self.config.user_agent { + request_builder = request_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + if let Some(ref params_value) = params { // Validate or log params_value before setting it as query parameters if params_value.is_object() { From a9ee3097d9fbe635fb8ef80eceff792c1b767cab Mon Sep 17 00:00:00 2001 From: aaravm Date: Thu, 11 Jul 2024 15:02:37 +0530 Subject: [PATCH 90/92] sorcery-ai suggestion --- README.md | 4 ++-- build-models.sh | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6db902b..ea044b1 100644 --- a/README.md +++ b/README.md @@ -21,11 +21,11 @@ Once you have installed Funnel, you can run the tests. This will automatically r ``` bash ./run-tests.sh ``` -or, you can run using cargo nextest using +or, you can run using: ``` cargo nextest run ``` -For checking the unit converage, you can run: +For checking the unit coverage, you can run: ``` cargo llvm-cov nextest ``` diff --git a/build-models.sh b/build-models.sh index ec122d0..58b9dbe 100755 --- a/build-models.sh +++ b/build-models.sh @@ -1,6 +1,8 @@ # Exit immediately if a command exits with a non-zero status. set -e +set -u + # Ensure the OpenAPI Generator JAR file is set up mkdir -p ~/bin/openapitools OPENAPI_GENERATOR_JAR=~/bin/openapitools/openapi-generator-cli.jar From a9b3c0b7ace5b0120102c7128b1394f7f4530f07 Mon Sep 17 00:00:00 2001 From: aaravm Date: Mon, 15 Jul 2024 15:22:35 +0530 Subject: [PATCH 91/92] separate cargo.toml --- Cargo.toml | 38 +++------- lib/Cargo.toml | 38 ++++++++++ lib/src/serviceinfo/models/mod.rs | 6 ++ lib/src/serviceinfo/models/service.rs | 70 +++++++++++++++++ .../models/service_organization.rs | 36 +++++++++ lib/src/serviceinfo/models/service_type.rs | 40 ++++++++++ lib/src/tes/models/mod.rs | 34 +++++++++ lib/src/tes/models/service.rs | 70 +++++++++++++++++ lib/src/tes/models/service_organization.rs | 36 +++++++++ lib/src/tes/models/service_type.rs | 40 ++++++++++ .../tes/models/tes_create_task_response.rs | 32 ++++++++ lib/src/tes/models/tes_executor.rs | 60 +++++++++++++++ lib/src/tes/models/tes_executor_log.rs | 48 ++++++++++++ lib/src/tes/models/tes_file_type.rs | 41 ++++++++++ lib/src/tes/models/tes_input.rs | 53 +++++++++++++ lib/src/tes/models/tes_list_tasks_response.rs | 36 +++++++++ lib/src/tes/models/tes_output.rs | 51 +++++++++++++ lib/src/tes/models/tes_output_file_log.rs | 40 ++++++++++ lib/src/tes/models/tes_resources.rs | 56 ++++++++++++++ lib/src/tes/models/tes_service_info.rs | 76 +++++++++++++++++++ lib/src/tes/models/tes_service_type.rs | 49 ++++++++++++ lib/src/tes/models/tes_state.rs | 68 +++++++++++++++++ lib/src/tes/models/tes_task.rs | 74 ++++++++++++++++++ lib/src/tes/models/tes_task_log.rs | 52 +++++++++++++ 24 files changed, 1115 insertions(+), 29 deletions(-) create mode 100644 lib/Cargo.toml create mode 100644 lib/src/serviceinfo/models/mod.rs create mode 100644 lib/src/serviceinfo/models/service.rs create mode 100644 lib/src/serviceinfo/models/service_organization.rs create mode 100644 lib/src/serviceinfo/models/service_type.rs create mode 100644 lib/src/tes/models/mod.rs create mode 100644 lib/src/tes/models/service.rs create mode 100644 lib/src/tes/models/service_organization.rs create mode 100644 lib/src/tes/models/service_type.rs create mode 100644 lib/src/tes/models/tes_create_task_response.rs create mode 100644 lib/src/tes/models/tes_executor.rs create mode 100644 lib/src/tes/models/tes_executor_log.rs create mode 100644 lib/src/tes/models/tes_file_type.rs create mode 100644 lib/src/tes/models/tes_input.rs create mode 100644 lib/src/tes/models/tes_list_tasks_response.rs create mode 100644 lib/src/tes/models/tes_output.rs create mode 100644 lib/src/tes/models/tes_output_file_log.rs create mode 100644 lib/src/tes/models/tes_resources.rs create mode 100644 lib/src/tes/models/tes_service_info.rs create mode 100644 lib/src/tes/models/tes_service_type.rs create mode 100644 lib/src/tes/models/tes_state.rs create mode 100644 lib/src/tes/models/tes_task.rs create mode 100644 lib/src/tes/models/tes_task_log.rs diff --git a/Cargo.toml b/Cargo.toml index e1ed8f7..a45a957 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,32 +1,12 @@ -[package] -name = "ga4gh-sdk" +[workspace] +members = [ + "lib" +] + +[workspace.package] version = "0.1.0" -authors = ["Aarav Mehta ", "Pavel Nikonorov", "ELIXIR Cloud & AAI "] +authors = ["Aarav Mehta (Google Summer of Code Participant)", "Pavel Nikonorov (Google Summer of Code Mentor; GENXT)", "ELIXIR Cloud & AAI (ELIXIR Europe)"] edition = "2021" -description = "Generic SDK and CLI for GA4GH API services" -license = "Apache-2.0" +readme = "./README.md" +license-file = "LICENSE.txt" repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk.git" - -[dependencies] -tokio = { version = "1", features = ["full"] } -serde = "^1.0" -serde_derive = "^1.0" -serde_json = "^1.0" -url = "^2.2" -uuid = { version = "^1.0", features = ["serde", "v4"] } -log = "0.4" -env_logger = "0.9" -once_cell = "1.8.0" - -[dependencies.reqwest] -version = "^0.11" -features = ["json", "multipart"] - -[dev-dependencies] -mockito = "0.31" -mockall = "0.10.2" -cargo-nextest = "0.9.30" - -[lib] -name = "ga4gh_sdk" -path = "lib/src/lib.rs" \ No newline at end of file diff --git a/lib/Cargo.toml b/lib/Cargo.toml new file mode 100644 index 0000000..8266b6d --- /dev/null +++ b/lib/Cargo.toml @@ -0,0 +1,38 @@ + +[package] +name = "ga4gh-lib" +description = """ +Generic SDK and CLI for GA4GH API services +""" +repository = "https://github.com/elixir-cloud-aai/ga4gh-sdk/tree/main/lib" +version.workspace = true +authors.workspace = true +edition.workspace = true +readme.workspace = true +license-file.workspace = true +# rust-version = "1.74" + +[dependencies] +tokio = { version = "1", features = ["full"] } +serde = "^1.0" +serde_derive = "^1.0" +serde_json = "^1.0" +url = "^2.2" +uuid = { version = "^1.0", features = ["serde", "v4"] } +log = "0.4" +env_logger = "0.9" +once_cell = "1.8.0" + +[dependencies.reqwest] +version = "^0.11" +features = ["json", "multipart"] + +[dev-dependencies] +mockito = "0.31" +mockall = "0.10.2" +cargo-nextest = "0.9.30" + +[lib] +name = "ga4gh_sdk" +path = "src/lib.rs" + diff --git a/lib/src/serviceinfo/models/mod.rs b/lib/src/serviceinfo/models/mod.rs new file mode 100644 index 0000000..9aa6373 --- /dev/null +++ b/lib/src/serviceinfo/models/mod.rs @@ -0,0 +1,6 @@ +pub mod service; +pub use self::service::Service; +pub mod service_organization; +pub use self::service_organization::ServiceOrganization; +pub mod service_type; +pub use self::service_type::ServiceType; diff --git a/lib/src/serviceinfo/models/service.rs b/lib/src/serviceinfo/models/service.rs new file mode 100644 index 0000000..ea8816c --- /dev/null +++ b/lib/src/serviceinfo/models/service.rs @@ -0,0 +1,70 @@ +/* + * GA4GH service-info API specification + * + * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). + * + * The version of the OpenAPI document: 1.0.0 + * Contact: ga4gh-discovery-networks@ga4gh.org + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::serviceinfo::models; +use serde::{Deserialize, Serialize}; + +/// Service : GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Service { + /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. + #[serde(rename = "id")] + pub id: String, + /// Name of this service. Should be human readable. + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "type")] + pub r#type: Box, + /// Description of the service. Should be human readable and provide information about the service. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "organization")] + pub organization: Box, + /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). + #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] + pub contact_url: Option, + /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. + #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] + pub documentation_url: Option, + /// Timestamp describing when the service was first deployed and available (RFC 3339 format) + #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] + pub created_at: Option, + /// Timestamp describing when the service was last updated (RFC 3339 format) + #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] + pub updated_at: Option, + /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option, + /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. + #[serde(rename = "version")] + pub version: String, +} + +impl Service { + /// GA4GH service + pub fn new(id: String, name: String, r#type: models::ServiceType, organization: models::ServiceOrganization, version: String) -> Service { + Service { + id, + name, + r#type: Box::new(r#type), + description: None, + organization: Box::new(organization), + contact_url: None, + documentation_url: None, + created_at: None, + updated_at: None, + environment: None, + version, + } + } +} + diff --git a/lib/src/serviceinfo/models/service_organization.rs b/lib/src/serviceinfo/models/service_organization.rs new file mode 100644 index 0000000..c57a536 --- /dev/null +++ b/lib/src/serviceinfo/models/service_organization.rs @@ -0,0 +1,36 @@ +/* + * GA4GH service-info API specification + * + * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). + * + * The version of the OpenAPI document: 1.0.0 + * Contact: ga4gh-discovery-networks@ga4gh.org + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::serviceinfo::models; +use serde::{Deserialize, Serialize}; + +/// ServiceOrganization : Organization providing the service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceOrganization { + /// Name of the organization responsible for the service + #[serde(rename = "name")] + pub name: String, + /// URL of the website of the organization (RFC 3986 format) + #[serde(rename = "url")] + pub url: String, +} + +impl ServiceOrganization { + /// Organization providing the service + pub fn new(name: String, url: String) -> ServiceOrganization { + ServiceOrganization { + name, + url, + } + } +} + diff --git a/lib/src/serviceinfo/models/service_type.rs b/lib/src/serviceinfo/models/service_type.rs new file mode 100644 index 0000000..028fe98 --- /dev/null +++ b/lib/src/serviceinfo/models/service_type.rs @@ -0,0 +1,40 @@ +/* + * GA4GH service-info API specification + * + * A way for a service to describe basic metadata concerning a service alongside a set of capabilities and/or limitations of the service. More information on [GitHub](https://github.com/ga4gh-discovery/ga4gh-service-info/). + * + * The version of the OpenAPI document: 1.0.0 + * Contact: ga4gh-discovery-networks@ga4gh.org + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::serviceinfo::models; +use serde::{Deserialize, Serialize}; + +/// ServiceType : Type of a GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceType { + /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). + #[serde(rename = "group")] + pub group: String, + /// Name of the API or GA4GH specification implemented. Official GA4GH types should be assigned as part of standards approval process. Custom artifacts are supported. + #[serde(rename = "artifact")] + pub artifact: String, + /// Version of the API or specification. GA4GH specifications use semantic versioning. + #[serde(rename = "version")] + pub version: String, +} + +impl ServiceType { + /// Type of a GA4GH service + pub fn new(group: String, artifact: String, version: String) -> ServiceType { + ServiceType { + group, + artifact, + version, + } + } +} + diff --git a/lib/src/tes/models/mod.rs b/lib/src/tes/models/mod.rs new file mode 100644 index 0000000..232b43a --- /dev/null +++ b/lib/src/tes/models/mod.rs @@ -0,0 +1,34 @@ +pub mod service; +pub use self::service::Service; +pub mod service_organization; +pub use self::service_organization::ServiceOrganization; +pub mod service_type; +pub use self::service_type::ServiceType; +pub mod tes_create_task_response; +pub use self::tes_create_task_response::TesCreateTaskResponse; +pub mod tes_executor; +pub use self::tes_executor::TesExecutor; +pub mod tes_executor_log; +pub use self::tes_executor_log::TesExecutorLog; +pub mod tes_file_type; +pub use self::tes_file_type::TesFileType; +pub mod tes_input; +pub use self::tes_input::TesInput; +pub mod tes_list_tasks_response; +pub use self::tes_list_tasks_response::TesListTasksResponse; +pub mod tes_output; +pub use self::tes_output::TesOutput; +pub mod tes_output_file_log; +pub use self::tes_output_file_log::TesOutputFileLog; +pub mod tes_resources; +pub use self::tes_resources::TesResources; +pub mod tes_service_info; +pub use self::tes_service_info::TesServiceInfo; +pub mod tes_service_type; +pub use self::tes_service_type::TesServiceType; +pub mod tes_state; +pub use self::tes_state::TesState; +pub mod tes_task; +pub use self::tes_task::TesTask; +pub mod tes_task_log; +pub use self::tes_task_log::TesTaskLog; diff --git a/lib/src/tes/models/service.rs b/lib/src/tes/models/service.rs new file mode 100644 index 0000000..3c1c6cc --- /dev/null +++ b/lib/src/tes/models/service.rs @@ -0,0 +1,70 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// Service : GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Service { + /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. + #[serde(rename = "id")] + pub id: String, + /// Name of this service. Should be human readable. + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "type")] + pub r#type: Box, + /// Description of the service. Should be human readable and provide information about the service. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "organization")] + pub organization: Box, + /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). + #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] + pub contact_url: Option, + /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. + #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] + pub documentation_url: Option, + /// Timestamp describing when the service was first deployed and available (RFC 3339 format) + #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] + pub created_at: Option, + /// Timestamp describing when the service was last updated (RFC 3339 format) + #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] + pub updated_at: Option, + /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option, + /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. + #[serde(rename = "version")] + pub version: String, +} + +impl Service { + /// GA4GH service + pub fn new(id: String, name: String, r#type: models::ServiceType, organization: models::ServiceOrganization, version: String) -> Service { + Service { + id, + name, + r#type: Box::new(r#type), + description: None, + organization: Box::new(organization), + contact_url: None, + documentation_url: None, + created_at: None, + updated_at: None, + environment: None, + version, + } + } +} + diff --git a/lib/src/tes/models/service_organization.rs b/lib/src/tes/models/service_organization.rs new file mode 100644 index 0000000..796617c --- /dev/null +++ b/lib/src/tes/models/service_organization.rs @@ -0,0 +1,36 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// ServiceOrganization : Organization providing the service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceOrganization { + /// Name of the organization responsible for the service + #[serde(rename = "name")] + pub name: String, + /// URL of the website of the organization (RFC 3986 format) + #[serde(rename = "url")] + pub url: String, +} + +impl ServiceOrganization { + /// Organization providing the service + pub fn new(name: String, url: String) -> ServiceOrganization { + ServiceOrganization { + name, + url, + } + } +} + diff --git a/lib/src/tes/models/service_type.rs b/lib/src/tes/models/service_type.rs new file mode 100644 index 0000000..100cd7f --- /dev/null +++ b/lib/src/tes/models/service_type.rs @@ -0,0 +1,40 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// ServiceType : Type of a GA4GH service +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServiceType { + /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). + #[serde(rename = "group")] + pub group: String, + /// Name of the API or GA4GH specification implemented. Official GA4GH types should be assigned as part of standards approval process. Custom artifacts are supported. + #[serde(rename = "artifact")] + pub artifact: String, + /// Version of the API or specification. GA4GH specifications use semantic versioning. + #[serde(rename = "version")] + pub version: String, +} + +impl ServiceType { + /// Type of a GA4GH service + pub fn new(group: String, artifact: String, version: String) -> ServiceType { + ServiceType { + group, + artifact, + version, + } + } +} + diff --git a/lib/src/tes/models/tes_create_task_response.rs b/lib/src/tes/models/tes_create_task_response.rs new file mode 100644 index 0000000..c1ed614 --- /dev/null +++ b/lib/src/tes/models/tes_create_task_response.rs @@ -0,0 +1,32 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesCreateTaskResponse : CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesCreateTaskResponse { + /// Task identifier assigned by the server. + #[serde(rename = "id")] + pub id: String, +} + +impl TesCreateTaskResponse { + /// CreateTaskResponse describes a response from the CreateTask endpoint. It will include the task ID that can be used to look up the status of the job. + pub fn new(id: String) -> TesCreateTaskResponse { + TesCreateTaskResponse { + id, + } + } +} + diff --git a/lib/src/tes/models/tes_executor.rs b/lib/src/tes/models/tes_executor.rs new file mode 100644 index 0000000..498c6e7 --- /dev/null +++ b/lib/src/tes/models/tes_executor.rs @@ -0,0 +1,60 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesExecutor : Executor describes a command to be executed, and its environment. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesExecutor { + /// Name of the container image. The string will be passed as the image argument to the containerization run command. Examples: - `ubuntu` - `quay.io/aptible/ubuntu` - `gcr.io/my-org/my-image` - `myregistryhost:5000/fedora/httpd:version1.0` + #[serde(rename = "image")] + pub image: String, + /// A sequence of program arguments to execute, where the first argument is the program to execute (i.e. argv). Example: ``` { \"command\" : [\"/bin/md5\", \"/data/file1\"] } ``` + #[serde(rename = "command")] + pub command: Vec, + /// The working directory that the command will be executed in. If not defined, the system will default to the directory set by the container image. + #[serde(rename = "workdir", skip_serializing_if = "Option::is_none")] + pub workdir: Option, + /// Path inside the container to a file which will be piped to the executor's stdin. This must be an absolute path. This mechanism could be used in conjunction with the input declaration to process a data file using a tool that expects STDIN. For example, to get the MD5 sum of a file by reading it into the STDIN ``` { \"command\" : [\"/bin/md5\"], \"stdin\" : \"/data/file1\" } ``` + #[serde(rename = "stdin", skip_serializing_if = "Option::is_none")] + pub stdin: Option, + /// Path inside the container to a file where the executor's stdout will be written to. Must be an absolute path. Example: ``` { \"stdout\" : \"/tmp/stdout.log\" } ``` + #[serde(rename = "stdout", skip_serializing_if = "Option::is_none")] + pub stdout: Option, + /// Path inside the container to a file where the executor's stderr will be written to. Must be an absolute path. Example: ``` { \"stderr\" : \"/tmp/stderr.log\" } ``` + #[serde(rename = "stderr", skip_serializing_if = "Option::is_none")] + pub stderr: Option, + /// Enviromental variables to set within the container. Example: ``` { \"env\" : { \"ENV_CONFIG_PATH\" : \"/data/config.file\", \"BLASTDB\" : \"/data/GRC38\", \"HMMERDB\" : \"/data/hmmer\" } } ``` + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + /// Default behavior of running an array of executors is that execution stops on the first error. If `ignore_error` is `True`, then the runner will record error exit codes, but will continue on to the next tesExecutor. + #[serde(rename = "ignore_error", skip_serializing_if = "Option::is_none")] + pub ignore_error: Option, +} + +impl TesExecutor { + /// Executor describes a command to be executed, and its environment. + pub fn new(image: String, command: Vec) -> TesExecutor { + TesExecutor { + image, + command, + workdir: None, + stdin: None, + stdout: None, + stderr: None, + env: None, + ignore_error: None, + } + } +} + diff --git a/lib/src/tes/models/tes_executor_log.rs b/lib/src/tes/models/tes_executor_log.rs new file mode 100644 index 0000000..69c8bcb --- /dev/null +++ b/lib/src/tes/models/tes_executor_log.rs @@ -0,0 +1,48 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesExecutorLog : ExecutorLog describes logging information related to an Executor. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesExecutorLog { + /// Time the executor started, in RFC 3339 format. + #[serde(rename = "start_time", skip_serializing_if = "Option::is_none")] + pub start_time: Option, + /// Time the executor ended, in RFC 3339 format. + #[serde(rename = "end_time", skip_serializing_if = "Option::is_none")] + pub end_time: Option, + /// Stdout content. This is meant for convenience. No guarantees are made about the content. Implementations may chose different approaches: only the head, only the tail, a URL reference only, etc. In order to capture the full stdout client should set Executor.stdout to a container file path, and use Task.outputs to upload that file to permanent storage. + #[serde(rename = "stdout", skip_serializing_if = "Option::is_none")] + pub stdout: Option, + /// Stderr content. This is meant for convenience. No guarantees are made about the content. Implementations may chose different approaches: only the head, only the tail, a URL reference only, etc. In order to capture the full stderr client should set Executor.stderr to a container file path, and use Task.outputs to upload that file to permanent storage. + #[serde(rename = "stderr", skip_serializing_if = "Option::is_none")] + pub stderr: Option, + /// Exit code. + #[serde(rename = "exit_code")] + pub exit_code: i32, +} + +impl TesExecutorLog { + /// ExecutorLog describes logging information related to an Executor. + pub fn new(exit_code: i32) -> TesExecutorLog { + TesExecutorLog { + start_time: None, + end_time: None, + stdout: None, + stderr: None, + exit_code, + } + } +} + diff --git a/lib/src/tes/models/tes_file_type.rs b/lib/src/tes/models/tes_file_type.rs new file mode 100644 index 0000000..87c2d58 --- /dev/null +++ b/lib/src/tes/models/tes_file_type.rs @@ -0,0 +1,41 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesFileType : Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. +/// Define if input/output element is a file or a directory. It is not required that the user provide this value, but it is required that the server fill in the value once the information is avalible at run time. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum TesFileType { + #[serde(rename = "FILE")] + File, + #[serde(rename = "DIRECTORY")] + Directory, + +} + +impl std::fmt::Display for TesFileType { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::File => write!(f, "FILE"), + Self::Directory => write!(f, "DIRECTORY"), + } + } +} + +impl Default for TesFileType { + fn default() -> TesFileType { + Self::File + } +} + diff --git a/lib/src/tes/models/tes_input.rs b/lib/src/tes/models/tes_input.rs new file mode 100644 index 0000000..6cd8488 --- /dev/null +++ b/lib/src/tes/models/tes_input.rs @@ -0,0 +1,53 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesInput : Input describes Task input files. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesInput { + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + /// REQUIRED, unless \"content\" is set. URL in long term storage, for example: - s3://my-object-store/file1 - gs://my-bucket/file2 - file:///path/to/my/file - /path/to/my/file + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, + /// Path of the file inside the container. Must be an absolute path. + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "type", skip_serializing_if = "Option::is_none")] + pub r#type: Option, + /// File content literal. Implementations should support a minimum of 128 KiB in this field and may define their own maximum. UTF-8 encoded If content is not empty, \"url\" must be ignored. + #[serde(rename = "content", skip_serializing_if = "Option::is_none")] + pub content: Option, + /// Indicate that a file resource could be accessed using a streaming interface, ie a FUSE mounted s3 object. This flag indicates that using a streaming mount, as opposed to downloading the whole file to the local scratch space, may be faster despite the latency and overhead. This does not mean that the backend will use a streaming interface, as it may not be provided by the vendor, but if the capacity is avalible it can be used without degrading the performance of the underlying program. + #[serde(rename = "streamable", skip_serializing_if = "Option::is_none")] + pub streamable: Option, +} + +impl TesInput { + /// Input describes Task input files. + pub fn new(path: String) -> TesInput { + TesInput { + name: None, + description: None, + url: None, + path, + r#type: None, + content: None, + streamable: None, + } + } +} + diff --git a/lib/src/tes/models/tes_list_tasks_response.rs b/lib/src/tes/models/tes_list_tasks_response.rs new file mode 100644 index 0000000..158be6a --- /dev/null +++ b/lib/src/tes/models/tes_list_tasks_response.rs @@ -0,0 +1,36 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesListTasksResponse : ListTasksResponse describes a response from the ListTasks endpoint. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesListTasksResponse { + /// List of tasks. These tasks will be based on the original submitted task document, but with other fields, such as the job state and logging info, added/changed as the job progresses. + #[serde(rename = "tasks")] + pub tasks: Vec, + /// Token used to return the next page of results. This value can be used in the `page_token` field of the next ListTasks request. + #[serde(rename = "next_page_token", skip_serializing_if = "Option::is_none")] + pub next_page_token: Option, +} + +impl TesListTasksResponse { + /// ListTasksResponse describes a response from the ListTasks endpoint. + pub fn new(tasks: Vec) -> TesListTasksResponse { + TesListTasksResponse { + tasks, + next_page_token: None, + } + } +} + diff --git a/lib/src/tes/models/tes_output.rs b/lib/src/tes/models/tes_output.rs new file mode 100644 index 0000000..9835f72 --- /dev/null +++ b/lib/src/tes/models/tes_output.rs @@ -0,0 +1,51 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesOutput : Output describes Task output files. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesOutput { + /// User-provided name of output file + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + /// Optional users provided description field, can be used for documentation. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + /// URL at which the TES server makes the output accessible after the task is complete. When tesOutput.path contains wildcards, it must be a directory; see `tesOutput.path_prefix` for details on how output URLs are constructed in this case. For Example: - `s3://my-object-store/file1` - `gs://my-bucket/file2` - `file:///path/to/my/file` + #[serde(rename = "url")] + pub url: String, + /// Absolute path of the file inside the container. May contain pattern matching wildcards to select multiple outputs at once, but mind implications for `tesOutput.url` and `tesOutput.path_prefix`. Only wildcards defined in IEEE Std 1003.1-2017 (POSIX), 12.3 are supported; see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13 + #[serde(rename = "path")] + pub path: String, + /// Prefix to be removed from matching outputs if `tesOutput.path` contains wildcards; output URLs are constructed by appending pruned paths to the directory specfied in `tesOutput.url`. Required if `tesOutput.path` contains wildcards, ignored otherwise. + #[serde(rename = "path_prefix", skip_serializing_if = "Option::is_none")] + pub path_prefix: Option, + #[serde(rename = "type", skip_serializing_if = "Option::is_none")] + pub r#type: Option, +} + +impl TesOutput { + /// Output describes Task output files. + pub fn new(url: String, path: String) -> TesOutput { + TesOutput { + name: None, + description: None, + url, + path, + path_prefix: None, + r#type: None, + } + } +} + diff --git a/lib/src/tes/models/tes_output_file_log.rs b/lib/src/tes/models/tes_output_file_log.rs new file mode 100644 index 0000000..e31ac58 --- /dev/null +++ b/lib/src/tes/models/tes_output_file_log.rs @@ -0,0 +1,40 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesOutputFileLog : OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesOutputFileLog { + /// URL of the file in storage, e.g. s3://bucket/file.txt + #[serde(rename = "url")] + pub url: String, + /// Path of the file inside the container. Must be an absolute path. + #[serde(rename = "path")] + pub path: String, + /// Size of the file in bytes. Note, this is currently coded as a string because official JSON doesn't support int64 numbers. + #[serde(rename = "size_bytes")] + pub size_bytes: String, +} + +impl TesOutputFileLog { + /// OutputFileLog describes a single output file. This describes file details after the task has completed successfully, for logging purposes. + pub fn new(url: String, path: String, size_bytes: String) -> TesOutputFileLog { + TesOutputFileLog { + url, + path, + size_bytes, + } + } +} + diff --git a/lib/src/tes/models/tes_resources.rs b/lib/src/tes/models/tes_resources.rs new file mode 100644 index 0000000..0ab22ce --- /dev/null +++ b/lib/src/tes/models/tes_resources.rs @@ -0,0 +1,56 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesResources : Resources describes the resources requested by a task. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesResources { + /// Requested number of CPUs + #[serde(rename = "cpu_cores", skip_serializing_if = "Option::is_none")] + pub cpu_cores: Option, + /// Define if the task is allowed to run on preemptible compute instances, for example, AWS Spot. This option may have no effect when utilized on some backends that don't have the concept of preemptible jobs. + #[serde(rename = "preemptible", skip_serializing_if = "Option::is_none")] + pub preemptible: Option, + /// Requested RAM required in gigabytes (GB) + #[serde(rename = "ram_gb", skip_serializing_if = "Option::is_none")] + pub ram_gb: Option, + /// Requested disk size in gigabytes (GB) + #[serde(rename = "disk_gb", skip_serializing_if = "Option::is_none")] + pub disk_gb: Option, + /// Request that the task be run in these compute zones. How this string is utilized will be dependent on the backend system. For example, a system based on a cluster queueing system may use this string to define priorty queue to which the job is assigned. + #[serde(rename = "zones", skip_serializing_if = "Option::is_none")] + pub zones: Option>, + /// Key/value pairs for backend configuration. ServiceInfo shall return a list of keys that a backend supports. Keys are case insensitive. It is expected that clients pass all runtime or hardware requirement key/values that are not mapped to existing tesResources properties to backend_parameters. Backends shall log system warnings if a key is passed that is unsupported. Backends shall not store or return unsupported keys if included in a task. If backend_parameters_strict equals true, backends should fail the task if any key/values are unsupported, otherwise, backends should attempt to run the task Intended uses include VM size selection, coprocessor configuration, etc. Example: ``` { \"backend_parameters\" : { \"VmSize\" : \"Standard_D64_v3\" } } ``` + #[serde(rename = "backend_parameters", skip_serializing_if = "Option::is_none")] + pub backend_parameters: Option>, + /// If set to true, backends should fail the task if any backend_parameters key/values are unsupported, otherwise, backends should attempt to run the task + #[serde(rename = "backend_parameters_strict", skip_serializing_if = "Option::is_none")] + pub backend_parameters_strict: Option, +} + +impl TesResources { + /// Resources describes the resources requested by a task. + pub fn new() -> TesResources { + TesResources { + cpu_cores: None, + preemptible: None, + ram_gb: None, + disk_gb: None, + zones: None, + backend_parameters: None, + backend_parameters_strict: None, + } + } +} + diff --git a/lib/src/tes/models/tes_service_info.rs b/lib/src/tes/models/tes_service_info.rs new file mode 100644 index 0000000..13157f1 --- /dev/null +++ b/lib/src/tes/models/tes_service_info.rs @@ -0,0 +1,76 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesServiceInfo { + /// Unique ID of this service. Reverse domain name notation is recommended, though not required. The identifier should attempt to be globally unique so it can be used in downstream aggregator services e.g. Service Registry. + #[serde(rename = "id")] + pub id: String, + /// Name of this service. Should be human readable. + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "type")] + pub r#type: Box, + /// Description of the service. Should be human readable and provide information about the service. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "organization")] + pub organization: Box, + /// URL of the contact for the provider of this service, e.g. a link to a contact form (RFC 3986 format), or an email (RFC 2368 format). + #[serde(rename = "contactUrl", skip_serializing_if = "Option::is_none")] + pub contact_url: Option, + /// URL of the documentation of this service (RFC 3986 format). This should help someone learn how to use your service, including any specifics required to access data, e.g. authentication. + #[serde(rename = "documentationUrl", skip_serializing_if = "Option::is_none")] + pub documentation_url: Option, + /// Timestamp describing when the service was first deployed and available (RFC 3339 format) + #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")] + pub created_at: Option, + /// Timestamp describing when the service was last updated (RFC 3339 format) + #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")] + pub updated_at: Option, + /// Environment the service is running in. Use this to distinguish between production, development and testing/staging deployments. Suggested values are prod, test, dev, staging. However this is advised and not enforced. + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option, + /// Version of the service being described. Semantic versioning is recommended, but other identifiers, such as dates or commit hashes, are also allowed. The version should be changed whenever the service is updated. + #[serde(rename = "version")] + pub version: String, + /// Lists some, but not necessarily all, storage locations supported by the service. + #[serde(rename = "storage", skip_serializing_if = "Option::is_none")] + pub storage: Option>, + /// Lists all tesResources.backend_parameters keys supported by the service + #[serde(rename = "tesResources_backend_parameters", skip_serializing_if = "Option::is_none")] + pub tes_resources_backend_parameters: Option>, +} + +impl TesServiceInfo { + pub fn new(id: String, name: String, r#type: models::TesServiceType, organization: models::ServiceOrganization, version: String) -> TesServiceInfo { + TesServiceInfo { + id, + name, + r#type: Box::new(r#type), + description: None, + organization: Box::new(organization), + contact_url: None, + documentation_url: None, + created_at: None, + updated_at: None, + environment: None, + version, + storage: None, + tes_resources_backend_parameters: None, + } + } +} + diff --git a/lib/src/tes/models/tes_service_type.rs b/lib/src/tes/models/tes_service_type.rs new file mode 100644 index 0000000..1c746bc --- /dev/null +++ b/lib/src/tes/models/tes_service_type.rs @@ -0,0 +1,49 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesServiceType { + /// Namespace in reverse domain name format. Use `org.ga4gh` for implementations compliant with official GA4GH specifications. For services with custom APIs not standardized by GA4GH, or implementations diverging from official GA4GH specifications, use a different namespace (e.g. your organization's reverse domain name). + #[serde(rename = "group")] + pub group: String, + #[serde(rename = "artifact")] + pub artifact: Artifact, + /// Version of the API or specification. GA4GH specifications use semantic versioning. + #[serde(rename = "version")] + pub version: String, +} + +impl TesServiceType { + pub fn new(group: String, artifact: Artifact, version: String) -> TesServiceType { + TesServiceType { + group, + artifact, + version, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Artifact { + #[serde(rename = "tes")] + Tes, +} + +impl Default for Artifact { + fn default() -> Artifact { + Self::Tes + } +} + diff --git a/lib/src/tes/models/tes_state.rs b/lib/src/tes/models/tes_state.rs new file mode 100644 index 0000000..83d9ee7 --- /dev/null +++ b/lib/src/tes/models/tes_state.rs @@ -0,0 +1,68 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesState : Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. +/// Task state as defined by the server. - `UNKNOWN`: The state of the task is unknown. The cause for this status message may be dependent on the underlying system. The `UNKNOWN` states provides a safe default for messages where this field is missing so that a missing field does not accidentally imply that the state is QUEUED. - `QUEUED`: The task is queued and awaiting resources to begin computing. - `INITIALIZING`: The task has been assigned to a worker and is currently preparing to run. For example, the worker may be turning on, downloading input files, etc. - `RUNNING`: The task is running. Input files are downloaded and the first Executor has been started. - `PAUSED`: The task is paused. The reasons for this would be tied to the specific system running the job. An implementation may have the ability to pause a task, but this is not required. - `COMPLETE`: The task has completed running. Executors have exited without error and output files have been successfully uploaded. - `EXECUTOR_ERROR`: The task encountered an error in one of the Executor processes. Generally, this means that an Executor exited with a non-zero exit code. - `SYSTEM_ERROR`: The task was stopped due to a system error, but not from an Executor, for example an upload failed due to network issues, the worker's ran out of disk space, etc. - `CANCELED`: The task was canceled by the user, and downstream resources have been deleted. - `CANCELING`: The task was canceled by the user, but the downstream resources are still awaiting deletion. - `PREEMPTED`: The task is stopped (preempted) by the system. The reasons for this would be tied to the specific system running the job. Generally, this means that the system reclaimed the compute capacity for reallocation. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum TesState { + #[serde(rename = "UNKNOWN")] + Unknown, + #[serde(rename = "QUEUED")] + Queued, + #[serde(rename = "INITIALIZING")] + Initializing, + #[serde(rename = "RUNNING")] + Running, + #[serde(rename = "PAUSED")] + Paused, + #[serde(rename = "COMPLETE")] + Complete, + #[serde(rename = "EXECUTOR_ERROR")] + ExecutorError, + #[serde(rename = "SYSTEM_ERROR")] + SystemError, + #[serde(rename = "CANCELED")] + Canceled, + #[serde(rename = "PREEMPTED")] + Preempted, + #[serde(rename = "CANCELING")] + Canceling, + +} + +impl std::fmt::Display for TesState { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Unknown => write!(f, "UNKNOWN"), + Self::Queued => write!(f, "QUEUED"), + Self::Initializing => write!(f, "INITIALIZING"), + Self::Running => write!(f, "RUNNING"), + Self::Paused => write!(f, "PAUSED"), + Self::Complete => write!(f, "COMPLETE"), + Self::ExecutorError => write!(f, "EXECUTOR_ERROR"), + Self::SystemError => write!(f, "SYSTEM_ERROR"), + Self::Canceled => write!(f, "CANCELED"), + Self::Preempted => write!(f, "PREEMPTED"), + Self::Canceling => write!(f, "CANCELING"), + } + } +} + +impl Default for TesState { + fn default() -> TesState { + Self::Unknown + } +} + diff --git a/lib/src/tes/models/tes_task.rs b/lib/src/tes/models/tes_task.rs new file mode 100644 index 0000000..c5251be --- /dev/null +++ b/lib/src/tes/models/tes_task.rs @@ -0,0 +1,74 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesTask : Task describes an instance of a task. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesTask { + /// Task identifier assigned by the server. + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "state", skip_serializing_if = "Option::is_none")] + pub state: Option, + /// User-provided task name. + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + /// Optional user-provided description of task for documentation purposes. + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + /// Input files that will be used by the task. Inputs will be downloaded and mounted into the executor container as defined by the task request document. + #[serde(rename = "inputs", skip_serializing_if = "Option::is_none")] + pub inputs: Option>, + /// Output files. Outputs will be uploaded from the executor container to long-term storage. + #[serde(rename = "outputs", skip_serializing_if = "Option::is_none")] + pub outputs: Option>, + #[serde(rename = "resources", skip_serializing_if = "Option::is_none")] + pub resources: Option>, + /// An array of executors to be run. Each of the executors will run one at a time sequentially. Each executor is a different command that will be run, and each can utilize a different docker image. But each of the executors will see the same mapped inputs and volumes that are declared in the parent CreateTask message. Execution stops on the first error. + #[serde(rename = "executors")] + pub executors: Vec, + /// Volumes are directories which may be used to share data between Executors. Volumes are initialized as empty directories by the system when the task starts and are mounted at the same path in each Executor. For example, given a volume defined at `/vol/A`, executor 1 may write a file to `/vol/A/exec1.out.txt`, then executor 2 may read from that file. (Essentially, this translates to a `docker run -v` flag where the container path is the same for each executor). + #[serde(rename = "volumes", skip_serializing_if = "Option::is_none")] + pub volumes: Option>, + /// A key-value map of arbitrary tags. These can be used to store meta-data and annotations about a task. Example: ``` { \"tags\" : { \"WORKFLOW_ID\" : \"cwl-01234\", \"PROJECT_GROUP\" : \"alice-lab\" } } ``` + #[serde(rename = "tags", skip_serializing_if = "Option::is_none")] + pub tags: Option>, + /// Task logging information. Normally, this will contain only one entry, but in the case where a task fails and is retried, an entry will be appended to this list. + #[serde(rename = "logs", skip_serializing_if = "Option::is_none")] + pub logs: Option>, + /// Date + time the task was created, in RFC 3339 format. This is set by the system, not the client. + #[serde(rename = "creation_time", skip_serializing_if = "Option::is_none")] + pub creation_time: Option, +} + +impl TesTask { + /// Task describes an instance of a task. + pub fn new(executors: Vec) -> TesTask { + TesTask { + id: None, + state: None, + name: None, + description: None, + inputs: None, + outputs: None, + resources: None, + executors, + volumes: None, + tags: None, + logs: None, + creation_time: None, + } + } +} + diff --git a/lib/src/tes/models/tes_task_log.rs b/lib/src/tes/models/tes_task_log.rs new file mode 100644 index 0000000..cc2c990 --- /dev/null +++ b/lib/src/tes/models/tes_task_log.rs @@ -0,0 +1,52 @@ +/* + * Task Execution Service + * + * ## Executive Summary The Task Execution Service (TES) API is a standardized schema and API for describing and executing batch execution tasks. A task defines a set of input files, a set of containers and commands to run, a set of output files and some other logging and metadata. TES servers accept task documents and execute them asynchronously on available compute resources. A TES server could be built on top of a traditional HPC queuing system, such as Grid Engine, Slurm or cloud style compute systems such as AWS Batch or Kubernetes. ## Introduction This document describes the TES API and provides details on the specific endpoints, request formats, and responses. It is intended to provide key information for developers of TES-compatible services as well as clients that will call these TES services. Use cases include: - Deploying existing workflow engines on new infrastructure. Workflow engines such as CWL-Tes and Cromwell have extentions for using TES. This will allow a system engineer to deploy them onto a new infrastructure using a job scheduling system not previously supported by the engine. - Developing a custom workflow management system. This API provides a common interface to asynchronous batch processing capabilities. A developer can write new tools against this interface and expect them to work using a variety of backend solutions that all support the same specification. ## Standards The TES API specification is written in OpenAPI and embodies a RESTful service philosophy. It uses JSON in requests and responses and standard HTTP/HTTPS for information transport. HTTPS should be used rather than plain HTTP except for testing or internal-only purposes. ### Authentication and Authorization Is is envisaged that most TES API instances will require users to authenticate to use the endpoints. However, the decision if authentication is required should be taken by TES API implementers. If authentication is required, we recommend that TES implementations use an OAuth2 bearer token, although they can choose other mechanisms if appropriate. Checking that a user is authorized to submit TES requests is a responsibility of TES implementations. ### CORS If TES API implementation is to be used by another website or domain it must implement Cross Origin Resource Sharing (CORS). Please refer to https://w3id.org/ga4gh/product-approval-support/cors for more information about GA4GH’s recommendations and how to implement CORS. + * + * The version of the OpenAPI document: 1.1.0 + * + * Generated by: https://openapi-generator.tech + */ + +#![allow(unused_imports)] +#![allow(clippy::empty_docs)] +use crate::tes::models; +use serde::{Deserialize, Serialize}; + +/// TesTaskLog : TaskLog describes logging information related to a Task. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TesTaskLog { + /// Logs for each executor + #[serde(rename = "logs")] + pub logs: Vec, + /// Arbitrary logging metadata included by the implementation. + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + /// When the task started, in RFC 3339 format. + #[serde(rename = "start_time", skip_serializing_if = "Option::is_none")] + pub start_time: Option, + /// When the task ended, in RFC 3339 format. + #[serde(rename = "end_time", skip_serializing_if = "Option::is_none")] + pub end_time: Option, + /// Information about all output files. Directory outputs are flattened into separate items. + #[serde(rename = "outputs")] + pub outputs: Vec, + /// System logs are any logs the system decides are relevant, which are not tied directly to an Executor process. Content is implementation specific: format, size, etc. System logs may be collected here to provide convenient access. For example, the system may include the name of the host where the task is executing, an error message that caused a SYSTEM_ERROR state (e.g. disk is full), etc. System logs are only included in the FULL task view. + #[serde(rename = "system_logs", skip_serializing_if = "Option::is_none")] + pub system_logs: Option>, +} + +impl TesTaskLog { + /// TaskLog describes logging information related to a Task. + pub fn new(logs: Vec, outputs: Vec) -> TesTaskLog { + TesTaskLog { + logs, + metadata: None, + start_time: None, + end_time: None, + outputs, + system_logs: None, + } + } +} + From 8ddb90b2e20cafd3bc80757bb5ba7add4d780b1a Mon Sep 17 00:00:00 2001 From: aaravm Date: Tue, 13 Aug 2024 02:20:33 +0530 Subject: [PATCH 92/92] initial commit --- lib/src/configuration.rs | 153 ++++++++++++++++++++++++++++++++----- lib/src/lib.rs | 3 +- lib/src/serviceinfo/mod.rs | 6 +- lib/src/tes/mod.rs | 6 +- lib/src/transport.rs | 113 ++++++++++++++++++++++++--- 5 files changed, 249 insertions(+), 32 deletions(-) diff --git a/lib/src/configuration.rs b/lib/src/configuration.rs index 01026b9..b6b9688 100644 --- a/lib/src/configuration.rs +++ b/lib/src/configuration.rs @@ -1,57 +1,135 @@ +use url::Url; +/// A struct representing a configuration for the SDK. +/// +/// The `Configuration` struct is responsible for specifying details of the Endpoint where the requests are made. +/// It provides methods for making constructing new configuration, changing the base url, and specifying a default configuration. #[derive(Debug, Clone)] pub struct Configuration { - pub base_path: String, + /// The base path for API requests. + pub base_path: Url, + /// The user agent to be used in API requests. pub user_agent: Option, + /// The basic authentication credentials. pub basic_auth: Option, + /// The OAuth access token for authentication. pub oauth_access_token: Option, + /// The bearer access token for authentication. pub bearer_access_token: Option, + /// The API key for authentication. pub api_key: Option, } -// Check whether defining BasicAuth works like this or not, else revert to the basic definition commented out -#[derive(Debug, Clone)] +/// Represents the basic authentication credentials. +#[derive(Debug, Clone, PartialEq)] pub struct BasicAuth { + /// The username for basic authentication. pub username: String, + /// The password for basic authentication. pub password: Option, } -// pub type BasicAuth = (String, Option); -#[derive(Debug, Clone)] +/// Represents the API key for authentication. +#[derive(Debug, Clone, PartialEq)] pub struct ApiKey { + /// The prefix for the API key. pub prefix: Option, + /// The key value of the API key. pub key: String, } impl Configuration { + /// Creates a new instance of Configuration. + /// + /// # Arguments + /// + /// * `base_path` - The base path for API requests. + /// * `user_agent` - The user agent to be used in API requests. + /// * `basic_auth` - The basic authentication credentials. + /// * `oauth_access_token` - The OAuth access token for authentication. + /// + /// # Returns + /// + /// A new instance of Configuration. pub fn new( - base_path: String, - user_agent: Option, - basic_auth: Option, - oauth_access_token: Option, + base_path: Url, ) -> Self { Configuration { base_path, - user_agent, - basic_auth, - oauth_access_token, + user_agent:None, + basic_auth: None, + oauth_access_token: None, bearer_access_token: None, api_key: None, } } - pub fn set_base_path(&mut self, base_path: &str) -> &mut Self { - if base_path.is_empty() { - panic!("Empty base path"); - } - self.base_path = base_path.to_string(); + /// Sets the base path for API requests. + /// + /// # Arguments + /// + /// * `base_path` - The base path for API requests. + /// + /// # Returns + /// + /// A mutable reference to the Configuration instance. + pub fn set_base_path(&mut self, base_path: Url) -> &mut Self { + self.base_path = base_path; + self + } + + /// Sets the user agent for API requests. + /// + /// # Arguments + /// + /// * `user_agent` - The user agent to be used in API requests. + /// + /// # Returns + /// + /// A new instance of Configuration. + pub fn with_user_agent(mut self, user_agent: String) -> Self { + self.user_agent = Some(user_agent); + self + } + + /// Sets the basic authentication credentials for API requests. + /// + /// # Arguments + /// + /// * `basic_auth` - The basic authentication credentials. + /// + /// # Returns + /// + /// A new instance of Configuration. + pub fn with_basic_auth(mut self, basic_auth: BasicAuth) -> Self { + self.basic_auth = Some(basic_auth); + self + } + + /// Sets the OAuth access token for API requests. + /// + /// # Arguments + /// + /// * `oauth_access_token` - The OAuth access token for authentication. + /// + /// # Returns + /// + /// A new instance of Configuration. + pub fn with_oauth_access_token(mut self, oauth_access_token: String) -> Self { + self.oauth_access_token = Some(oauth_access_token); self } } impl Default for Configuration { + /// Creates a default instance of Configuration. + /// + /// # Returns + /// + /// A default instance of Configuration. + /// This is used to define a configuration for a server that is running on your localhost fn default() -> Self { Configuration { - base_path: "localhost".to_owned(), + base_path: Url::parse("http://localhost").unwrap(), user_agent: Some("GA4GH SDK".to_owned()), basic_auth: None, oauth_access_token: None, @@ -60,3 +138,42 @@ impl Default for Configuration { } } } + +#[cfg(test)] +mod tests { + use super::*; + use url::Url; + + #[test] + fn test_new_configuration() { + let config = Configuration::new( + Url::parse("https://api.example.com").unwrap(), + ) + .with_user_agent("My User Agent".to_owned()) + .with_basic_auth(BasicAuth { + username: "admin".to_owned(), + password: Some("password".to_owned()), + }) + .with_oauth_access_token("my_oauth_token".to_owned()); + + assert_eq!(config.base_path.as_str(), "https://api.example.com/"); + assert_eq!(config.user_agent, Some("My User Agent".to_owned())); + assert_eq!( + config.basic_auth, + Some(BasicAuth { + username: "admin".to_owned(), + password: Some("password".to_owned()), + }) + ); + assert_eq!(config.oauth_access_token, Some("my_oauth_token".to_owned())); + assert_eq!(config.bearer_access_token, None); + assert_eq!(config.api_key, None); + } + + #[test] + fn test_set_base_path() { + let mut config = Configuration::default(); + config.set_base_path(Url::parse("https://api.example.com").unwrap()); + assert_eq!(config.base_path.as_str(), "https://api.example.com/"); + } +} diff --git a/lib/src/lib.rs b/lib/src/lib.rs index 012b141..243bff2 100644 --- a/lib/src/lib.rs +++ b/lib/src/lib.rs @@ -6,6 +6,7 @@ extern crate serde_derive; mod test_utils; pub mod configuration; +pub mod transport; pub mod serviceinfo; pub mod tes; -pub mod transport; + diff --git a/lib/src/serviceinfo/mod.rs b/lib/src/serviceinfo/mod.rs index cf9b27c..7f307cc 100644 --- a/lib/src/serviceinfo/mod.rs +++ b/lib/src/serviceinfo/mod.rs @@ -46,7 +46,11 @@ mod tests { setup(); let mut config = Configuration::default(); let funnel_url = ensure_funnel_running().await; - config.set_base_path(&funnel_url); + + // Parse the funnel_url String into a Url + let funnel_url = url::Url::parse(&funnel_url).expect("Invalid URL format"); + + config.set_base_path(funnel_url); let service_info = ServiceInfo::new(&config).unwrap(); // Call get_service_info and print the result diff --git a/lib/src/tes/mod.rs b/lib/src/tes/mod.rs index 3ae5823..a5b9281 100644 --- a/lib/src/tes/mod.rs +++ b/lib/src/tes/mod.rs @@ -204,7 +204,11 @@ mod tests { // setup(); – should be run once in the test function let mut config = Configuration::default(); let funnel_url = ensure_funnel_running().await; - config.set_base_path(&funnel_url); + + // Parse the funnel_url String into a Url + let funnel_url = url::Url::parse(&funnel_url).expect("Invalid URL format"); + + config.set_base_path(funnel_url); let tes = match TES::new(&config).await { Ok(tes) => tes, Err(e) => { diff --git a/lib/src/transport.rs b/lib/src/transport.rs index 98690e4..569200b 100644 --- a/lib/src/transport.rs +++ b/lib/src/transport.rs @@ -1,3 +1,31 @@ +/// A struct representing a transport for making HTTP requests. +/// +/// The `Transport` struct is responsible for handling HTTP requests using the `reqwest` crate. +/// It provides methods for making GET, POST, PUT, and DELETE requests. +/// +/// # Examples +/// +/// ``` +/// use crate::configuration::Configuration; +/// use crate::transport::Transport; +/// +/// let config = Configuration::new("Url::parse("https://api.example.com").unwrap() , None, None, None); +/// let transport = Transport::new(&config); +/// +/// // Make a GET request +/// let response = transport.get("/users", None).await; +/// +/// // Make a POST request +/// let data = serde_json::json!({"name": "John Doe", "age": 30}); +/// let response = transport.post("/users", Some(data)).await; +/// +/// // Make a PUT request +/// let data = serde_json::json!({"name": "John Doe", "age": 30}); +/// let response = transport.put("/users/1", data).await; +/// +/// // Make a DELETE request +/// let response = transport.delete("/users/1").await; +/// ``` use crate::configuration::Configuration; use log::error; use reqwest::Client; @@ -12,6 +40,16 @@ pub struct Transport { } impl Transport { + + /// Creates a new `Transport` instance with the given configuration. + /// + /// # Arguments + /// + /// * `config` - The configuration for the transport. + /// + /// # Returns + /// + /// A new `Transport` instance. pub fn new(config: &Configuration) -> Self { Transport { config: config.clone(), @@ -19,6 +57,18 @@ impl Transport { } } + /// Sends an HTTP request with the specified method, endpoint, data, and parameters. + /// + /// # Arguments + /// + /// * `method` - The HTTP method for the request. + /// * `endpoint` - The endpoint for the request. + /// * `data` - The data to send with the request (optional). + /// * `params` - The query parameters for the request (optional). + /// + /// # Returns + /// + /// A `Result` containing the response body as a string, or an error if the request fails. async fn request( &self, method: reqwest::Method, @@ -26,8 +76,8 @@ impl Transport { data: Option, params: Option, ) -> Result> { - let full_url = format!("{}{}", self.config.base_path, endpoint); - let url = reqwest::Url::parse(&full_url).map_err(|e| { + let base_url = &self.config.base_path; + let url = base_url.join(endpoint).map_err(|e| { error!("Invalid endpoint (shouldn't contain base url): {}. Error: {}", endpoint, e); Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid endpoint")) as Box })?; @@ -37,7 +87,7 @@ impl Transport { if let Some(ref user_agent) = self.config.user_agent { request_builder = request_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); } - + if let Some(ref params_value) = params { // Validate or log params_value before setting it as query parameters if params_value.is_object() { @@ -52,7 +102,7 @@ impl Transport { if serde_json::to_string(&data).is_ok() { request_builder = request_builder.json(&data); } else { - eprintln!("Parameters are invalid, and can't convert to JSON"); + log::error!("Parameters are invalid, and can't convert to JSON"); } } @@ -76,6 +126,16 @@ impl Transport { } } + /// Sends a GET request to the specified endpoint with the given query parameters. + /// + /// # Arguments + /// + /// * `endpoint` - The endpoint for the request. + /// * `params` - The query parameters for the request (optional). + /// + /// # Returns + /// + /// A `Result` containing the response body as a string, or an error if the request fails. pub async fn get( &self, endpoint: &str, @@ -85,6 +145,16 @@ impl Transport { .await } + /// Sends a POST request to the specified endpoint with the given data. + /// + /// # Arguments + /// + /// * `endpoint` - The endpoint for the request. + /// * `data` - The data to send with the request (optional). + /// + /// # Returns + /// + /// A `Result` containing the response body as a string, or an error if the request fails. pub async fn post( &self, endpoint: &str, @@ -93,12 +163,31 @@ impl Transport { self.request(reqwest::Method::POST, endpoint, data, None) .await } - + + /// Sends a PUT request to the specified endpoint with the given data. + /// + /// # Arguments + /// + /// * `endpoint` - The endpoint for the request. + /// * `data` - The data to send with the request. + /// + /// # Returns + /// + /// A `Result` containing the response body as a string, or an error if the request fails. pub async fn put(&self, endpoint: &str, data: Value) -> Result> { self.request(reqwest::Method::PUT, endpoint, Some(data), None) .await } + /// Sends a DELETE request to the specified endpoint. + /// + /// # Arguments + /// + /// * `endpoint` - The endpoint for the request. + /// + /// # Returns + /// + /// A `Result` containing the response body as a string, or an error if the request fails. pub async fn delete(&self, endpoint: &str) -> Result> { self.request(reqwest::Method::DELETE, endpoint, None, None) .await @@ -110,23 +199,25 @@ impl Transport { #[cfg(test)] mod tests { use crate::configuration::Configuration; - use crate::test_utils::setup; use crate::transport::Transport; use mockito::mock; + use url::Url; + + // effectively no sense in testing various responses, as it's reqwest's responsibility + // we should test Transport's methods instead #[tokio::test] async fn test_request() { - setup(); - let base_url = &mockito::server_url(); - // effectively no sense in testing various responses, as it's reqwest's responsibility - // we should test Transport's methods + let base_url_str = mockito::server_url(); + let base_url = Url::parse(&base_url_str).expect("Failed to parse mock server URL"); + let _m = mock("GET", "/test") .with_status(200) .with_header("content-type", "application/json") .with_body(r#"{"message": "success"}"#) .create(); - let config = Configuration::new(base_url.clone(),None, None, None); + let config = Configuration::new(base_url.clone()); let transport = Transport::new(&config.clone()); let response = transport.get("/test", None).await;