README.md

centraldogma-rs

Official Rust Client for Central Dogma.

Full documentation is available at https://docs.rs/centraldogma

Getting started

Installing

Add centraldogma crate and version to Cargo.toml.

centraldogma = "0.1"

Async support with tokio

The client uses reqwest to make HTTP calls, which internally uses the tokio runtime for async support. As such, you may require to take a dependency on tokio in order to use the client.

tokio = { version = "1.2.0", features = ["full"] }

Create a client

Create a new client to make API to CentralDogma using the Client struct.

use centraldogma::Client;

#[tokio::main]
async fn main() {
    // with token
    let client = Client::new("http://localhost:36462", Some("token")).await.unwrap();
    // without token
    let client = Client::new("http://localhost:36462", None).await.unwrap();
    // your code ...
}

Making typed API calls

Typed API calls are provided behind traits:

• ProjectService
• RepoService
• ContentService
• WatchService

Examples

Get File

use centraldogma::{
    Client, ContentService,
    model::{Revision, Query},
};

#[tokio::main]
async fn main() {
    // without token
    let client = Client::new("http://localhost:36462", None).await.unwrap();

    let file = client
        .repo("project", "repository")
        .get_file(Revision::HEAD, &Query::of_text("/a.yml").unwrap())
        .await
        .unwrap();
    // your code ...
}

Push

use centraldogma::{
    Client, ContentService,
    model::{Revision, Change, ChangeContent, CommitMessage},
};
use serde_json;

#[tokio::main]
async fn main() {
    let client = Client::new("http://localhost:36462", None).await.unwrap();
    let changes = vec![Change {
        path: "/a.json".to_string(),
        content: ChangeContent::UpsertJson(serde_json::json!({"a":"b"})),
    }];
    let result = client
        .repo("foo", "bar")
        .push(
            Revision::HEAD,
            CommitMessage::only_summary("Add a.json"),
            changes,
        )
        .await
        .unwrap();
}

Watch file change

use centraldogma::{Client, WatchService, model::Query};
use futures::StreamExt;

#[tokio::main]
async fn main() {
    let client = Client::new("http://localhost:36462", None).await.unwrap();
    let mut stream = client
        .repo("foo", "bar")
        .watch_file_stream(&Query::identity("/a.json").unwrap())
        .unwrap();

    tokio::spawn(async move {
        while let Some(result) = stream.next().await {
            // your code ...
        }
    });
}

Contributing

See CONTRIBUTING.md.