Struct hrobot::AsyncRobot

impl AsyncRobot

pub async fn list_storageboxes(&self) -> Result<Vec<StorageBoxReference>, Error>

List all storageboxes associated with this account.

Note that this function returns a truncated version of the StorageBox which does not contain disk usage and service accessibility information.

pub async fn get_storagebox( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Get a single storagebox.

pub async fn rename_storagebox( &self, id: StorageBoxId, name: &str ) -> Result<StorageBox, Error>

Rename storagebox.

pub async fn configure_storagebox_accessibility( &self, id: StorageBoxId, accessibility: Accessibility ) -> Result<StorageBox, Error>

Configure storagebox accessibility.

pub async fn enable_storagebox_samba( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Enable Samba (SMB) access to the storagebox.

pub async fn disable_storagebox_samba( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Disable Samba (SMB) access to the storagebox.

pub async fn enable_storagebox_webdav( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Enable WebDAV access to the storagebox.

pub async fn disable_storagebox_webdav( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Disable WebDAV access to the storagebox.

pub async fn enable_storagebox_ssh( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Enable SSH access to the storagebox.

pub async fn disable_storagebox_ssh( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Disable SSH access to the storagebox.

pub async fn enable_storagebox_external_reachability( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Enable external reachability for the storagebox.

External reachability means that the enabled services are reachable outside of Hetzner’s networks. Without this enabled, you won’t be able to log into the storagebox from anything other than Hetzner Cloud or Hetzner’s Dedicated Servers.

Example

let robot = hrobot::AsyncRobot::default();
robot.enable_storagebox_external_reachability(StorageBoxId(1234)).await.unwrap();

pub async fn disable_storagebox_external_reachability( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Disable external reachability for to the storagebox.

External reachability means that the enabled services are reachable outside of Hetzner’s networks. Without this enabled, you won’t be able to log into the storagebox from anything other than Hetzner Cloud or Hetzner’s Dedicated Servers.

Example

let robot = hrobot::AsyncRobot::default();
robot.disable_storagebox_external_reachability(StorageBoxId(1234)).await.unwrap();

pub async fn enable_storagebox_snapshot_directory( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Enable snapshot directory visibility for the storagebox.

When enabled, mounts a directory containing storage box snapshots in /.zfs or /home/.zfs depending on access method.

Example

let robot = hrobot::AsyncRobot::default();
robot.enable_storagebox_snapshot_directory(StorageBoxId(1234)).await.unwrap();

pub async fn disable_storagebox_snapshot_directory( &self, id: StorageBoxId ) -> Result<StorageBox, Error>

Disable snapshot directory visibility for the storagebox.

When enabled, mounts a directory containing storage box snapshots in /.zfs or /home/.zfs depending on access method.

Example

let robot = hrobot::AsyncRobot::default();
robot.disable_storagebox_snapshot_directory(StorageBoxId(1234)).await.unwrap();

pub async fn reset_storagebox_password( &self, id: StorageBoxId ) -> Result<String, Error>

Reset storagebox password, returning the new password.

Example

let robot = hrobot::AsyncRobot::default();
robot.reset_storagebox_password(StorageBoxId(1234)).await.unwrap();

pub async fn list_snapshots( &self, id: StorageBoxId ) -> Result<Vec<Snapshot>, Error>

List snapshots for storagebox.

Example

let robot = hrobot::AsyncRobot::default();
robot.list_snapshots(StorageBoxId(1234)).await.unwrap();

pub async fn create_snapshot( &self, id: StorageBoxId ) -> Result<CreatedSnapshot, Error>

Create a new snapshot of the storagebox.

Example

let robot = hrobot::AsyncRobot::default();
robot.create_snapshot(StorageBoxId(1234)).await.unwrap();

pub async fn delete_snapshot( &self, id: StorageBoxId, snapshot_name: &str ) -> Result<(), Error>

Delete a snapshot of the storagebox.

Snapshots are named after the timestamp at which they are created with an implicit timezone of UTC. The safest way to target a snapshot for deletion, is to first retrieve it, and use its name from there.

If you otherwise know the timestamp, but not the name of the snapshot, you can format it as “YYYY-MM-DDThh-mm-ss”, with an assumed UTC timezone.

Example

let robot = hrobot::AsyncRobot::default();
robot.delete_snapshot(
    StorageBoxId(1234),
    "2015-12-21T13-13-03"
).await.unwrap();

pub async fn revert_to_snapshot( &self, id: StorageBoxId, snapshot_name: &str ) -> Result<(), Error>

Revert storagebox to a snapshot.

Example

let robot = hrobot::AsyncRobot::default();
robot.revert_to_snapshot(
    StorageBoxId(1234),
    "2015-12-21T13-13-03"
).await.unwrap();

pub async fn change_snapshot_comment( &self, id: StorageBoxId, snapshot_name: &str, comment: &str ) -> Result<(), Error>

Change snapshot comment.

Example

let robot = hrobot::AsyncRobot::default();
robot.change_snapshot_comment(
    StorageBoxId(1234),
    "2015-12-21T13-13-03",
    "Last backup before upgrade to 2.0"
).await.unwrap();

pub async fn get_snapshot_plan( &self, id: StorageBoxId ) -> Result<SnapshotPlan, Error>

Update snapshot plan for storagebox

Example

let robot = hrobot::AsyncRobot::default();
robot.get_snapshot_plan(StorageBoxId(1234)).await.unwrap();

pub async fn update_snapshot_plan( &self, id: StorageBoxId, plan: SnapshotPlan ) -> Result<SnapshotPlan, Error>

Update snapshot plan.

Example

let robot = hrobot::AsyncRobot::default();
robot.update_snapshot_plan(
    StorageBoxId(1234),
    SnapshotPlan::weekly(Weekday::Monday, 10, 0)
).await.unwrap();

pub async fn list_subaccounts( &self, id: StorageBoxId ) -> Result<Vec<Subaccount>, Error>

List sub-accounts for storagebox.

Example

let robot = hrobot::AsyncRobot::default();
robot.list_subaccounts(StorageBoxId(1234)).await.unwrap();

pub async fn create_subaccount( &self, storagebox: StorageBoxId, home_directory: &str, accessibility: Accessibility, permissions: Permission, comment: Option<&str> ) -> Result<CreatedSubaccount, Error>

Create sub-account.

Example

let robot = hrobot::AsyncRobot::default();
robot.create_subaccount(
    StorageBoxId(1234),
    "/home/test-user",
    Accessibility::default(), // default disables all access.
    Permission::ReadOnly,
    None
).await.unwrap();

pub async fn set_subaccount_home_directory( &self, storagebox: StorageBoxId, subaccount: &SubaccountId, home_directory: &str ) -> Result<(), Error>

Change home directory of storagebox sub-account

Example

let robot = hrobot::AsyncRobot::default();
robot.set_subaccount_home_directory(
    StorageBoxId(1234),
    &SubaccountId("u1234-sub1".to_string()),
    "/homedirs/sub1"
).await.unwrap();

pub async fn update_subaccount( &self, storagebox: StorageBoxId, subaccount: &SubaccountId, home_directory: &str, accessibility: Option<&Accessibility>, permissions: Option<Permission>, comment: Option<&str> ) -> Result<(), Error>

Change sub-account comment/description.

Example

let robot = hrobot::AsyncRobot::default();
robot.update_subaccount(
    StorageBoxId(1234),
    &SubaccountId("u1234-sub1".to_string()),
    "/new/home/dir",
    None, // Keep old accessibility options
    Some(Permission::ReadWrite),
    Some("Sub-account used for accessing backups")
).await.unwrap();

pub async fn reset_subaccount_password( &self, storagebox: StorageBoxId, subaccount: &SubaccountId ) -> Result<String, Error>

Reset sub-account password.

Example

let robot = hrobot::AsyncRobot::default();
let password = robot.reset_subaccount_password(
    StorageBoxId(1234),
    &SubaccountId("u1234-sub1".to_string()),
).await.unwrap();

println!("new password: {password}");

pub async fn delete_subaccount( &self, storagebox: StorageBoxId, subaccount: SubaccountId ) -> Result<(), Error>

Delete sub-account.

Example

let robot = hrobot::AsyncRobot::default();
robot.delete_subaccount(
    StorageBoxId(1234),
    SubaccountId("u1234-sub1".to_string()),
).await.unwrap();

impl AsyncRobot

pub async fn list_subnets( &self ) -> Result<HashMap<ServerId, Vec<Subnet>>, Error>

List all subnets, grouped by server they are assigned to.

Example

let robot = hrobot::AsyncRobot::default();
robot.list_subnets().await.unwrap();

pub async fn get_subnet(&self, subnet_addr: IpAddr) -> Result<Subnet, Error>

Get subnet information.

Example

let robot = hrobot::AsyncRobot::default();
robot.get_subnet("2a01:4f8:123:123::".parse().unwrap()).await.unwrap();

pub async fn enable_subnet_traffic_warnings( &self, ip: IpAddr, traffic_warnings: Option<TrafficWarnings> ) -> Result<Subnet, Error>

Enable traffic warnings for the subnet, optionally overriding the existing traffic limits.

Example

let robot = hrobot::AsyncRobot::default();
robot.enable_ip_traffic_warnings(
    "2a01:4f8:123:123::".parse().unwrap(),
    Some(TrafficWarnings {
        hourly:  ByteSize::mb(200),
        daily:   ByteSize::gb(2),
        monthly: ByteSize::gb(20),
    })
).await.unwrap();

pub async fn disable_subnet_traffic_warnings( &self, ip: IpAddr ) -> Result<Subnet, Error>

Disable traffic warnings for the subnet.

Example

let robot = hrobot::AsyncRobot::default();
robot.disable_subnet_traffic_warnings("2a01:4f8:123:123::".parse().unwrap()).await.unwrap();

pub async fn get_subnet_separate_mac(&self, ip: IpAddr) -> Result<String, Error>

Get the separate MAC address for this subnet.

Example

let robot = hrobot::AsyncRobot::default();
robot.get_subnet_separate_mac("2a01:4f8:123:123::".parse().unwrap()).await.unwrap();

pub async fn generate_subnet_separate_mac( &self, ip: IpAddr ) -> Result<String, Error>

Generate a separate MAC address for subnet.

Example

let robot = hrobot::AsyncRobot::default();
robot.generate_subnet_separate_mac("2a01:4f8:123:123::".parse().unwrap()).await.unwrap();

pub async fn remove_subnet_separate_mac(&self, ip: IpAddr) -> Result<(), Error>

Remove the separate MAC address for a subnet.

Example

let robot = hrobot::AsyncRobot::default();
robot.remove_subnet_separate_mac("2a01:4f8:123:123::".parse().unwrap()).await.unwrap();

pub async fn get_subnet_cancellation( &self, ip: Ipv4Addr ) -> Result<Cancellation, Error>

Get cancellation status for a subnet.

Note: Only IPv4 subnets can be cancelled.

Example

let robot = hrobot::AsyncRobot::default();
robot.get_subnet_cancellation("123.123.123.123".parse().unwrap()).await.unwrap();

pub async fn cancel_subnet( &self, ip: Ipv4Addr, date: Date ) -> Result<Cancelled, Error>

Cancel a subnet.

Note: Only IPv4 subnets can be cancelled.

Example

use time::{Date, Month};

let robot = hrobot::AsyncRobot::default();
robot.cancel_subnet(
    "123.123.123.123".parse().unwrap(),
    Date::from_calendar_date(2023, Month::July, 17).unwrap()
).await.unwrap();

pub async fn revoke_subnet_cancellation( &self, ip: Ipv4Addr ) -> Result<Cancellable, Error>

Revoke subnet cancellation.

Note: Only IPv4 subnets can be cancelled.

Example

let robot = hrobot::AsyncRobot::default();
robot.revoke_ip_cancellation("123.123.123.123".parse().unwrap()).await.unwrap();

impl AsyncRobot

pub async fn get_traffic( &self, ips: &[IpNet], range: TimeRange ) -> Result<HashMap<IpNet, Vec<TrafficStatistic>>, Error>

Get traffic statistics for specific IPs

Example

let robot = hrobot::AsyncRobot::default();
let traffic = robot.get_traffic(
    &[
        "123.123.123.123/32".parse().unwrap(),
        "2a01:4f8:123:123::".parse().unwrap(),
    ],
    TimeRange::month(2023, Month::July)
).await.unwrap();

impl AsyncRobot

pub async fn list_vswitches(&self) -> Result<Vec<VSwitchReference>, Error>

List all vSwitches.

Example

let robot = hrobot::AsyncRobot::default();
robot.list_vswitches().await.unwrap();

pub async fn get_vswitch(&self, vswitch: VSwitchId) -> Result<VSwitch, Error>

Get vSwitch information.

Example

let robot = hrobot::AsyncRobot::default();
robot.get_vswitch(VSwitchId(123456)).await.unwrap();

pub async fn create_vswitch( &self, name: &str, vlan_id: VlanId ) -> Result<VSwitchReference, Error>

Create a vSwitch

Example

let robot = hrobot::AsyncRobot::default();
robot.create_vswitch("vswitch-test-1", VlanId(4078)).await.unwrap();

pub async fn update_vswitch( &self, vswitch_id: VSwitchId, name: &str, vlan_id: VlanId ) -> Result<(), Error>

Update vSwitch.

Example

let robot = hrobot::AsyncRobot::default();
robot.update_vswitch(
    VSwitchId(124567),
    "vswitch-test-2",
    VlanId(4079)
).await.unwrap();

pub async fn cancel_vswitch( &self, vswitch_id: VSwitchId, cancellation_date: Date ) -> Result<(), Error>

Cancel vSwitch.

Example

let robot = hrobot::AsyncRobot::default();
robot.cancel_vswitch(
    VSwitchId(124567),
    Date::from_calendar_date(2023, Month::July, 10).unwrap()
).await.unwrap();

pub async fn connect_vswitch_servers( &self, vswitch_id: VSwitchId, server_ids: &[ServerId] ) -> Result<(), Error>

Connect dedicated servers to vSwitch.

Example

let robot = hrobot::AsyncRobot::default();
robot.connect_vswitch_servers(
    VSwitchId(124567),
    &[ServerId(1234567)],
).await.unwrap();

pub async fn disconnect_vswitch_servers( &self, vswitch_id: VSwitchId, server_ids: &[ServerId] ) -> Result<(), Error>

Disconnect dedicated servers from vSwitch.

Example

let robot = hrobot::AsyncRobot::default();
robot.disconnect_vswitch_servers(
    VSwitchId(124567),
    &[ServerId(1234567)],
).await.unwrap();

impl AsyncRobot

pub async fn is_wake_on_lan_available( &self, server_number: ServerId ) -> Result<bool, Error>

Check if Wake-on-LAN is available for the server.

Example

let robot = hrobot::AsyncRobot::default();
assert!(robot.is_wake_on_lan_available(ServerId(1234567)).await.unwrap());

pub async fn trigger_wake_on_lan( &self, server_number: ServerId ) -> Result<(), Error>

Send a Wake-on-LAN packet to the specified server.

Example

let robot = hrobot::AsyncRobot::default();
robot.trigger_wake_on_lan(ServerId(1234567)).await.unwrap();

impl AsyncRobot

pub fn from_env( client: Client<HttpsConnector<HttpConnector>, Body> ) -> Result<Self, VarError>

Construct a new AsyncRobot using the environment variables HROBOT_USERNAME and HROBOT_PASSWORD for credentials, and the given client.

Example

Construct an AsyncRobot using a hyper::Client and hyper_rustls.

let https = hyper_rustls::HttpsConnectorBuilder::new()
    .with_native_roots()
    .https_only()
    .enable_http1()
    .build();

let client = hyper::Client::builder().build(https);

let robot = hrobot::AsyncRobot::from_env(client);

pub fn new( client: Client<HttpsConnector<HttpConnector>, Body>, username: &str, password: &str ) -> Self

Construct a new AsyncRobot, using the given client, username and password.

Example

Construct an AsyncRobot using a custom hyper::Client.

let https = hyper_rustls::HttpsConnectorBuilder::new()
    .with_native_roots()
    .https_only()
    .enable_http1()
    .build();

let client = hyper::Client::builder().build(https);

let robot = hrobot::AsyncRobot::new(client, "#ws+username", "p@ssw0rd");

Trait Implementations§

impl Clone for AsyncRobot

fn clone(&self) -> AsyncRobot

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Debug for AsyncRobot

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

Formats the value using the given formatter. Read more

impl Default for AsyncRobot

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

impl !UnwindSafe for AsyncRobot

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for Twhere U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for Twhere U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for Twhere U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more