eba4fd1
use admin::services::logs::JobLogDto;
use admin::services::queues::QueueSnapshotDto;
use admin::services::system::{
AdminEndpointDto, CountsDto, DashboardDto, DatabaseConfigDto, DependenciesDto, DependencyDto,
EmailConfigDto, FeaturesDto, GitConfigDto, HostEntryDto, ImportConfigDto, ProcessInfoDto,
RedisConfigDto, SearchConfigDto, SessionConfigDto, StorageConfigDto, SystemConfigDto,
SystemStatusDto, TrendPointDto,
};
use crate::convert::ts;
use crate::proto as pb;
pub fn status(value: SystemStatusDto) -> pb::SystemStatus {
pb::SystemStatus {
process: Some(process(value.process)),
dependencies: Some(dependencies(value.dependencies)),
features: Some(features(value.features)),
counts: Some(counts(value.counts)),
queues: value.queues.into_iter().map(queue_snapshot).collect(),
recent_failures: value.recent_failures.into_iter().map(job_log).collect(),
generated_at: ts(value.generated_at),
}
}
pub fn config(value: SystemConfigDto) -> pb::SystemConfig {
pb::SystemConfig {
version: value.version,
hosts: value.hosts.into_iter().map(host_entry).collect(),
admin: Some(admin_endpoint(value.admin)),
features: Some(features(value.features)),
search: Some(search_config(value.search)),
import: Some(import_config(value.import)),
git: Some(git_config(value.git)),
storage: Some(storage_config(value.storage)),
database: Some(database_config(value.database)),
redis: Some(redis_config(value.redis)),
session: Some(session_config(value.session)),
email: Some(email_config(value.email)),
generated_at: ts(value.generated_at),
}
}
pub fn dashboard(value: DashboardDto) -> pb::Dashboard {
pb::Dashboard {
counts: Some(counts(value.counts)),
trend: value.trend.into_iter().map(trend_point).collect(),
active_sessions: value.active_sessions,
restricted_users: value.restricted_users,
recent_failures: value.recent_failures.into_iter().map(job_log).collect(),
queues: value.queues.into_iter().map(queue_snapshot).collect(),
generated_at: ts(value.generated_at),
}
}
pub fn process(value: ProcessInfoDto) -> pb::ProcessInfo {
pb::ProcessInfo {
version: value.version,
uptime_secs: value.uptime_secs,
}
}
pub fn dependency(value: DependencyDto) -> pb::Dependency {
pb::Dependency {
ok: value.ok,
latency_ms: value.latency_ms,
detail: value.detail,
}
}
pub fn dependencies(value: DependenciesDto) -> pb::Dependencies {
pb::Dependencies {
database: Some(dependency(value.database)),
redis: Some(dependency(value.redis)),
storage: Some(dependency(value.storage)),
search: Some(dependency(value.search)),
}
}
pub fn features(value: FeaturesDto) -> pb::Features {
pb::Features {
search_enabled: value.search_enabled,
import_enabled: value.import_enabled,
email_enabled: value.email_enabled,
email_queue_enabled: value.email_queue_enabled,
}
}
pub fn counts(value: CountsDto) -> pb::Counts {
pb::Counts {
users: value.users,
active_users: value.active_users,
spaces: value.spaces,
active_spaces: value.active_spaces,
repos: value.repos,
rooms: value.rooms,
issues: value.issues,
messages: value.messages,
}
}
pub fn queue_snapshot(value: QueueSnapshotDto) -> pb::QueueSnapshot {
pb::QueueSnapshot {
name: value.name,
kind: value.kind,
enabled: value.enabled,
depth: value.depth,
queued: value.queued,
running: value.running,
failed: value.failed,
succeeded: value.succeeded,
note: value.note,
}
}
pub fn job_log(value: JobLogDto) -> pb::JobLog {
pb::JobLog {
source: value.source,
id: value.id.to_string(),
state: value.state,
error: value.error,
created_at: ts(value.created_at),
updated_at: value.updated_at.map(ts),
}
}
pub fn trend_point(value: TrendPointDto) -> pb::TrendPoint {
pb::TrendPoint {
date: value.date,
users: value.users,
spaces: value.spaces,
repos: value.repos,
}
}
pub fn host_entry(value: HostEntryDto) -> pb::HostEntry {
pb::HostEntry {
name: value.name,
enabled: value.enabled,
bind_addr: value.bind_addr,
port: value.port.map(u32::from),
}
}
pub fn admin_endpoint(value: AdminEndpointDto) -> pb::AdminEndpoint {
pb::AdminEndpoint {
enabled: value.enabled,
bind_addr: value.bind_addr,
port: u32::from(value.port),
cors_allow_origins: value.cors_allow_origins,
cors_allow_credentials: value.cors_allow_credentials,
}
}
pub fn search_config(value: SearchConfigDto) -> pb::SearchConfig {
pb::SearchConfig {
enabled: value.enabled,
index_prefix: value.index_prefix,
max_file_bytes: value.max_file_bytes as u64,
batch_size: value.batch_size as u64,
poll_interval_secs: value.poll_interval_secs,
}
}
pub fn import_config(value: ImportConfigDto) -> pb::ImportConfig {
pb::ImportConfig {
enabled: value.enabled,
allowed_hosts: value.allowed_hosts,
allow_insecure_tls: value.allow_insecure_tls,
max_concurrent_jobs: value.max_concurrent_jobs as u64,
max_repo_bytes: value.max_repo_bytes,
max_attempts: value.max_attempts,
}
}
pub fn git_config(value: GitConfigDto) -> pb::GitConfig {
pb::GitConfig {
repo_root: value.repo_root,
objects_root: value.objects_root,
max_blob_size: value.max_blob_size,
sync_topic: value.sync_topic,
sync_concurrency: value.sync_concurrency as u64,
base_url: value.base_url,
graphql_complexity_limit: value.graphql_complexity_limit,
graphql_introspection: value.graphql_introspection,
}
}
pub fn storage_config(value: StorageConfigDto) -> pb::StorageConfig {
pb::StorageConfig {
bucket: value.bucket,
region: value.region,
path_style: value.path_style,
}
}
pub fn database_config(value: DatabaseConfigDto) -> pb::DatabaseConfig {
pb::DatabaseConfig {
endpoint: value.endpoint,
host: value.host,
port: value.port.map(u32::from),
database: value.database,
ssl_mode: value.ssl_mode,
max_connections: value.max_connections,
min_connections: value.min_connections,
replica_count: value.replica_count as u64,
}
}
pub fn redis_config(value: RedisConfigDto) -> pb::RedisConfig {
pb::RedisConfig {
endpoint: value.endpoint,
mode: value.mode,
database: value.database.map(u32::from),
pool_size: value.pool_size as u64,
}
}
pub fn session_config(value: SessionConfigDto) -> pb::SessionConfig {
pb::SessionConfig {
mode: value.mode,
cookie_name: value.cookie_name,
cookie_domain: value.cookie_domain,
cookie_secure: value.cookie_secure,
cookie_same_site: value.cookie_same_site,
lifespan_secs: value.lifespan_secs,
table_name: value.table_name,
}
}
pub fn email_config(value: EmailConfigDto) -> pb::EmailConfig {
pb::EmailConfig {
enabled: value.enabled,
queue_enabled: value.queue_enabled,
smtp_host: value.smtp_host,
smtp_port: u32::from(value.smtp_port),
from_address: value.from_address,
from_name: value.from_name,
}
}