cluster

Manage cluster

Full_stats

Path: GET /v7.0/cluster/full_stats
Description: Full statistics information
Authentication required: yes
Scope: cluster#full_stats
Aliases
Blocking: no

Input parameters

No parameters.

Output parameters

Layout: hash
Namespace: cluster

Parameter	Type	Description
`nodes_online` Nodes_online	Integer
`node_count` Node_count	Integer
`vps_running` Vps_running	Integer	Number of running VPSes
`vps_stopped` Vps_stopped	Integer	Number of stopped VPSes
`vps_suspended` Vps_suspended	Integer
`vps_deleted` Vps_deleted	Integer	Number of lazily deleted VPSes
`vps_count` Vps_count	Integer
`user_active` User_active	Integer
`user_suspended` User_suspended	Integer
`user_deleted` User_deleted	Integer
`user_count` User_count	Integer
`ipv4_used` Ipv4_used	Integer
`ipv4_count` Ipv4_count	Integer

Generate_migration_keys

Path: POST /v7.0/cluster/generate_migration_keys
Description: Generate ssh keys for VPS migrations where applicable
Authentication required: yes
Scope: cluster#generate_migration_keys
Aliases
Blocking: yes

Input parameters

No parameters.

Output parameters

No parameters.

Public_stats

Path: GET /v7.0/cluster/public_stats
Description: Public statistics information
Authentication required: no
Scope: cluster#public_stats
Aliases
Blocking: no

Input parameters

No parameters.

Output parameters

Layout: object
Namespace: cluster

Parameter	Type	Description
`user_count` Number of users	Integer
`vps_count` Number of VPSes	Integer
`ipv4_left` Number of free public IPv4 addresses	Integer

Examples

Examples use an initialized api client, authenticated when required. See initialization and authentication.

Example #0

Ruby · Simple

reply = api.cluster.public_stats

# reply is an instance of HaveAPI::Client::ResourceInstance
# reply.user_count = 1100
# reply.vps_count = 1560
# reply.ipv4_left = 256

Ruby · With error handling

begin
  require 'haveapi/client'

  api = HaveAPI::Client.new("https://api.vpsfree.cz/", version: "7.0")
  api.setup

  reply = api.cluster.public_stats

  # reply is an instance of HaveAPI::Client::ResourceInstance
  # reply.user_count = 1100
  # reply.vps_count = 1560
  # reply.ipv4_left = 256
rescue HaveAPI::Client::ValidationError => error
  warn error.message
  warn error.errors.inspect
rescue HaveAPI::Client::ActionFailed => error
  warn error.message
  warn error.response.errors.inspect if error.response.is_a?(HaveAPI::Client::Response)
rescue HaveAPI::Client::Authentication::AuthenticationFailed, HaveAPI::Client::ProtocolError,
       RestClient::Exception, JSON::ParserError => error
  warn error.message
end

JavaScript (callback) · Simple

const resource = CallbackClient.findResource(api, ["cluster"]);
const action = CallbackClient.findAction(resource, "public_stats");
action.directInvoke({
  onReply: (owner, reply) => {
    if (!reply.isOk()) {
      console.error(reply.message(), reply.envelope.errors);
      return;
    }
    console.log(reply.response());
  }
});

JavaScript (callback) · With error handling

import { CallbackClient } from "haveapi-client";

const api = new CallbackClient("https://api.vpsfree.cz/", {version: "7.0"});

api.setup((api, ready) => {
  if (!ready) {
    console.error("Discovery or authentication failed");
    return;
  }
  try {
    const resource = CallbackClient.findResource(api, ["cluster"]);
    const action = CallbackClient.findAction(resource, "public_stats");
    action.directInvoke({
      onReply: (owner, reply) => {
        if (!reply.isOk()) {
          console.error(reply.message(), reply.envelope.errors);
          return;
        }
        console.log(reply.response());
        console.log(reply.meta());
      }
    });
  } catch (error) {
    console.error(error);
  }
});

JavaScript (async) · Simple

const result = await api.resource("cluster").action("public_stats")();
console.log(result.value);

JavaScript (async) · With error handling

import { AsyncClient, AsyncError } from "haveapi-client";

async function main() {
  const api = new AsyncClient("https://api.vpsfree.cz/", {version: "7.0"});
  try {
    await api.setup();
    const result = await api.resource("cluster").action("public_stats")();
    console.log(result.value);
    console.log(result.response.meta);
  } catch (error) {
    if (error instanceof AsyncError) {
      console.error(error.kind, error.message, error.errors);
    } else {
      throw error;
    }
  }
}
main().catch(error => console.error(error));

TypeScript (callback) · Simple

const resource = CallbackClient.findResource(api, ["cluster"]);
const action = CallbackClient.findAction(resource, "public_stats");
action.directInvoke({
  onReply: (owner, reply) => {
    if (!reply.isOk()) {
      console.error(reply.message(), reply.envelope.errors);
      return;
    }
    console.log(reply.response());
  }
});

TypeScript (callback) · With error handling

import { CallbackClient } from "haveapi-client";

const api = new CallbackClient("https://api.vpsfree.cz/", {version: "7.0"});

api.setup((api, ready) => {
  if (!ready) {
    console.error("Discovery or authentication failed");
    return;
  }
  try {
    const resource = CallbackClient.findResource(api, ["cluster"]);
    const action = CallbackClient.findAction(resource, "public_stats");
    action.directInvoke({
      onReply: (owner, reply) => {
        if (!reply.isOk()) {
          console.error(reply.message(), reply.envelope.errors);
          return;
        }
        console.log(reply.response());
        console.log(reply.meta());
      }
    });
  } catch (error) {
    console.error(error);
  }
});

TypeScript (async) · Simple

const result = await api.resource("cluster").action("public_stats")();
console.log(result.value);

TypeScript (async) · With error handling

import { AsyncClient, AsyncError } from "haveapi-client";

async function main(): Promise<void> {
  const api = new AsyncClient("https://api.vpsfree.cz/", {version: "7.0"});
  try {
    await api.setup();
    const result = await api.resource("cluster").action("public_stats")();
    console.log(result.value);
    console.log(result.response.meta);
  } catch (error) {
    if (error instanceof AsyncError) {
      console.error(error.kind, error.message, error.errors);
    } else {
      throw error;
    }
  }
}
main().catch(error => console.error(error));

Python (sync) · Simple

response = api.resources["cluster"].actions["public_stats"].call()
print(response.data)

Python (sync) · With error handling

from haveapi_client import Client, ActionError, HaveAPIError

try:
    with Client("https://api.vpsfree.cz/", version="7.0") as api:
        response = api.resources["cluster"].actions["public_stats"].call()
        print(response.data)
        print(response.meta)
except ActionError as error:
    print(error.message, error.errors)
except HaveAPIError as error:
    print(error.message, error.status_code)

Python (async) · Simple

# Run inside an async function after initializing api.
response = await api.resources["cluster"].actions["public_stats"].call()
print(response.data)

Python (async) · With error handling

import asyncio

from haveapi_client import AsyncClient, ActionError, HaveAPIError


async def main() -> None:
    try:
        async with AsyncClient("https://api.vpsfree.cz/", version="7.0") as api:
            response = await api.resources["cluster"].actions["public_stats"].call()
            print(response.data)
            print(response.meta)
    except ActionError as error:
        print(error.message, error.errors)
    except HaveAPIError as error:
        print(error.message, error.status_code)


asyncio.run(main())

Go API client · Simple

invocation := api.Cluster.PublicStats.Prepare()
response, err := invocation.Call()
if err != nil {
	fmt.Println(err)
	return
}
if !response.Status {
	fmt.Println(response.Message, response.Errors)
	return
}
if response.Output != nil {
	fmt.Println(response.Output.UserCount)
	fmt.Println(response.Output.VpsCount)
	fmt.Println(response.Output.Ipv4Left)
}

Rust API client (async) · Simple

// Use inside an async function returning Result<(), Box<dyn std::error::Error>>.
let response = api.cluster().public_stats().send().await?;
println!("{:?}", &response.output.user_count);
println!("{:?}", &response.output.vps_count);
println!("{:?}", &response.output.ipv4_left);

Rust API client (async) · With error handling

// cargo add vpsadmin-client
// cargo add tokio --features macros,rt-multi-thread
// cargo add serde_json
use vpsadmin_client::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api = match Client::builder("https://api.vpsfree.cz/")
        .build() {
        Ok(api) => api,
        Err(error) => {
            eprintln!("Client configuration failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let response = match api.cluster().public_stats().send().await {
        Ok(response) => response,
        Err(error) => {
            eprintln!("Request failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let _ = response.http_status;
    let _ = &response.meta;
    println!("{:?}", &response.output.user_count);
    println!("{:?}", &response.output.vps_count);
    println!("{:?}", &response.output.ipv4_left);
    Ok(())
}

Rust API client (blocking) · Simple

// Use inside a synchronous function outside async runtime threads returning Result<(), Box<dyn std::error::Error>>.
let response = api.cluster().public_stats().send()?;
println!("{:?}", &response.output.user_count);
println!("{:?}", &response.output.vps_count);
println!("{:?}", &response.output.ipv4_left);

Rust API client (blocking) · With error handling

// cargo add vpsadmin-client --features blocking
// cargo add serde_json
// Construct, use and drop this blocking client outside async runtime threads.
use vpsadmin_client::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api = match Client::builder("https://api.vpsfree.cz/")
        .build() {
        Ok(api) => api,
        Err(error) => {
            eprintln!("Client configuration failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let response = match api.cluster().public_stats().send() {
        Ok(response) => response,
        Err(error) => {
            eprintln!("Request failed: {}", error);
            eprintln!("HTTP status: {:?}; timeout: {}", error.http_status(), error.is_timeout());
            return Err(error.into());
        }
    };
    let _ = response.http_status;
    let _ = &response.meta;
    println!("{:?}", &response.output.user_count);
    println!("{:?}", &response.output.vps_count);
    println!("{:?}", &response.output.ipv4_left);
    Ok(())
}

TypeScript API client · Simple

// Requires an initialized api and an async context.
const result = await api.cluster.public_stats();
console.log(result.data.user_count);
console.log(result.data.vps_count);
console.log(result.data.ipv4_left);

TypeScript API client · With error handling

// Configured API client: vpsadmin-typescript-client.
import { AsyncClient, AsyncError } from "haveapi-client";
import { createClient } from "vpsadmin-typescript-client";

async function main(): Promise<void> {
  try {
    const runtime = new AsyncClient("https://api.vpsfree.cz/v7.0");
    const api = createClient({ execute: spec => runtime.request(spec) });
    const result = await api.cluster.public_stats();
    void [result.data, result.meta, result.envelope, result.httpStatus];
    const item = result.data;
    const value0: unknown = item.user_count;
    if (value0 !== null && value0 !== undefined) console.log(value0);
    const value1: unknown = item.vps_count;
    if (value1 !== null && value1 !== undefined) console.log(value1);
    const value2: unknown = item.ipv4_left;
    if (value2 !== null && value2 !== undefined) console.log(value2);
  } catch (error) {
    if (!(error instanceof AsyncError)) throw error;
    console.error(error.kind, error.httpStatus);
    throw error;
  }
}

main().catch(error => { throw error; });

PHP · Simple

$reply = $api->cluster->public_stats();

// $reply is an instance of \HaveAPI\Client\ResourceInstance
// $reply->user_count = 1100
// $reply->vps_count = 1560
// $reply->ipv4_left = 256

PHP · With error handling

try {
    $api = new \HaveAPI\Client('https://api.vpsfree.cz/', '7.0');
    $api->setup();

    $reply = $api->cluster->public_stats();

    // $reply is an instance of \HaveAPI\Client\ResourceInstance
    // $reply->user_count = 1100
    // $reply->vps_count = 1560
    // $reply->ipv4_left = 256
} catch (\HaveAPI\Client\Exception\ValidationError $error) {
    echo $error->getMessage() . "\n";
    print_r($error->getErrors());
} catch (\HaveAPI\Client\Exception\ActionFailed $error) {
    echo $error->getMessage() . "\n";
    print_r($error->getErrors());
} catch (\HaveAPI\Client\Exception\Base $error) {
    echo $error->getMessage() . "\n";
} catch (\Exception $error) {
    // Dependency failures still propagate to the application.
    echo $error->getMessage() . "\n";
    throw $error;
}

CLI · Simple

$ haveapi-cli -u https://api.vpsfree.cz/ --version 7.0 cluster public_stats
#                       Number of users:  1100
#                       Number of VPSes:  1560
#  Number of free public IPv4 addresses:  256
#

curl · Simple

$ curl --request GET \
       --data-binary \{\"cluster\":null\} \
       https://api.vpsfree.cz/v7.0/cluster/public_stats

# {
#   "status": true,
#   "message": null,
#   "response": {
#     "cluster": {
#       "user_count": 1100,
#       "vps_count": 1560,
#       "ipv4_left": 256
#     }
#   },
#   "errors": null
# }

HTTP · Simple

GET /v7.0/cluster/public_stats HTTP/1.1
Host: api.vpsfree.cz
Content-Type: application/json



HTTP/1.1 200 OK
Content-Type: application/json;charset=utf-8
Content-Length: 175

{
  "status": true,
  "message": null,
  "response": {
    "cluster": {
      "user_count": 1100,
      "vps_count": 1560,
      "ipv4_left": 256
    }
  },
  "errors": null
}

Search

Path: POST /v7.0/cluster/search
Description: Search users, VPSes and DNS zones by IDs, names and owned objects
Authentication required: yes
Scope: cluster#search
Aliases
Blocking: no

Input parameters

Layout: hash
Namespace: cluster

Parameter Type Required Details

value

Value

String

yes

Value to be searched for

Default: null

Validation rules
Rule	Details
Present	Must be supplied and cannot be null. Must not be empty; strings must contain a non-whitespace character. Validation error message: must be present and non-empty

Output parameters

Layout: hash_list
Namespace: clusters

Parameter	Type	Description
`resource` Resource	String	Resource name of the located object
`id` ID	Integer	Identifier of the located object
`attribute` Attribute	String	Name of the attribute containing the searched value
`value` Value	String	Located value

Set_maintenance

Path: POST /v7.0/cluster/set_maintenance
Description: Set maintenance lock
Authentication required: yes
Scope: cluster#set_maintenance
Aliases
Blocking: no

Input parameters

Layout: hash
Namespace: cluster

Parameter Type Required Details

lock

Lock

Boolean

yes

Default: null

Validation rules
Rule	Details
Present	Must be supplied and cannot be null. Must not be empty; strings must contain a non-whitespace character. Validation error message: must be present and non-empty

reason

Reason

String

Default: ""

Output parameters

No parameters.

Show

Path: GET /v7.0/cluster
Description: Cluster information
Authentication required: yes
Scope: cluster#show
Aliases: find
Blocking: no

Input parameters

No parameters.

Output parameters

Layout: object
Namespace: cluster

Parameter	Type	Description
`maintenance_lock` Maintenance_lock	Boolean
`maintenance_lock_reason` Maintenance_lock_reason	String

cluster#

Full_stats#

Input parameters#

Output parameters#

Generate_migration_keys#

Input parameters#

Output parameters#

Public_stats#

Input parameters#

Output parameters#

Examples#

Example #0#

Search#

Input parameters#

Output parameters#

Set_maintenance#

Input parameters#

Output parameters#

Show#

Input parameters#

Output parameters#

cluster

Full_stats

Input parameters

Output parameters

Generate_migration_keys

Input parameters

Output parameters

Public_stats

Input parameters

Output parameters

Examples

Example #0

Search

Input parameters

Output parameters

Set_maintenance

Input parameters

Output parameters

Show

Input parameters

Output parameters