Enum Commands 

pub enum Commands {
    Init {
        api_init: ApiInit,
        api_domain: String,
        password: String,
        mfa_stored: bool,
        api_contacts: Vec<String>,
        app_domains: Vec<String>,
        privileged_domains: Option<Vec<String>>,
    },
    Api {
        api_init: ApiInit,
        app_api: AppApi,
        dedicated_ports: bool,
        openapi: bool,
        swagger: bool,
    },
    App {
        app_api: AppApi,
        project: String,
        domain_override: Option<String>,
    },
}

Variants

Init

initialize the environment for an Ordinary API server

Fields

api_init: ApiInit

api_domain: String

domain name for API console

password: String

instance user password

mfa_stored: bool

store the MFA key locally instead of copying a QR code

api_contacts: Vec<String>

contacts for the API domain cert provisioning

app_domains: Vec<String>

domains that apps can subdomain off of.

i.e. when example.com is passed, my.example.com is considered a valid app domain.

privileged_domains: Option<Vec<String>>

list of applications that have access to API server level commands (i.e. API server invite token generation)

currently intended to enable API server admins to set up a web-based registration portal.

Api

start the Ordinary API server

Fields

api_init: ApiInit

app_api: AppApi

dedicated_ports: bool

give each app its own port

openapi: bool

whether to expose the OpenAPI JSON at /openapi

Note: this will automatically be turned on when --swagger is passed.

swagger: bool

whether to expose the Swagger docs at /swagger

App

start an Ordinary Application server

Fields

app_api: AppApi

project: String

for running a standalone project. (project must already be built)

domain_override: Option<String>

use a different domain than what’s in the ordinary.json

Trait Implementations

impl Debug for Commands

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand