Struct Server 

pub struct Server {

    pub uuid: Uuid,
    pub uuid_short: i32,
    pub external_id: Option<CompactString>,
    pub allocation: Option<ServerAllocation>,
    pub destination_allocation_uuid: Option<Uuid>,
    pub node: Fetchable<Node>,
    pub destination_node: Option<Fetchable<Node>>,
    pub owner: User,
    pub egg: Box<NestEgg>,
    pub nest: Box<Nest>,
    pub backup_configuration: Option<Fetchable<BackupConfiguration>>,
    pub status: Option<ServerStatus>,
    pub suspended: bool,
    pub name: CompactString,
    pub description: Option<CompactString>,
    pub memory: i64,
    pub memory_overhead: i64,
    pub swap: i64,
    pub disk: i64,
    pub io_weight: Option<i16>,
    pub cpu: i32,
    pub pinned_cpus: Vec<i16>,
    pub startup: CompactString,
    pub image: CompactString,
    pub auto_kill: ServerConfigurationAutoKill,
    pub auto_start_behavior: ServerAutoStartBehavior,
    pub timezone: Option<CompactString>,
    pub hugepages_passthrough_enabled: bool,
    pub kvm_passthrough_enabled: bool,
    pub allocation_limit: i32,
    pub database_limit: i32,
    pub backup_limit: i32,
    pub schedule_limit: i32,
    pub subuser_permissions: Option<Arc<Vec<CompactString>>>,
    pub subuser_ignored_files: Option<Vec<CompactString>>,
    pub created: NaiveDateTime,
    /* private fields */
}

Fields

uuid: Uuid

uuid_short: i32

external_id: Option<CompactString>

allocation: Option<ServerAllocation>

destination_allocation_uuid: Option<Uuid>

node: Fetchable<Node>

destination_node: Option<Fetchable<Node>>

owner: User

egg: Box<NestEgg>

nest: Box<Nest>

backup_configuration: Option<Fetchable<BackupConfiguration>>

status: Option<ServerStatus>

suspended: bool

name: CompactString

description: Option<CompactString>

memory: i64

memory_overhead: i64

swap: i64

disk: i64

io_weight: Option<i16>

cpu: i32

pinned_cpus: Vec<i16>

startup: CompactString

image: CompactString

auto_kill: ServerConfigurationAutoKill

auto_start_behavior: ServerAutoStartBehavior

timezone: Option<CompactString>

hugepages_passthrough_enabled: bool

kvm_passthrough_enabled: bool

allocation_limit: i32

database_limit: i32

backup_limit: i32

schedule_limit: i32

subuser_permissions: Option<Arc<Vec<CompactString>>>

subuser_ignored_files: Option<Vec<CompactString>>

created: NaiveDateTime

Implementations

impl Server

pub async fn by_node_uuid_uuid( database: &Database, node_uuid: Uuid, uuid: Uuid, ) -> Result<Option<Self>, DatabaseError>

pub async fn by_external_id( database: &Database, external_id: &str, ) -> Result<Option<Self>, DatabaseError>

pub async fn by_identifier( database: &Database, identifier: &str, ) -> Result<Option<Self>, DatabaseError>

pub async fn by_user_identifier( database: &Database, user: &User, identifier: &str, ) -> Result<Option<Self>, Error>

Get a server by its identifier, ensuring the user has access to it.

Cached for 5 seconds.

pub async fn by_owner_uuid_with_pagination( database: &Database, owner_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_user_uuid_server_order_with_pagination( database: &Database, user: &User, server_order: &[Uuid], page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_user_uuid_with_pagination( database: &Database, user_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn all_uuids_by_node_uuid_user_uuid( database: &Database, node_uuid: Uuid, user_uuid: Uuid, ) -> Result<Vec<Uuid>, DatabaseError>

pub async fn by_not_user_uuid_with_pagination( database: &Database, user_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_node_uuid_with_pagination( database: &Database, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_node_uuid_transferring_with_pagination( database: &Database, node_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_egg_uuid_with_pagination( database: &Database, egg_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn by_backup_configuration_uuid_with_pagination( database: &Database, backup_configuration_uuid: Uuid, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn all_with_pagination( database: &Database, page: i64, per_page: i64, search: Option<&str>, ) -> Result<Pagination<Self>, DatabaseError>

pub async fn count_by_user_uuid( database: &Database, user_uuid: Uuid, ) -> Result<i64, Error>

pub async fn count_by_node_uuid( database: &Database, node_uuid: Uuid, ) -> Result<i64, Error>

pub async fn count_by_egg_uuid( database: &Database, egg_uuid: Uuid, ) -> Result<i64, Error>

pub async fn fetch_status( &self, database: &Database, ) -> Result<Option<ServerStatus>, DatabaseError>

Fetches the current status of the server from the database. This is the most up-to-date status, as opposed to the potentially cached status in the Server struct.

pub async fn try_set_status_by_uuid( executor: impl Executor<'_, Database = Postgres>, uuid: Uuid, from: Option<ServerStatus>, to: Option<ServerStatus>, ) -> Result<bool, Error>

Atomically moves the server from the from status to the to status, returning false if the server was not in the from status and nothing was changed.

pub async fn set_status( &mut self, executor: impl Executor<'_, Database = Postgres>, status: Option<ServerStatus>, ) -> Result<(), Error>

Sets the status of the server, regardless of the status it is currently in.

pub async fn try_set_status( &mut self, executor: impl Executor<'_, Database = Postgres>, from: Option<ServerStatus>, to: Option<ServerStatus>, ) -> Result<bool, Error>

Same as try_set_status_by_uuid, keeping the status on the struct in sync.

pub async fn sync(self, database: &Database) -> Result<(), Error>

Syncs the server with the node. This will update server resources, schedules, name, etc.

pub async fn batch_sync(self, database: &Arc<Database>)

Same as sync but runs in a background task, is deduplicated and is not awaited. Any errors will be logged but not returned.

This method is meant to be used in 90% of cases where you want to sync the server with low priority.

pub async fn install( &self, state: &State, truncate_directory: bool, installation_script: Option<InstallationScript>, ) -> Result<(), Error>

Triggers a re-installation of the server on the node. This will only work if the server is in a state that allows re-installation. (None status) If this is not the case, a DisplayError will be returned.

pub async fn transfer( self, state: &State, options: ServerTransferOptions, ) -> Result<(), Error>

Triggers a transfer of the server to another node. This will only work if the server is not currently installing or restoring a backup. If this is not the case, a DisplayError will be returned.

pub fn wings_permissions<'a>( &'a self, settings: &AppSettings, user: &User, auth: Option<&'a GetAuthMethod>, ) -> Vec<&'a str>

pub fn wings_subuser_permissions<'a>( &self, settings: &AppSettings, subuser: &'a ServerSubuser, auth: Option<&'a GetAuthMethod>, ) -> Vec<&'a str>

pub async fn feature_limits( &self, state: &State, ) -> Result<ApiServerFeatureLimits, Error>

Gets the feature limits for the server, useful in case you need to loop over them or want to pass them to the frontend individually.

pub async fn backup_configuration( &self, database: &Database, ) -> Option<BackupConfiguration>

pub fn is_ignored(&mut self, path: impl AsRef<Path>, is_dir: bool) -> bool

pub async fn into_remote_api_object( self, database: &Database, ) -> Result<RemoteApiServer, Error>

Trait Implementations

impl BaseModel for Server

const NAME: &'static str = "server"

fn get_extension_list() -> &'static ModelExtensionList

fn get_extension_data(&self) -> &ModelExtensionData

fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, CompactString>

fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, DatabaseError>

fn register_model_extension( extension: impl ModelExtension + Send + Sync + 'static, )

Registers a model extension. If an extension with the same name is already registered, this function will do nothing.

fn parse_model_extension<Extension: SafeModelExtension>( &self, ) -> Result<Extension::Value, DatabaseError>

where Extension::Value: Serialize + DeserializeOwned,

Parses a model extension from the model’s extension data. If the extension is not found, or if the data cannot be deserialized, an error is returned.

fn columns(prefix: Option<&str>) -> BTreeMap<&'static str, CompactString>

fn columns_sql(prefix: Option<&str>) -> CompactString

fn map_extensions( prefix: &str, row: &PgRow, ) -> Result<ModelExtensionData, DatabaseError>

impl ByUuid for Server

fn by_uuid<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn by_uuid_with_transaction<'life0, 'life1, 'async_trait>( transaction: &'life0 mut Transaction<'life1, Postgres>, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn by_uuid_cached<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn by_uuid_optional<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, DatabaseError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn by_uuid_optional_with_transaction<'life0, 'life1, 'async_trait>( transaction: &'life0 mut Transaction<'life1, Postgres>, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, DatabaseError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn by_uuid_optional_cached<'life0, 'async_trait>( database: &'life0 Database, uuid: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn get_fetchable(uuid: Uuid) -> Fetchable<Self>

fn get_fetchable_from_row( row: &PgRow, column: impl AsRef<str>, ) -> Option<Fetchable<Self>>

impl Clone for Server

fn clone(&self) -> Server

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CreatableModel for Server

type CreateOptions<'a> = CreateServerOptions

type CreateResult = Server

fn get_create_handlers() -> &'static LazyLock<CreateListenerList<Self>>

fn create_with_transaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( _state: &'life0 State, _options: Self::CreateOptions<'life1>, _transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn create<'life0, 'life1, 'async_trait>( state: &'life0 State, options: Self::CreateOptions<'life1>, ) -> Pin<Box<dyn Future<Output = Result<Self, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn register_create_handler<F: for<'a> Fn(&'a mut Self::CreateOptions<'_>, &'a mut InsertQueryBuilder<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn register_after_create_handler<F: for<'a> Fn(&'a mut Self::CreateResult, &'a Self::CreateOptions<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_create_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( options: &'life0 mut Self::CreateOptions<'life1>, query_builder: &'life2 mut InsertQueryBuilder<'_>, state: &'life3 State, transaction: &'life4 mut Transaction<'life5, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

fn run_after_create_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( result: &'life0 mut Self::CreateResult, options: &'life1 Self::CreateOptions<'life2>, state: &'life3 State, transaction: &'life4 mut Transaction<'life5, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

impl DeletableModel for Server

type DeleteOptions = DeleteServerOptions

fn get_delete_handlers() -> &'static LazyLock<DeleteHandlerList<Self>>

fn delete_with_transaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _state: &'life1 State, _options: Self::DeleteOptions, _transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 State, options: Self::DeleteOptions, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn register_delete_handler<F: for<'a> Fn(&'a Self, &'a Self::DeleteOptions, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn register_after_delete_handler<F: for<'a> Fn(&'a Self, &'a Self::DeleteOptions, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_delete_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, options: &'life1 Self::DeleteOptions, state: &'life2 State, transaction: &'life3 mut Transaction<'life4, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn run_after_delete_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, options: &'life1 Self::DeleteOptions, state: &'life2 State, transaction: &'life3 mut Transaction<'life4, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

impl<'de> Deserialize<'de> for Server

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventEmittingModel for Server

type Event = ServerEvent

fn get_event_emitter() -> &'static EventEmitter<Self::Event>

fn register_event_handler<F: Fn(State, Arc<Self::Event>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), Error>> + Send + 'static>( listener: F, ) -> EventHandlerHandle

impl IntoAdminApiObject for Server

type AdminApiObject = AdminApiServer

type ExtraArgs<'a> = &'a StorageUrlRetriever<'a>

fn into_admin_api_object<'a, 'life0, 'async_trait>( self, state: &'life0 State, storage_url_retriever: Self::ExtraArgs<'a>, ) -> Pin<Box<dyn Future<Output = Result<Self::AdminApiObject, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

impl IntoApiObject for Server

type ApiObject = ApiServer

type ExtraArgs<'a> = &'a User

fn into_api_object<'a, 'life0, 'async_trait>( self, state: &'life0 State, user: Self::ExtraArgs<'a>, ) -> Pin<Box<dyn Future<Output = Result<Self::ApiObject, DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

impl Serialize for Server

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UpdatableModel for Server

type UpdateOptions = UpdateServerOptions

fn get_update_handlers() -> &'static LazyLock<UpdateHandlerList<Self>>

fn update_with_transaction<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, state: &'life1 State, options: Self::UpdateOptions, transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn register_update_handler<F: for<'a> Fn(&'a mut Self, &'a mut Self::UpdateOptions, &'a mut UpdateQueryBuilder<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn register_after_update_handler<F: for<'a> Fn(&'a mut Self, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_update_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 mut self, options: &'life1 mut Self::UpdateOptions, query_builder: &'life2 mut UpdateQueryBuilder<'_>, state: &'life3 State, transaction: &'life4 mut Transaction<'life5, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

fn run_after_update_handlers<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, state: &'life1 State, transaction: &'life2 mut Transaction<'life3, Postgres>, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn update<'life0, 'life1, 'async_trait>( &'life0 mut self, state: &'life1 State, options: Self::UpdateOptions, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,