Struct Node 

pub struct Node {

    pub uuid: Uuid,
    pub location: Location,
    pub backup_configuration: Option<Fetchable<BackupConfiguration>>,
    pub name: CompactString,
    pub description: Option<CompactString>,
    pub deployment_enabled: bool,
    pub maintenance_enabled: bool,
    pub public_url: Option<Url>,
    pub url: Url,
    pub sftp_host: Option<CompactString>,
    pub sftp_port: i32,
    pub memory: i64,
    pub disk: i64,
    pub token_id: CompactString,
    pub token: EncryptedString,
    pub created: NaiveDateTime,
    /* private fields */
}

Fields

uuid: Uuid

location: Location

backup_configuration: Option<Fetchable<BackupConfiguration>>

name: CompactString

description: Option<CompactString>

deployment_enabled: bool

maintenance_enabled: bool

public_url: Option<Url>

url: Url

sftp_host: Option<CompactString>

sftp_port: i32

memory: i64

disk: i64

token_id: CompactString

token: EncryptedString

created: NaiveDateTime

Implementations

impl Node

pub const AIO_NODE_UUID: Uuid

pub async fn by_location_uuid_with_pagination( database: &Database, location_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 by_location_uuids_most_eligible( database: &Database, location_uuids: &[Uuid], limits: AdminApiServerLimits, allow_overallocation: bool, suspension_penalty: f64, randomness: f64, ) -> Result<Vec<Self>, DatabaseError>

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

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

pub async fn find_deployment_blocker( database: &Database, location_uuids: &[Uuid], limits: AdminApiServerLimits, allow_overallocation: bool, suspension_penalty: f64, ) -> Result<Option<NodeDeploymentBlocker>, DatabaseError>

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

Fetch the current configuration of this node

Cached for 120 seconds.

pub async fn update_configuration( &self, database: &Database, config_patch: &Value, ) -> Result<bool, Error>

Update the configuration of this node

Invalidates the cached configuration.

pub async fn fetch_server_resources( &self, database: &Database, ) -> Result<HashMap<Uuid, ResourceUsage>, Error>

Fetch the current resource usages of all servers on this node.

Cached for 15 seconds.

pub fn generate_token() -> (String, String)

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

pub async fn reset_token_if_unchanged( &self, state: &State, expected_token_id: &str, ) -> Result<Option<(String, String)>, Error>

Rotates the token only while the node still has expected_token_id, so a token handed out once (e.g. through an enrollment code) cannot be claimed twice.

pub fn is_all_in_one_node(&self) -> bool

pub fn url(&self, path: &str) -> Url

pub async fn public_url( &self, state: &State, request_host: Option<&str>, path: &str, ) -> Result<Url, Error>

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

pub fn invalidate_permissions( &self, database: &Arc<Database>, invalidation: PermissionsInvalidation, )

Tells wings that permissions changed: live sessions continue with their new permissions and only those that lost access end. Must run after the change is committed. Nodes that predate invalidation end the affected users’ sessions instead. Runs in the background, failures are only logged.

pub fn invalidate_permissions_everywhere( database: &Arc<Database>, invalidation: PermissionsInvalidation, )

Self::invalidate_permissions on every node.

pub async fn fetch_firewall_support(&self, database: &Database) -> Option<bool>

Whether this node will enforce firewall rules, None when its configuration could not be retrieved in time. False covers both a node that cannot firewall at all and one with firewalling turned off, so the reason stays out of the client API.

pub async fn fetch_allowed_sources( &self, database: &Database, ) -> Option<NodeAllowedSources>

The node’s allowed_mounts / allowed_devices, None when its configuration could not be retrieved in time.

pub async fn bandwidth_status(&self, database: &Database) -> BandwidthStatus

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

pub async fn fetch_tunnel_status( &self, database: &Database, ) -> Option<TundraStatus>

What the node reports about its mesh daemon, None when it could not be reached in time. Not cached: the panel shows it live on the node page.

pub async fn used_ports( &self, state: &State, ips: &[IpAddr], ) -> Result<HashMap<IpAddr, Vec<u16>>, Error>

pub async fn create_jwt<T: Serialize>( &self, database: &Database, jwt: &Jwt, payload: &T, ) -> Result<String, Error>

Trait Implementations

impl BaseModel for Node

const NAME: &'static str = "node"

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 cache_invalidation_keys(&self) -> Vec<CompactString>

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 Node

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>>

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

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

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CreatableModel for Node

type CreateOptions<'a> = CreateNodeOptions

type CreateResult = Node

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 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,

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

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

impl DeletableModel for Node

type DeleteOptions = ()

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 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,

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,

impl<'de> Deserialize<'de> for Node

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DuplicableModel for Node

type DuplicateOptions<'a> = DuplicateNodeOptions

type DuplicateResult = Node

fn get_duplicate_handlers() -> &'static LazyLock<DuplicateHandlerList<Self>>

fn duplicate_with_transaction<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, state: &'life1 State, options: Self::DuplicateOptions<'life2>, transaction: &'life3 mut Transaction<'life4, 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, 'life4: 'async_trait,

fn register_duplicate_handler<F: for<'a> Fn(&'a Self, &'a Self::DuplicateOptions<'_>, &'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_duplicate_handler<F: for<'a> Fn(&'a Self, &'a mut Self::DuplicateResult, &'a Self::DuplicateOptions<'_>, &'a State, &'a mut Transaction<'_, Postgres>) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'a>> + Send + Sync + 'static>( priority: ListenerPriority, callback: F, )

fn run_duplicate_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, options: &'life1 Self::DuplicateOptions<'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,

fn run_after_duplicate_handlers<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>( &'life0 self, duplicated: &'life1 mut Self::DuplicateResult, options: &'life2 Self::DuplicateOptions<'life3>, state: &'life4 State, transaction: &'life5 mut Transaction<'life6, 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, 'life6: 'async_trait,

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

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

impl EventEmittingModel for Node

type Event = NodeEvent

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 Node

type AdminApiObject = AdminApiNode

type ExtraArgs<'a> = ()

fn into_admin_api_object<'a, 'life0, 'async_trait>( self, state: &'life0 State, _args: 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 ResolvableModel for Node

type Fingerprint = EncryptedString

fn uuid(&self) -> Uuid

fn fingerprint(&self) -> Self::Fingerprint

fn resolve<'life0, 'life1, 'async_trait>( database: &'life0 Database, identifier: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'async_trait>>

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

fn resolve_cached<'life0, 'life1, 'async_trait>( database: &'life0 Database, identifier: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'async_trait>>

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

impl Serialize for Node

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 Node

type UpdateOptions = UpdateNodeOptions

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,