Introduction
Mitosis is a Rust library and a command line tool to run distributed platforms for transport research.
This guide is an example of how to use Mitosis to run a simple distributed platform to parallelize your tasks. It is designed for transport-layer research, but it can be used for any other purpose.
Basic Workflow
The Mitosis CLI tool is a single binary that provides subcommands for starting the Coordinator, Worker and Client processes.
Users function as units for access control, while groups operate as units for tangible resource control. Every user has an identically named group but also has the option to create or join additional groups.
Users can delegate tasks to various groups via the Client, which are then delivered to the Coordinator and subsequently executed by the corresponding Worker. Each Worker can be configured to permit specific groups and carry tags to denote its characteristics.
Tasks, once submitted, are distributed to different Workers based on their groups and tags. Every task is assigned a unique UUID, allowing users to track the status and results of their tasks.
Contributing
Mitosis is free and open source. You can find the source code on GitHub and issues and feature requests can be posted on the GitHub issue tracker. Mitosis relies on the community to fix bugs and add features: if you'd like to contribute, please read the CONTRIBUTING guide and consider opening a pull request.
Installation
The Mitosis project contains a CLI tool (named mito
) that you can use to directly start a distributed platform,
and a SDK library (named netmito
) that you can use to create your own client.
There are multiple ways to install the Mitosis CLI tool. Choose any one of the methods below that best suit your needs.
ATTENTION: As we are still in the early stages of development without a released version, we only support building from source currently.
Pre-compiled binaries
Executable binaries are available for download on the GitHub Releases page.
Download the binary and extract the archive.
The archive contains an mito
executable which you can run to start your distributed platform.
To make it easier to run, put the path to the binary into your PATH
or install it in a directory that is already in your PATH
.
For example, do sudo install -m 755 mito /usr/local/bin/mito
on Linux.
Build from source using Rust
Dependencies
You have to install pkg-config, libssl-dev if you want to build the binary from source.
Installing with Cargo
To build the mito
executable from source, you will first need to install Rust and Cargo.
Follow the instructions on the Rust installation page.
Once you have installed Rust, the following command can be used to build and install mito:
cargo install mito
This will automatically download mito from crates.io, build it, and install it in Cargo's global binary directory (~/.cargo/bin/
by default).
You can run cargo install mito
again whenever you want to update to a new version.
That command will check if there is a newer version, and re-install mito if a newer version is found.
To uninstall, run the command cargo uninstall mito
.
Installing the latest git version with Cargo
The version published to crates.io will ever so slightly be behind the version hosted on GitHub. If you need the latest version you can build the git version of mito yourself. Cargo makes this super easy!
cargo install --git https://github.com/stack-rs/mitosis.git mito
Again, make sure to add the Cargo bin directory to your PATH
.
Building from source
If you want to build the binary from source, you can clone the repository and build it using Cargo.
git clone https://github.com/stack-rs/mitosis.git
cd mitosis
cargo build --release
Then you can find the binary in target/release/mito
and install or run it as you like.
Modifying and contributing
If you are interested in making modifications to Mitosis itself, check out the Contributing Guide for more information.
Running a Coordinator
A Coordinator is a process that manages the execution of a workflow. It is responsible for scheduling tasks, tracking their progress, and handling failures. The Coordinator is a long-running process that is typically deployed as a service.
External Requirements
The Coordinator requires access to several external services. It needs a PostgreSQL database to store data, an S3-compatible storage service to store task artifacts or group attachments. The Redis server is an optional service that acts as a pub/sub provider, enabling clients to subscribe to and query more comprehensive details regarding the execution status of tasks.
For those services, you can use the docker-compose file provided in the repository.
First, Copy .env.example
to .env
and set the variables in it.
And then, run the following command to start the services:
docker-compose up -d
The Coordinator also requires a private and public key pair to sign and verify access tokens. For the private and public keys, you can generate them using the following commands:
openssl genpkey -algorithm ed25519 -out private.pem
openssl pkey -in private.pem -pubout -out public.pem
Starting a Coordinator
To start a Coordinator, you need to provide a TOML file that configures the Coordinator. The TOML file specifies the Coordinator's configuration, such as the address it binds to, the URL of the postgres database, and token expiry settings. All configuration options are optional and have default values.
Here is an example of a Coordinator configuration file (you can also refer to config.example.toml
in the repository):
[coordinator]
bind = "127.0.0.1:5000"
db_url = "postgres://mitosis:mitosis@localhost/mitosis"
s3_url = "http://127.0.0.1:9000"
s3_access_key = "mitosis_access"
s3_secret_key = "mitosis_secret"
# redis_url is not set. It should be in format like "redis://:mitosis@localhost"
# redis_worker_password is not set by default and will be generated randomly
# redis_client_password is not set by default and will be generated randomly
admin_user = "mitosis_admin"
admin_password = "mitosis_admin"
access_token_private_path = "private.pem"
access_token_public_path = "public.pem"
access_token_expires_in = "7d"
heartbeat_timeout = "600s"
file_log = false
# log_path is not set. It will use the default rolling log file path if file_log is set to true
To start a Coordinator, run the following command:
mito coordinator --config /path/to/coordinator.toml
The Coordinator will start and listen for incoming requests on the specified address.
We can also override the configuration settings using command-line arguments. Note that the names of command-line arguments may not be the same as those in the configuration file. For example, to change the address the Coordinator binds to, you can run:
mito coordinator --config /path/to/coordinator.toml --bind 0.0.0.0:8000
The full list of command-line arguments can be found by running mito coordinator --help
:
Run the mitosis coordinator
Usage: mito coordinator [OPTIONS]
Options:
-b, --bind <BIND>
The address to bind to
--config <CONFIG>
The path of the config file
--db <DB_URL>
The database URL
--s3 <S3_URL>
The S3 URL
--s3-access-key <S3_ACCESS_KEY>
The S3 access key
--s3-secret-key <S3_SECRET_KEY>
The S3 secret key
--redis <REDIS_URL>
The Redis URL
--redis-worker-password <REDIS_WORKER_PASSWORD>
The Redis worker password
--redis-client-password <REDIS_CLIENT_PASSWORD>
The Redis client password
--admin-user <ADMIN_USER>
The admin username
--admin-password <ADMIN_PASSWORD>
The admin password
--access-token-private-path <ACCESS_TOKEN_PRIVATE_PATH>
The path to the private key, default to `private.pem`
--access-token-public-path <ACCESS_TOKEN_PUBLIC_PATH>
The path to the public key, default to `public.pem`
--access-token-expires-in <ACCESS_TOKEN_EXPIRES_IN>
The access token expiration time, default to 7 days
--heartbeat-timeout <HEARTBEAT_TIMEOUT>
The heartbeat timeout, default to 600 seconds
--log-path <LOG_PATH>
The log file path. If not specified, then the default rolling log file path would be used. If specified, then the log file would be exactly at the path specified
--file-log
Enable logging to file
-h, --help
Print help
-V, --version
Print version
Running a Worker
A Worker is a process that executes tasks. It is responsible for fetching tasks from the Coordinator, executing them, and reporting the results back to the Coordinator. The Worker is a long-running process that is typically deployed as a service.
Starting a Worker
To start a Worker, you need to provide a TOML file that configures the Worker. The TOML file specifies the Worker's configuration, such as the polling (fetching) interval, the URL of the Coordinator, and the the groups allowed to submit tasks to it. All configuration options are optional and have default values.
Here is an example of a Worker configuration file (you can also refer to config.example.toml
in the repository):
[worker]
coordinator_addr = "http://127.0.0.1:5000"
polling_interval = "3m"
heartbeat_interval = "5m"
lifetime = "7d"
# credential_path is not set
# user is not set
# password is not set
# groups are not set, default to the user's group
# tags are not set
file_log = false
# log_path is not set. It will use the default rolling log file path if file_log is set to true
# lifetime is not set, default to the coordinator's setting
To start a Worker, run the following command:
mito worker --config /path/to/worker.toml
The Worker will start and fetch tasks from the Coordinator at the specified interval.
We can also override the configuration settings using command-line arguments. Note that the names of command-line arguments may not be the same as those in the configuration file. For example, to change the polling interval, you can run:
mito worker --config /path/to/worker.toml --polling-interval 5m
The full list of command-line arguments can be found by running mito worker --help
:
Run a mitosis worker
Usage: mito worker [OPTIONS]
Options:
--config <CONFIG>
The path of the config file
-c, --coordinator <COORDINATOR_ADDR>
The address of the coordinator
--polling-interval <POLLING_INTERVAL>
The interval to poll tasks or resources
--heartbeat-interval <HEARTBEAT_INTERVAL>
The interval to send heartbeat
--credential-path <CREDENTIAL_PATH>
The path of the user credential file
-u, --user <USER>
The username of the user
-p, --password <PASSWORD>
The password of the user
-g, --groups [<GROUPS>...]
The groups allowed to submit tasks to this worker
-t, --tags [<TAGS>...]
The tags of this worker
--log-path <LOG_PATH>
The log file path. If not specified, then the default rolling log file path would be used. If specified, then the log file would be exactly at the path specified
--file-log
Enable logging to file
--lifetime <LIFETIME>
The lifetime of the worker to alive (e.g., 7d, 1year)
-h, --help
Print help
-V, --version
Print version
Running a Client
A Client is a process that interact with the Coordinator. It is responsible for creating tasks, querying their results, and managing workers or groups. The Client is a short-lived process that is typically run on-demand.
Starting a Client
While it's possible to provide a TOML configuration file to the client, it's often unnecessary given the limited number of configuration items, all of which pertain to login procedures.
Typically, to start a Client, we can simply run the following command to enter interactive mode:
mito client -i
If a user has never logged in or if his/her session has expired, the Client will prompt them to re-input their username and password for authentication.
Alternatively, they can directly specify their username (-u
) or password (-p
) during execution.
Once authenticated, the Client will retain their credentials in a file for future use.
We recommend using the interactive mode for most operations, as it provides a more user-friendly experience.
We can also directly run a command without entering interactive mode by specifying the command as an argument. For example, to create a new user, we can run:
mito client create user -u new_user -p new_password
The full list of command-line arguments can be found by running mito client --help
:
Run a mitosis client
Usage: mito client [OPTIONS] [COMMAND]
Commands:
create Create a new user or group
get Get the info of a task, artifact, attachment, or a list of tasks subject to the filters
submit Submit a task
upload Upload an attachment to a group
cancel Cancel a worker or a task
quit Quit the client's interactive mode
help Print this message or the help of the given subcommand(s)
Options:
--config <CONFIG> The path of the config file
-c, --coordinator <COORDINATOR_ADDR> The address of the coordinator
--credential-path <CREDENTIAL_PATH> The path of the user credential file
-u, --user <USER> The username of the user
-p, --password <PASSWORD> The password of the user
-i, --interactive Enable interactive mode
-h, --help Print help
-V, --version Print version
To know how each subcommand works, you can run mito client <subcommand> --help
.
For example, to know how to create a new user, you can run mito client create user --help
:
Create a new user
Usage: mito client create user [OPTIONS] --username <USERNAME> --password <PASSWORD>
Options:
-u, --username <USERNAME> The username of the user
-p, --password <PASSWORD> The password of the user
--admin Whether the user is an admin
-h, --help Print help
-V, --version Print version
Client SDK
The Mitosis project contains a SDK library (named netmito
) that you can use to create your own client programmatically.
To use the SDK, add the following to your Cargo.toml
:
[dependencies]
netmito = "0.1"
Here is a simple example of how to create a new user using the SDK:
use netmito::client::MitoClient;
use netmito::config::client::{ClientConfig, CreateUserArgs};
#[tokio::main]
async fn main() {
// Create a new client configuration
let config = ClientConfig::default();
// Setup the client
let mut client = MitoClient::new(config);
// Create arguments for creating a new user
let args = CreateUserArgs {
username: "new_user".to_string(),
password: "new_password".to_string(),
admin: false,
};
// Create a new user
client.create_user(args).await.unwrap();
}
For more details, please refer to the API documentation.