robin/haze
1
0
Fork 0
mirror of https://codeberg.org/icewind/haze.git synced 2026-06-03 09:04:12 +02:00
Code Issues Projects Releases Wiki Activity

split services into seperate files

Browse source
This commit is contained in:
Robin Appelman 2021-07-30 18:04:14 +02:00
commit 3cac4e4679
9 changed files with 434 additions and 463 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/cloud.rs
View file

@ -4,6 +4,7 @@ use crate::exec::{exec, exec_tty, ExitCode};
use crate::mapping::{default_mappings, Mapping};
use crate::php::PhpVersion;
use crate::service::Service;
use crate::service::ServiceTrait;
use bollard::container::{ListContainersOptions, RemoveContainerOptions};
use bollard::models::ContainerState;
use bollard::network::CreateNetworkOptions;

3
src/image.rs
View file

@ -21,8 +21,7 @@ pub async fn pull_image(docker: &Docker, image: &str) -> Result<()> {
let mut bars: HashMap<String, u16> = HashMap::new();
let stdout = stdout();
let mut stdout = stdout.lock();
let mut stdout = stdout();
while let Some(info) = info_stream.next().await {
let info: CreateImageInfo = info?;
// dbg!(&info);

1
src/main.rs
View file

@ -3,6 +3,7 @@ use crate::cloud::{Cloud, CloudOptions};
use crate::config::HazeConfig;
use crate::exec::container_logs;
use crate::service::Service;
use crate::service::ServiceTrait;
use bollard::Docker;
use color_eyre::{eyre::WrapErr, Result};

510
src/service.rs
View file

@ -1,61 +1,62 @@
use crate::exec::exec;
use crate::image::pull_image;
use bollard::container::{Config, CreateContainerOptions, NetworkingConfig};
use bollard::models::{ContainerState, EndpointSettings, HostConfig};
mod ldap;
mod objectstore;
mod onlyoffice;
use crate::service::ldap::{LDAPAdmin, LDAP};
use crate::service::objectstore::ObjectStore;
use crate::service::onlyoffice::OnlyOffice;
use bollard::models::ContainerState;
use bollard::Docker;
use color_eyre::{eyre::WrapErr, Report, Result};
use maplit::hashmap;
use color_eyre::{eyre::WrapErr, Result};
use enum_dispatch::enum_dispatch;
use std::time::Duration;
use tokio::time::{sleep, timeout};
#[derive(Debug, Clone, Eq, PartialEq)]
#[async_trait::async_trait]
#[enum_dispatch(Service)]
pub trait ServiceTrait {
fn name(&self) -> &str;
fn env(&self) -> &[&str];
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String>;
async fn is_healthy(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
Ok(matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
))
}
fn container_name(&self, cloud_id: &str) -> String;
async fn start_message(&self, docker: &Docker, cloud_id: &str) -> Result<Option<String>>;
fn apps(&self) -> &'static [&'static str];
async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>>;
}
#[enum_dispatch]
#[derive(Clone, Eq, PartialEq, Debug)]
pub enum Service {
ObjectStore(ObjectStore),
Ldap(LDAP),
LdapAdmin(LDAPAdmin),
LDAP(LDAP),
LDAPAdmin(LDAPAdmin),
OnlyOffice(OnlyOffice),
}
impl Service {
pub fn name(&self) -> &str {
match self {
Service::ObjectStore(store) => store.name(),
Service::Ldap(ldap) => ldap.name(),
Service::LdapAdmin(ldap_admin) => ldap_admin.name(),
Service::OnlyOffice(office) => office.name(),
}
}
pub fn env(&self) -> &[&str] {
match self {
Service::ObjectStore(store) => store.env(),
Service::Ldap(ldap) => ldap.env(),
Service::LdapAdmin(ldap_admin) => ldap_admin.env(),
Service::OnlyOffice(office) => office.env(),
}
}
pub async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
match self {
Service::ObjectStore(store) => store.spawn(docker, cloud_id, network).await,
Service::Ldap(ldap) => ldap.spawn(docker, cloud_id, network).await,
Service::LdapAdmin(ldap_admin) => ldap_admin.spawn(docker, cloud_id, network).await,
Service::OnlyOffice(office) => office.spawn(docker, cloud_id, network).await,
}
}
async fn is_healthy(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
match self {
Service::ObjectStore(store) => store.is_healthy(docker, cloud_id).await,
Service::Ldap(ldap) => ldap.is_healthy(docker, cloud_id).await,
Service::LdapAdmin(ldap_admin) => ldap_admin.is_healthy(docker, cloud_id).await,
Service::OnlyOffice(office) => office.is_healthy(docker, cloud_id).await,
}
}
pub fn from_type(ty: &str) -> Option<&'static [Self]> {
match ty {
"s3" => Some(&[Service::ObjectStore(ObjectStore::S3)]),
"ldap" => Some(&[Service::Ldap(LDAP), Service::LdapAdmin(LDAPAdmin)]),
"ldap" => Some(&[Service::LDAP(LDAP), Service::LDAPAdmin(LDAPAdmin)]),
"onlyoffice" => Some(&[Service::OnlyOffice(OnlyOffice)]),
_ => None,
}
@ -71,421 +72,4 @@ impl Service {
.await
.wrap_err("Timeout after 30 seconds")?
}
pub fn container_name(&self, cloud_id: &str) -> String {
match self {
Service::ObjectStore(store) => store.container_name(cloud_id),
Service::Ldap(ldap) => ldap.container_name(cloud_id),
Service::LdapAdmin(ldap_admin) => ldap_admin.container_name(cloud_id),
Service::OnlyOffice(office) => office.container_name(cloud_id),
}
}
pub async fn start_message(&self, docker: &Docker, cloud_id: &str) -> Result<Option<String>> {
match self {
Service::ObjectStore(store) => store.start_message(docker, cloud_id).await,
Service::Ldap(ldap) => ldap.start_message(docker, cloud_id).await,
Service::LdapAdmin(ldap_admin) => ldap_admin.start_message(docker, cloud_id).await,
Service::OnlyOffice(office) => office.start_message(docker, cloud_id).await,
}
}
pub fn apps(&self) -> &'static [&'static str] {
match self {
Service::ObjectStore(store) => store.apps(),
Service::Ldap(ldap) => ldap.apps(),
Service::LdapAdmin(ldap_admin) => ldap_admin.apps(),
Service::OnlyOffice(office) => office.apps(),
}
}
pub async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>> {
match self {
Service::ObjectStore(store) => store.post_setup(docker, cloud_id).await,
Service::Ldap(ldap) => ldap.post_setup(docker, cloud_id).await,
Service::LdapAdmin(ldap_admin) => ldap_admin.post_setup(docker, cloud_id).await,
Service::OnlyOffice(office) => office.post_setup(docker, cloud_id).await,
}
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum ObjectStore {
S3,
}
impl ObjectStore {
fn image(&self) -> &str {
match self {
ObjectStore::S3 => "localstack/localstack:0.12.7",
}
}
fn name(&self) -> &str {
match self {
ObjectStore::S3 => "s3",
}
}
fn self_env(&self) -> Vec<&str> {
match self {
ObjectStore::S3 => vec!["DEBUG=1", "SERVICES=s3"],
}
}
fn env(&self) -> &[&str] {
match self {
ObjectStore::S3 => &["S3=1"],
}
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
pull_image(docker, self.image()).await?;
let options = Some(CreateContainerOptions {
name: format!("{}-object", cloud_id),
});
let config = Config {
image: Some(self.image()),
env: Some(self.self_env()),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
async fn is_healthy(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
let mut output = Vec::new();
exec(
docker,
format!("{}-object", cloud_id),
"root",
vec!["curl", "localhost:4566/health"],
vec![],
Some(&mut output),
)
.await?;
let output = String::from_utf8(output)?;
Ok(output.contains(r#""s3": "running""#))
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-object", cloud_id)
}
async fn start_message(&self, _docker: &Docker, _cloud_id: &str) -> Result<Option<String>> {
Ok(None)
}
fn apps(&self) -> &'static [&'static str] {
&["files_external"]
}
async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
Ok(Vec::new())
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct LDAP;
impl LDAP {
fn image(&self) -> &str {
"icewind1991/haze-ldap"
}
fn name(&self) -> &str {
"ldap"
}
fn self_env(&self) -> Vec<&str> {
vec!["LDAP_ADMIN_PASSWORD=haze"]
}
fn env(&self) -> &[&str] {
&["LDAP=1"]
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
pull_image(docker, self.image()).await?;
let options = Some(CreateContainerOptions {
name: self.container_name(cloud_id),
});
let config = Config {
image: Some(self.image()),
env: Some(self.self_env()),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
cmd: Some(vec!["--copy-service"]),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
async fn is_healthy(&self, _docker: &Docker, _cloud_id: &str) -> Result<bool> {
Ok(true)
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-ldap", cloud_id)
}
async fn start_message(&self, _docker: &Docker, _cloud_id: &str) -> Result<Option<String>> {
Ok(None)
}
fn apps(&self) -> &'static [&'static str] {
&["user_ldap"]
}
async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
Ok(Vec::new())
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct LDAPAdmin;
impl LDAPAdmin {
fn image(&self) -> &str {
"osixia/phpldapadmin"
}
fn name(&self) -> &str {
"ldap-admin"
}
fn self_env(&self) -> Vec<&str> {
vec!["PHPLDAPADMIN_LDAP_HOSTS=ldap"]
}
fn env(&self) -> &[&str] {
&[]
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
pull_image(docker, self.image()).await?;
let options = Some(CreateContainerOptions {
name: self.container_name(cloud_id),
});
let config = Config {
image: Some(self.image()),
env: Some(self.self_env()),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
cmd: Some(vec!["--copy-service"]),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
async fn is_healthy(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
Ok(matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
))
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-ldap-admin", cloud_id)
}
async fn start_message(&self, docker: &Docker, cloud_id: &str) -> Result<Option<String>> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
let ip = if matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
) {
info.network_settings
.unwrap()
.networks
.unwrap()
.values()
.next()
.unwrap()
.ip_address
.clone()
.unwrap()
} else {
return Err(Report::msg("ldap admin not started"));
};
Ok(Some(format!(
"Ldap admin running at: https://{} with 'cn=admin,dc=example,dc=org' and password 'haze'",
ip
)))
}
async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
Ok(Vec::new())
}
fn apps(&self) -> &'static [&'static str] {
&[]
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct OnlyOffice;
impl OnlyOffice {
fn image(&self) -> &str {
"onlyoffice/documentserver"
}
fn name(&self) -> &str {
"onlyoffice"
}
fn self_env(&self) -> Vec<&str> {
vec![]
}
fn env(&self) -> &[&str] {
&[]
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
pull_image(docker, self.image()).await?;
let options = Some(CreateContainerOptions {
name: self.container_name(cloud_id),
});
let config = Config {
image: Some(self.image()),
env: Some(self.self_env()),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
async fn is_healthy(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
Ok(matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
))
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-onlyoffice", cloud_id)
}
async fn start_message(&self, _docker: &Docker, _cloud_id: &str) -> Result<Option<String>> {
Ok(None)
}
fn apps(&self) -> &'static [&'static str] {
&["onlyoffice"]
}
async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
let ip = if matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
) {
info.network_settings
.unwrap()
.networks
.unwrap()
.values()
.next()
.unwrap()
.ip_address
.clone()
.unwrap()
} else {
return Err(Report::msg("onlyoffice not started"));
};
Ok(vec![format!(
"occ config:app:set onlyoffice DocumentServerUrl --value http://{}/",
ip
)])
}
}

160
src/service/ldap.rs Normal file
View file

@ -0,0 +1,160 @@
use crate::image::pull_image;
use crate::service::ServiceTrait;
use crate::Result;
use bollard::container::{Config, CreateContainerOptions, NetworkingConfig};
use bollard::models::{ContainerState, EndpointSettings, HostConfig};
use bollard::Docker;
use color_eyre::Report;
use maplit::hashmap;
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct LDAP;
#[async_trait::async_trait]
impl ServiceTrait for LDAP {
fn name(&self) -> &str {
"ldap"
}
fn env(&self) -> &[&str] {
&["LDAP=1"]
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
let image = "icewind1991/haze-ldap";
pull_image(docker, image).await?;
let options = Some(CreateContainerOptions {
name: self.container_name(cloud_id),
});
let config = Config {
image: Some(image),
env: Some(vec!["LDAP_ADMIN_PASSWORD=haze"]),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
cmd: Some(vec!["--copy-service"]),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-ldap", cloud_id)
}
async fn start_message(&self, _docker: &Docker, _cloud_id: &str) -> Result<Option<String>> {
Ok(None)
}
fn apps(&self) -> &'static [&'static str] {
&["user_ldap"]
}
async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
Ok(Vec::new())
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct LDAPAdmin;
#[async_trait::async_trait]
impl ServiceTrait for LDAPAdmin {
fn name(&self) -> &str {
"ldap-admin"
}
fn env(&self) -> &[&str] {
&[]
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
let image = "osixia/phpldapadmin";
pull_image(docker, image).await?;
let options = Some(CreateContainerOptions {
name: self.container_name(cloud_id),
});
let config = Config {
image: Some(image),
env: Some(vec!["PHPLDAPADMIN_LDAP_HOSTS=ldap"]),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
cmd: Some(vec!["--copy-service"]),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-ldap-admin", cloud_id)
}
async fn start_message(&self, docker: &Docker, cloud_id: &str) -> Result<Option<String>> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
let ip = if matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
) {
info.network_settings
.unwrap()
.networks
.unwrap()
.values()
.next()
.unwrap()
.ip_address
.clone()
.unwrap()
} else {
return Err(Report::msg("ldap admin not started"));
};
Ok(Some(format!(
"Ldap admin running at: https://{} with 'cn=admin,dc=example,dc=org' and password 'haze'",
ip
)))
}
async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
Ok(Vec::new())
}
fn apps(&self) -> &'static [&'static str] {
&[]
}
}

104
src/service/objectstore.rs Normal file
View file

@ -0,0 +1,104 @@
use crate::exec::exec;
use crate::image::pull_image;
use crate::service::ServiceTrait;
use crate::Result;
use bollard::container::{Config, CreateContainerOptions, NetworkingConfig};
use bollard::models::{EndpointSettings, HostConfig};
use bollard::Docker;
use maplit::hashmap;
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum ObjectStore {
S3,
}
impl ObjectStore {
fn image(&self) -> &str {
match self {
ObjectStore::S3 => "localstack/localstack:0.12.7",
}
}
fn self_env(&self) -> Vec<&str> {
match self {
ObjectStore::S3 => vec!["DEBUG=1", "SERVICES=s3"],
}
}
}
#[async_trait::async_trait]
impl ServiceTrait for ObjectStore {
fn name(&self) -> &str {
match self {
ObjectStore::S3 => "s3",
}
}
fn env(&self) -> &[&str] {
match self {
ObjectStore::S3 => &["S3=1"],
}
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
pull_image(docker, self.image()).await?;
let options = Some(CreateContainerOptions {
name: format!("{}-object", cloud_id),
});
let config = Config {
image: Some(self.image()),
env: Some(self.self_env()),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
async fn is_healthy(&self, docker: &Docker, cloud_id: &str) -> Result<bool> {
let mut output = Vec::new();
exec(
docker,
format!("{}-object", cloud_id),
"root",
vec!["curl", "localhost:4566/health"],
vec![],
Some(&mut output),
)
.await?;
let output = String::from_utf8(output)?;
Ok(output.contains(r#""s3": "running""#))
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-object", cloud_id)
}
async fn start_message(&self, _docker: &Docker, _cloud_id: &str) -> Result<Option<String>> {
Ok(None)
}
fn apps(&self) -> &'static [&'static str] {
&["files_external"]
}
async fn post_setup(&self, _docker: &Docker, _cloud_id: &str) -> Result<Vec<String>> {
Ok(Vec::new())
}
}

95
src/service/onlyoffice.rs Normal file
View file

@ -0,0 +1,95 @@
use crate::image::pull_image;
use crate::service::ServiceTrait;
use crate::Result;
use bollard::container::{Config, CreateContainerOptions, NetworkingConfig};
use bollard::models::{ContainerState, EndpointSettings, HostConfig};
use bollard::Docker;
use color_eyre::Report;
use maplit::hashmap;
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct OnlyOffice;
#[async_trait::async_trait]
impl ServiceTrait for OnlyOffice {
fn name(&self) -> &str {
"onlyoffice"
}
fn env(&self) -> &[&str] {
&[]
}
async fn spawn(&self, docker: &Docker, cloud_id: &str, network: &str) -> Result<String> {
let image = "onlyoffice/documentserver";
pull_image(docker, image).await?;
let options = Some(CreateContainerOptions {
name: self.container_name(cloud_id),
});
let config = Config {
image: Some(image),
host_config: Some(HostConfig {
network_mode: Some(network.to_string()),
..Default::default()
}),
labels: Some(hashmap! {
"haze-type" => self.name(),
"haze-cloud-id" => cloud_id
}),
networking_config: Some(NetworkingConfig {
endpoints_config: hashmap! {
network => EndpointSettings {
aliases: Some(vec![self.name().to_string()]),
..Default::default()
}
},
}),
..Default::default()
};
let id = docker.create_container(options, config).await?.id;
docker.start_container::<String>(&id, None).await?;
Ok(id)
}
fn container_name(&self, cloud_id: &str) -> String {
format!("{}-onlyoffice", cloud_id)
}
async fn start_message(&self, _docker: &Docker, _cloud_id: &str) -> Result<Option<String>> {
Ok(None)
}
fn apps(&self) -> &'static [&'static str] {
&["onlyoffice"]
}
async fn post_setup(&self, docker: &Docker, cloud_id: &str) -> Result<Vec<String>> {
let info = docker
.inspect_container(&self.container_name(cloud_id), None)
.await?;
let ip = if matches!(
info.state,
Some(ContainerState {
running: Some(true),
..
})
) {
info.network_settings
.unwrap()
.networks
.unwrap()
.values()
.next()
.unwrap()
.ip_address
.clone()
.unwrap()
} else {
return Err(Report::msg("onlyoffice not started"));
};
Ok(vec![format!(
"occ config:app:set onlyoffice DocumentServerUrl --value http://{}/",
ip
)])
}
}