Connection

cloudpub_sdk

Struct Connection 

Source 
pub struct Connection {
    pub config: Arc<RwLock<ClientConfig>>,
    pub command_tx: Sender<Message>,
    /* private fields */
}
Expand description

Управляет соединением с сервером CloudPub.

Структура Connection предоставляет высокоуровневый интерфейс для взаимодействия с сервером CloudPub, обработки аутентификации, регистрации сервисов и управления жизненным циклом.

§Пример

use cloudpub_sdk::Connection;
use cloudpub_common::protocol::{Protocol, Auth, Endpoint};

// Создание и настройка соединения
let mut conn = Connection::builder()
    .credentials("user@example.com", "password")
    .timeout_secs(30)
    .build()
    .await?;

// Регистрация сервиса
let endpoint = conn.publish(
    Protocol::Http,
    "localhost:8080".to_string(),
    Some("My Service".to_string()),
    Some(Auth::None),
    None,
    None,
    None,
).await?;

println!("Сервис доступен по адресу: {}", endpoint.as_url());

// Список всех сервисов
let services = conn.ls().await?;
for service in services {
    let name = service.client.as_ref()
        .and_then(|c| c.description.clone())
        .unwrap_or_else(|| "Безымянный".to_string());
    println!("Сервис: {} - {}", name, service.as_url());
}

§Потокобезопасность

Connection использует внутреннюю синхронизацию и может быть безопасно разделен между потоками с использованием Arc<Mutex<Connection>> при необходимости.

Fields§

§config: Arc<RwLock<ClientConfig>>§command_tx: Sender<Message>

Implementations§

Source§

impl Connection

Source

pub fn builder() -> ConnectionBuilder

Создает новый построитель соединения для настройки параметров соединения.

Это рекомендуемый способ создания нового соединения.

§Пример
use cloudpub_sdk::Connection;

let conn = Connection::builder()
    .config_path("/path/to/config.toml")
    .credentials("user@example.com", "password")
    .timeout_secs(30)
    .verbose(true)
    .build()
    .await?;
Examples found in repository?
examples/example.rs (line 33)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn wait_for_event( &self, target_event: impl Fn(&ConnectionEvent) -> bool + Send, ) -> Result<ConnectionEvent>

Ожидает наступления определенного события с таймаутом.

Этот метод блокируется до получения целевого события или истечения таймаута. Он используется внутренне другими методами, но также может использоваться напрямую для пользовательской обработки событий.

§Аргументы
  • target_event - Предикатная функция, которая возвращает true при получении желаемого события
§Возвращает

Возвращает соответствующее событие или ошибку, если:

  • Истек таймаут
  • Соединение закрыто
  • Получено событие ошибки
§Пример
use cloudpub_sdk::ConnectionEvent;

// Ожидать установки соединения
let event = conn.wait_for_event(|e| matches!(e, ConnectionEvent::Connected)).await?;

// Ожидать любой операции с эндпоинтом
let event = conn.wait_for_event(|e| matches!(e, ConnectionEvent::Endpoint(_))).await?;
if let ConnectionEvent::Endpoint(endpoint) = event {
    println!("Эндпоинт зарегистрирован: {}", endpoint.guid);
}
Source

pub fn set(&self, key: &str, value: &str) -> Result<()>

Устанавливает значение конфигурации.

§Аргументы
  • key - Ключ конфигурации (например, “server”, “port”, “ssl”)
  • value - Значение конфигурации
§Пример
conn.set("server", "api.example.com")?;
conn.set("port", "443")?;
conn.set("ssl", "true")?;
Source

pub fn get(&self, key: &str) -> Result<String>

Получает значение конфигурации.

§Аргументы
  • key - Ключ конфигурации для получения
§Возвращает

Значение конфигурации или ошибку, если ключ не существует.

§Пример
let server = conn.get("server")?;
println!("Подключено к серверу: {}", server);
Source

pub fn options(&self) -> HashMap<String, String>

Получает все опции конфигурации в виде HashMap.

§Возвращает

HashMap, содержащий все текущие пары ключ-значение конфигурации.

§Пример
let options = conn.options();
for (key, value) in options {
    println!("Config: {} = {}", key, value);
}
Source

pub fn logout(&self) -> Result<()>

Выходит из системы, очищая токен аутентификации.

Это удаляет сохраненный токен аутентификации как из памяти, так и из файла конфигурации. Соединение нужно будет повторно аутентифицировать для дальнейших операций.

§Пример
conn.logout()?;
println!("Выход выполнен успешно");
Source

pub async fn register( &mut self, protocol: Protocol, address: String, name: Option<String>, auth: Option<Auth>, acl: Option<Vec<Acl>>, headers: Option<Vec<Header>>, rules: Option<Vec<FilterRule>>, ) -> Result<ServerEndpoint>

Регистрирует сервис на сервере CloudPub.

Этот метод регистрирует локальный сервис для доступа через CloudPub. Сервису будет присвоен уникальный GUID и URL для удаленного доступа.

§Аргументы
  • protocol - Тип протокола (HTTP, HTTPS, TCP, UDP, WS, WSS, RTSP)
  • address - Локальный адрес сервиса. Для RTSP с авторизацией используйте формат: rtsp://user:pass@host:port/path
  • name - Опциональное человекочитаемое имя для сервиса
  • auth - Опциональный метод аутентификации для доступа к сервису
  • acl - Опциональный список контроля доступа для фильтрации IP
  • headers - Опциональные HTTP заголовки для добавления к ответам
  • rules - Опциональные правила фильтрации для фильтрации запросов
§Возвращает

Возвращает ServerEndpoint, содержащий:

  • guid: Уникальный идентификатор для сервиса
  • URL информацию для доступа к сервису
  • Статус сервиса и метаданные
§Пример
use cloudpub_common::protocol::{Protocol, Auth, Endpoint, Acl, Header, FilterRule};

// HTTP service
let endpoint = conn.register(
    Protocol::Http,
    "localhost:3000".to_string(),
    Some("My Web App".to_string()),
    Some(Auth::Basic),
    None,
    None,
    None,
).await?;

// HTTP service with ACL and headers
let acl = vec![Acl { user: "admin".to_string(), role: cloudpub_common::protocol::Role::Admin as i32 }];
let headers = vec![Header { name: "X-Custom".to_string(), value: "test".to_string() }];
let endpoint = conn.register(
    Protocol::Http,
    "localhost:8080".to_string(),
    Some("API Server".to_string()),
    Some(Auth::None),
    Some(acl),
    Some(headers),
    None,
).await?;

// RTSP service with credentials in URL
let rtsp_endpoint = conn.register(
    Protocol::Rtsp,
    "rtsp://camera:secret@localhost:554/stream".to_string(),
    Some("Security Camera".to_string()),
    Some(Auth::None),
    None,
    None,
    None,
).await?;

println!("Сервис зарегистрирован по адресу: {}", endpoint.as_url());
println!("GUID сервиса: {}", endpoint.guid);
Source

pub async fn publish( &mut self, protocol: Protocol, address: String, name: Option<String>, auth: Option<Auth>, acl: Option<Vec<Acl>>, headers: Option<Vec<Header>>, rules: Option<Vec<FilterRule>>, ) -> Result<ServerEndpoint>

Публикует сервис на сервере CloudPub.

Это псевдоним для register(), который запускает сервис сразу после регистрации

§Аргументы
  • protocol - Тип протокола (HTTP, HTTPS, TCP, UDP, WS, WSS, RTSP)
  • address - Локальный адрес сервиса. Для RTSP с авторизацией используйте формат: rtsp://user:pass@host:port/path
  • name - Опциональное человекочитаемое имя для сервиса
  • auth - Опциональный метод аутентификации для доступа к сервису
  • acl - Опциональный список контроля доступа для фильтрации IP
  • headers - Опциональные HTTP заголовки для добавления к ответам
  • rules - Опциональные правила фильтрации для фильтрации запросов
§Возвращает

Возвращает ServerEndpoint с деталями сервиса и URL доступа.

§Пример
use cloudpub_common::protocol::{Protocol, Auth, Endpoint, Acl, FilterRule};

// Publish a TCP service
let endpoint = conn.publish(
    Protocol::Tcp,
    "localhost:8080".to_string(),
    Some("TCP Server".to_string()),
    Some(Auth::None),
    None,
    None,
    None,
).await?;

// Publish HTTP service with ACL
let acl = vec![Acl { user: "reader".to_string(), role: cloudpub_common::protocol::Role::Reader as i32 }];
let endpoint = conn.publish(
    Protocol::Http,
    "localhost:3000".to_string(),
    Some("Internal API".to_string()),
    Some(Auth::Basic),
    Some(acl),
    None,
    None,
).await?;

// Publish RTSP with embedded credentials
let rtsp = conn.publish(
    Protocol::Rtsp,
    "rtsp://admin:password@192.168.1.100:554/live/ch0".to_string(),
    Some("IP Camera".to_string()),
    Some(Auth::Basic),
    None,
    None,
    None,
).await?;

println!("TCP сервис доступен по адресу: {}", endpoint.as_url());
Examples found in repository?
examples/example.rs (lines 61-69)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn ls(&mut self) -> Result<Vec<ServerEndpoint>>

Выводит список всех зарегистрированных сервисов.

Возвращает список всех сервисов, в данный момент зарегистрированных на сервере, включая их статус, URL и метаданные.

§Возвращает

Вектор структур ServerEndpoint, содержащих информацию о сервисах.

§Пример
use cloudpub_common::protocol::Endpoint;

let services = conn.ls().await?;

for service in services {
    let name = service.client.as_ref()
        .and_then(|c| c.description.clone())
        .unwrap_or_else(|| "Безымянный".to_string());
    println!("Сервис: {} ({})" ,
        name,
        service.guid
    );
    println!("  URL: {}", service.as_url());
    println!("  Статус: {}", service.status.unwrap_or_else(|| "Неизвестен".to_string()));
}
Examples found in repository?
examples/example.rs (line 106)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn start(&mut self, guid: String) -> Result<()>

Запускает сервис по его GUID.

Запускает ранее зарегистрированный сервис, который мог быть остановлен. Это делает сервис снова доступным через его CloudPub URL.

§Аргументы
  • guid - Уникальный идентификатор сервиса для запуска
§Пример
let services = conn.ls().await?;
if let Some(service) = services.first() {
    conn.start(service.guid.clone()).await?;
    println!("Запущен сервис: {}", service.guid);
}
Examples found in repository?
examples/example.rs (line 126)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn stop(&mut self, guid: String) -> Result<()>

Останавливает сервис по его GUID.

Временно останавливает сервис, делая его недоступным через CloudPub. Регистрация сервиса сохраняется и может быть перезапущена позже.

§Arguments
  • guid - Уникальный идентификатор сервиса для остановки
§Пример
conn.stop("service-guid-123".to_string()).await?;
println!("Сервис остановлен");
Examples found in repository?
examples/example.rs (line 162)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn unpublish(&mut self, guid: String) -> Result<()>

Отменяет публикацию (удаляет) сервис по его GUID.

Навсегда удаляет регистрацию сервиса с сервера. Сервис больше не будет доступен через CloudPub.

§Arguments
  • guid - Уникальный идентификатор сервиса для отмены публикации
§Пример
conn.unpublish("service-guid-123".to_string()).await?;
println!("Публикация сервиса отменена и удалена");
Examples found in repository?
examples/example.rs (line 172)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn clean(&mut self) -> Result<()>

Удаляет все зарегистрированные сервисы.

Этот метод удаляет все сервисы, зарегистрированные текущим пользователем. Используйте с осторожностью, так как эта операция не может быть отменена.

§Пример
conn.clean().await?;
println!("Все сервисы удалены");

let services = conn.ls().await?;
assert_eq!(services.len(), 0);
Examples found in repository?
examples/example.rs (line 191)
25async fn main() -> Result<()> {
26    // ====================================================================
27    // ШАГ 1: УСТАНОВЛЕНИЕ СОЕДИНЕНИЯ
28    // ====================================================================
29    println!("1. Подключение к серверу");
30
31    // Создание соединения с использованием паттерна билдера
32    // Билдер позволяет настроить различные параметры соединения
33    let mut conn = Connection::builder()
34        // Указать путь к пользовательскому файлу конфигурации (опционально)
35        // Если не указан, используется системное расположение по умолчанию
36        .config_path(Path::new("/tmp/cloudpub.toml"))
37        // Установить уровень логирования для отладки
38        // Варианты: "trace", "debug", "info", "warn", "error"
39        .log_level("info")
40        // Включить подробный вывод в stderr для отладки
41        // Полезно при разработке, отключите в продакшене
42        .verbose(true)
43        // Предоставить учетные данные для аутентификации
44        // Вы также можете использовать .token() для аутентификации на основе токена
45        .credentials("admin@example.com", "test")
46        // Установить таймаут для операций (в секундах)
47        // Применяется ко всем асинхронным операциям
48        .timeout_secs(3)
49        // Построить и установить соединение
50        // Произойдет аутентификация и ожидание готовности соединения
51        .build()
52        .await?;
53
54    // ====================================================================
55    // ШАГ 2: ПУБЛИКАЦИЯ HTTP СЕРВИСА
56    // ====================================================================
57    println!("2. Публикация нового HTTP сервиса...");
58
59    // Публикация локального HTTP сервиса для доступа через CloudPub
60    let endpoint = conn
61        .publish(
62            Protocol::Http,                           // Тип протокола
63            "localhost:8080".to_string(),             // Локальный адрес для публикации
64            Some("Тестовый HTTP сервис".to_string()), // Человекочитаемое имя сервиса
65            Some(Auth::None),                         // Метод аутентификации для доступа к сервису
66            None,                                     // Без ограничений ACL
67            None,                                     // Без пользовательских заголовков
68            None,                                     // Без правил фильтрации
69        )
70        .await?;
71
72    // Endpoint содержит информацию об опубликованном сервисе
73    // as_url() возвращает публичный URL, по которому доступен сервис
74    println!("  Сервис опубликован: {}", endpoint.as_url());
75
76    // ====================================================================
77    // ШАГ 3: ПУБЛИКАЦИЯ TCP СЕРВИСА
78    // ====================================================================
79    println!("3. Публикация нового TCP сервиса...");
80
81    // TCP сервисы полезны для публикации SSH, баз данных или пользовательских TCP протоколов
82    let endpoint = conn
83        .publish(
84            Protocol::Tcp,                           // TCP протокол
85            "localhost:22".to_string(),              // Локальный SSH порт (пример)
86            Some("Тестовый TCP сервис".to_string()), // Имя сервиса
87            Some(Auth::None),                        // Аутентификация не требуется
88            None,                                    // Без ограничений ACL
89            None,                                    // Без пользовательских заголовков
90            None,                                    // Без правил фильтрации
91        )
92        .await?;
93
94    println!("  Сервис опубликован: {}", endpoint.as_url());
95
96    // Сохранить GUID для последующих операций
97    // GUID уникально идентифицирует этот сервис
98    let service_guid = endpoint.guid.clone();
99
100    // ====================================================================
101    // ШАГ 4: СПИСОК ВСЕХ СЕРВИСОВ
102    // ====================================================================
103    println!("4. Список сервисов:");
104
105    // Получить все сервисы, зарегистрированные текущим пользователем
106    let services = conn.ls().await?;
107
108    // Отобразить каждый сервис с его GUID и URL
109    for service in &services {
110        println!("  {}: {}", service.guid, service.as_url());
111
112        // Сервисы также содержат дополнительные метаданные:
113        // - service.name: Опциональное человекочитаемое имя
114        // - service.status: Текущий статус (работает, остановлен и т.д.)
115        // - service.protocol: Тип протокола
116        // - service.auth: Метод аутентификации
117    }
118
119    // ====================================================================
120    // ШАГ 5: ЗАПУСК СЕРВИСА
121    // ====================================================================
122    println!("5. Запуск сервиса {}...", service_guid);
123
124    // Запустить ранее остановленный сервис
125    // Примечание: Сервисы обычно запускаются автоматически после публикации
126    conn.start(service_guid.clone()).await?;
127    println!("   - Сервис запущен");
128
129    // ====================================================================
130    // ШАГ 6: ПРОВЕРКА СТАТУСА СЕРВИСА
131    // ====================================================================
132    println!("6. Проверка статуса сервиса...");
133
134    // Получить список сервисов снова, чтобы увидеть обновленный статус
135    let services = conn.ls().await?;
136
137    // Найти наш конкретный сервис и отобразить его статус
138    if let Some(service) = services.iter().find(|s| s.guid == service_guid) {
139        println!(
140            "   - Статус сервиса: {}",
141            service.status.as_ref().unwrap_or(&"Неизвестно".to_string())
142        );
143
144        // Поле статуса указывает состояние сервиса:
145        // - "running": Сервис активен и доступен
146        // - "stopped": Сервис зарегистрирован, но не доступен
147        // - "error": Сервис столкнулся с ошибкой
148    }
149
150    let mut buffer = String::new();
151    io::stdin()
152        .read_line(&mut buffer)
153        .expect("Не удалось прочитать строку");
154
155    // ====================================================================
156    // ШАГ 7: ОСТАНОВКА СЕРВИСА
157    // ====================================================================
158    println!("7. Остановка сервиса {}...", service_guid);
159
160    // Остановка делает сервис временно недоступным,
161    // но сохраняет его регистрацию
162    conn.stop(service_guid.clone()).await?;
163    println!("   - Сервис остановлен");
164
165    // ====================================================================
166    // ШАГ 8: ОТМЕНА ПУБЛИКАЦИИ СЕРВИСА
167    // ====================================================================
168    println!("8. Отмена регистрации сервиса {}...", service_guid);
169
170    // Отмена публикации удаляет регистрацию сервиса
171    // Сервис больше не будет доступен через CloudPub
172    conn.unpublish(service_guid.clone()).await?;
173    println!("   - Регистрация сервиса отменена");
174
175    // ====================================================================
176    // ШАГ 9: ПРОВЕРКА УДАЛЕНИЯ
177    // ====================================================================
178    println!("9. Финальный список сервисов...");
179
180    // Получить список сервисов для подтверждения удаления
181    let services = conn.ls().await?;
182    println!("   - Осталось {} сервис(ов)", services.len());
183
184    // ====================================================================
185    // ШАГ 10: ОЧИСТКА ВСЕХ СЕРВИСОВ
186    // ====================================================================
187    println!("10. Очистка всех сервисов...");
188
189    // Clean удаляет все сервисы, зарегистрированные текущим пользователем
190    // Используйте с осторожностью, так как это действие нельзя отменить
191    conn.clean().await?;
192    println!("   - Все сервисы удалены");
193
194    // Проверить, что все сервисы были удалены
195    let services = conn.ls().await?;
196    println!("   Финальное количество: {} сервис(ов)", services.len());
197
198    println!("Демонстрация успешно завершена!");
199
200    // ====================================================================
201    // ОЧИСТКА СОЕДИНЕНИЯ
202    // ====================================================================
203    // Соединение будет автоматически закрыто, когда `conn` выйдет из области видимости
204    // Реализация Drop обрабатывает:
205    // - Отправку сообщения Break для корректной остановки клиента
206    // - Отмену фоновых задач
207    // - Очистку ресурсов
208
209    Ok(())
210}
Source

pub async fn ping(&mut self) -> Result<u64>

Пингует сервер для измерения задержки.

Создает временную конечную точку пинга и измеряет время прохождения туда и обратно до сервера. Полезно для проверки работоспособности соединения и задержки.

§Возвращает

Задержку пинга в микросекундах.

§Пример
let latency_us = conn.ping().await?;
println!("Задержка сервера: {}μs ({:.2}мс)", latency_us, latency_us as f64 / 1000.0);

if latency_us > 100_000 {  // 100ms
    println!("Предупреждение: Обнаружена высокая задержка");
}
Source

pub fn purge(&self) -> Result<()>

Очищает локальный каталог кэша.

Удаляет все кэшированные данные, включая временные файлы и логи. Это может быть полезно для устранения неполадок или освобождения дискового пространства.

§Пример
conn.purge()?;
println!("Кэш успешно очищен");

Trait Implementations§

Source§

impl Drop for Connection

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

Source§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

Source§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

Source§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

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

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

fn in_current_span(self) -> Instrumented<Self>

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

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

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

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

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

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

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

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

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ErasedDestructor for T
where T: 'static,