pub mod run_machine_action_request {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Action {
AddSshKey(::buffa::alloc::boxed::Box<super::super::super::SshKey>),
RemoveSshKeyFingerprint(::buffa::alloc::string::String),
RestartMachine(
::buffa::alloc::boxed::Box<super::super::super::RestartMachineAction>,
),
CancelRestart(bool),
EndSessionId(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Action {}
impl From<super::super::super::SshKey> for Action {
fn from(v: super::super::super::SshKey) -> Self {
Self::AddSshKey(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::SshKey> for ::core::option::Option<Action> {
fn from(v: super::super::super::SshKey) -> Self {
Self::Some(Action::from(v))
}
}
impl From<super::super::super::RestartMachineAction> for Action {
fn from(v: super::super::super::RestartMachineAction) -> Self {
Self::RestartMachine(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::RestartMachineAction>
for ::core::option::Option<Action> {
fn from(v: super::super::super::RestartMachineAction) -> Self {
Self::Some(Action::from(v))
}
}
impl ::serde::Serialize for Action {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::AddSshKey(v) => {
map.serialize_entry("add_ssh_key", &**v)?;
}
Self::RemoveSshKeyFingerprint(v) => {
map.serialize_entry("remove_ssh_key_fingerprint", v)?;
}
Self::RestartMachine(v) => {
map.serialize_entry("restart_machine", &**v)?;
}
Self::CancelRestart(v) => {
map.serialize_entry("cancel_restart", v)?;
}
Self::EndSessionId(v) => {
map.serialize_entry("end_session_id", v)?;
}
}
map.end()
}
}
}
pub mod project_source {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Kind {
Files(bool),
Github(::buffa::alloc::boxed::Box<super::super::super::GithubSource>),
}
impl ::buffa::Oneof for Kind {}
impl From<super::super::super::GithubSource> for Kind {
fn from(v: super::super::super::GithubSource) -> Self {
Self::Github(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::GithubSource> for ::core::option::Option<Kind> {
fn from(v: super::super::super::GithubSource) -> Self {
Self::Some(Kind::from(v))
}
}
impl ::serde::Serialize for Kind {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::Files(v) => {
map.serialize_entry("files", v)?;
}
Self::Github(v) => {
map.serialize_entry("github", &**v)?;
}
}
map.end()
}
}
}
pub mod deploy_project_request {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Version {
UploadId(::buffa::alloc::string::String),
Commit(::buffa::alloc::string::String),
NewestCommit(bool),
RollbackDeployId(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Version {}
impl ::serde::Serialize for Version {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::UploadId(v) => {
map.serialize_entry("upload_id", v)?;
}
Self::Commit(v) => {
map.serialize_entry("commit", v)?;
}
Self::NewestCommit(v) => {
map.serialize_entry("newest_commit", v)?;
}
Self::RollbackDeployId(v) => {
map.serialize_entry("rollback_deploy_id", v)?;
}
}
map.end()
}
}
}
pub mod file_change {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Change {
Text(::buffa::alloc::string::String),
Data(::buffa::alloc::vec::Vec<u8>),
MakeDirectory(bool),
Delete(bool),
DeleteTree(bool),
RenameTo(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Change {}
impl ::serde::Serialize for Change {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::Text(v) => {
map.serialize_entry("text", v)?;
}
Self::Data(v) => {
map.serialize_entry("data", &::buffa::json_helpers::ProtoJson(v))?;
}
Self::MakeDirectory(v) => {
map.serialize_entry("make_directory", v)?;
}
Self::Delete(v) => {
map.serialize_entry("delete", v)?;
}
Self::DeleteTree(v) => {
map.serialize_entry("delete_tree", v)?;
}
Self::RenameTo(v) => {
map.serialize_entry("rename_to", v)?;
}
}
map.end()
}
}
}
pub mod run_project_action_request {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Action {
StartServices(::buffa::alloc::boxed::Box<super::super::super::ServicesAction>),
StopServices(::buffa::alloc::boxed::Box<super::super::super::ServicesAction>),
RestartServices(::buffa::alloc::boxed::Box<super::super::super::ServicesAction>),
RecreateService(
::buffa::alloc::boxed::Box<super::super::super::RecreateServiceAction>,
),
BackUp(::buffa::alloc::boxed::Box<super::super::super::BackUpAction>),
RestoreSnapshot(
::buffa::alloc::boxed::Box<super::super::super::RestoreSnapshotAction>,
),
CancelOperation(
::buffa::alloc::boxed::Box<super::super::super::CancelOperationAction>,
),
DeleteProject(
::buffa::alloc::boxed::Box<super::super::super::DeleteProjectAction>,
),
SetSource(::buffa::alloc::boxed::Box<super::super::super::ProjectSource>),
DeleteVolume(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Action {}
impl From<super::super::super::RecreateServiceAction> for Action {
fn from(v: super::super::super::RecreateServiceAction) -> Self {
Self::RecreateService(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::RecreateServiceAction>
for ::core::option::Option<Action> {
fn from(v: super::super::super::RecreateServiceAction) -> Self {
Self::Some(Action::from(v))
}
}
impl From<super::super::super::BackUpAction> for Action {
fn from(v: super::super::super::BackUpAction) -> Self {
Self::BackUp(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::BackUpAction> for ::core::option::Option<Action> {
fn from(v: super::super::super::BackUpAction) -> Self {
Self::Some(Action::from(v))
}
}
impl From<super::super::super::RestoreSnapshotAction> for Action {
fn from(v: super::super::super::RestoreSnapshotAction) -> Self {
Self::RestoreSnapshot(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::RestoreSnapshotAction>
for ::core::option::Option<Action> {
fn from(v: super::super::super::RestoreSnapshotAction) -> Self {
Self::Some(Action::from(v))
}
}
impl From<super::super::super::CancelOperationAction> for Action {
fn from(v: super::super::super::CancelOperationAction) -> Self {
Self::CancelOperation(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::CancelOperationAction>
for ::core::option::Option<Action> {
fn from(v: super::super::super::CancelOperationAction) -> Self {
Self::Some(Action::from(v))
}
}
impl From<super::super::super::DeleteProjectAction> for Action {
fn from(v: super::super::super::DeleteProjectAction) -> Self {
Self::DeleteProject(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::DeleteProjectAction>
for ::core::option::Option<Action> {
fn from(v: super::super::super::DeleteProjectAction) -> Self {
Self::Some(Action::from(v))
}
}
impl From<super::super::super::ProjectSource> for Action {
fn from(v: super::super::super::ProjectSource) -> Self {
Self::SetSource(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::ProjectSource> for ::core::option::Option<Action> {
fn from(v: super::super::super::ProjectSource) -> Self {
Self::Some(Action::from(v))
}
}
impl ::serde::Serialize for Action {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::StartServices(v) => {
map.serialize_entry("start_services", &**v)?;
}
Self::StopServices(v) => {
map.serialize_entry("stop_services", &**v)?;
}
Self::RestartServices(v) => {
map.serialize_entry("restart_services", &**v)?;
}
Self::RecreateService(v) => {
map.serialize_entry("recreate_service", &**v)?;
}
Self::BackUp(v) => {
map.serialize_entry("back_up", &**v)?;
}
Self::RestoreSnapshot(v) => {
map.serialize_entry("restore_snapshot", &**v)?;
}
Self::CancelOperation(v) => {
map.serialize_entry("cancel_operation", &**v)?;
}
Self::DeleteProject(v) => {
map.serialize_entry("delete_project", &**v)?;
}
Self::SetSource(v) => {
map.serialize_entry("set_source", &**v)?;
}
Self::DeleteVolume(v) => {
map.serialize_entry("delete_volume", v)?;
}
}
map.end()
}
}
}
pub mod read_path_request {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Root {
Service(::buffa::alloc::string::String),
Volume(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Root {}
impl ::serde::Serialize for Root {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::Service(v) => {
map.serialize_entry("service", v)?;
}
Self::Volume(v) => {
map.serialize_entry("volume", v)?;
}
}
map.end()
}
}
}
pub mod create_transfer_request {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Transfer {
UploadArchive(::buffa::alloc::boxed::Box<super::super::super::ArchiveUpload>),
UploadFile(::buffa::alloc::boxed::Box<super::super::super::FileUpload>),
Download(::buffa::alloc::boxed::Box<super::super::super::PathDownload>),
}
impl ::buffa::Oneof for Transfer {}
impl From<super::super::super::ArchiveUpload> for Transfer {
fn from(v: super::super::super::ArchiveUpload) -> Self {
Self::UploadArchive(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::ArchiveUpload> for ::core::option::Option<Transfer> {
fn from(v: super::super::super::ArchiveUpload) -> Self {
Self::Some(Transfer::from(v))
}
}
impl From<super::super::super::FileUpload> for Transfer {
fn from(v: super::super::super::FileUpload) -> Self {
Self::UploadFile(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::FileUpload> for ::core::option::Option<Transfer> {
fn from(v: super::super::super::FileUpload) -> Self {
Self::Some(Transfer::from(v))
}
}
impl From<super::super::super::PathDownload> for Transfer {
fn from(v: super::super::super::PathDownload) -> Self {
Self::Download(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::PathDownload> for ::core::option::Option<Transfer> {
fn from(v: super::super::super::PathDownload) -> Self {
Self::Some(Transfer::from(v))
}
}
impl ::serde::Serialize for Transfer {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::UploadArchive(v) => {
map.serialize_entry("upload_archive", &**v)?;
}
Self::UploadFile(v) => {
map.serialize_entry("upload_file", &**v)?;
}
Self::Download(v) => {
map.serialize_entry("download", &**v)?;
}
}
map.end()
}
}
}
pub mod file_upload {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Root {
Service(::buffa::alloc::string::String),
Volume(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Root {}
impl ::serde::Serialize for Root {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::Service(v) => {
map.serialize_entry("service", v)?;
}
Self::Volume(v) => {
map.serialize_entry("volume", v)?;
}
}
map.end()
}
}
}
pub mod path_download {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Root {
Service(::buffa::alloc::string::String),
Volume(::buffa::alloc::string::String),
}
impl ::buffa::Oneof for Root {}
impl ::serde::Serialize for Root {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::Service(v) => {
map.serialize_entry("service", v)?;
}
Self::Volume(v) => {
map.serialize_entry("volume", v)?;
}
}
map.end()
}
}
}
pub mod watch_operation_response {
#[allow(unused_imports)]
use super::*;
#[derive(Clone, PartialEq, Debug)]
pub enum Message {
Log(::buffa::alloc::boxed::Box<super::super::super::OperationLogLine>),
FinishedOperation(::buffa::alloc::boxed::Box<super::super::super::Operation>),
}
impl ::buffa::Oneof for Message {}
impl From<super::super::super::OperationLogLine> for Message {
fn from(v: super::super::super::OperationLogLine) -> Self {
Self::Log(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::OperationLogLine>
for ::core::option::Option<Message> {
fn from(v: super::super::super::OperationLogLine) -> Self {
Self::Some(Message::from(v))
}
}
impl From<super::super::super::Operation> for Message {
fn from(v: super::super::super::Operation) -> Self {
Self::FinishedOperation(::buffa::alloc::boxed::Box::new(v))
}
}
impl From<super::super::super::Operation> for ::core::option::Option<Message> {
fn from(v: super::super::super::Operation) -> Self {
Self::Some(Message::from(v))
}
}
impl ::serde::Serialize for Message {
fn serialize<S: ::serde::Serializer>(
&self,
s: S,
) -> ::core::result::Result<S::Ok, S::Error> {
use ::serde::ser::SerializeMap;
let mut map = s.serialize_map(Some(1))?;
match self {
Self::Log(v) => {
map.serialize_entry("log", &**v)?;
}
Self::FinishedOperation(v) => {
map.serialize_entry("finished_operation", &**v)?;
}
}
map.end()
}
}
}