instant-labs
/
instant-epp
mirror of https://github.com/instant-labs/instant-epp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update docs

This commit is contained in:
Nicholas Rempel 2021-11-05 15:14:05 -07:00 committed by masalachai
parent 445516e9e9
commit 5924b86cdd
24 changed files with 621 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
epp-client/src/config.rs
View File

@ -1,38 +1,31 @@
//! Config load module
//! Config
//!
//! Loads the configuration and credentials for each registry connection from
//! the `$XDG_CONFIG_HOME/epp-client/epp-client.toml` file
//!
//! ## Usage
//!
//! The config is automatically loaded when the module is initialized
//! and is available through the `epp_client::config::CONFIG` variable
//!
//! ## Sample config
//!
//! ```toml
//! [registry.verisign]
//! host = 'epp.verisign-grs.com'
//! port = 700
//! username = 'username'
//! password = 'password'
//! # service extensions
//! ext_uris = []
//!
//! [registry.hexonet.tls_files]
//! # the full client certificate chain in PEM format
//! cert_chain = '/path/to/certificate/chain/pemfile'
//! # the RSA private key for your certificate
//! key = '/path/to/private/key/pemfile'
//! ```
//! This module contains the connection configuration for the EPP client.
//!
//! ## Example
//!
//! ```rust
//! use epp_client::config::CONFIG;
//! ```no_run
//! use std::collections::HashMap;
//!
//! use epp_client::config::{EppClientConfig, EppClientConnection};
//!
//! // Create a config
//! let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
//! registry.insert(
//! "registry_name".to_owned(),
//! EppClientConnection {
//! host: "example.com".to_owned(),
//! port: 700,
//! username: "username".to_owned(),
//! password: "password".to_owned(),
//! ext_uris: None,
//! tls_files: None,
//! },
//! );
//! let config = EppClientConfig { registry };
//!
//! // Get configuration for the relevant registry section
//! let registry = CONFIG.registry("verisign").unwrap();
//! let registry = config.registry("verisign").unwrap();
//!
//! // Get EPP host name and port no.
//! let remote = registry.connection_details();

47
epp-client/src/connection/client.rs
View File

@ -2,28 +2,47 @@
//!
//! ## Example
//!
//! ```rust
//! ```no_run
//! use std::collections::HashMap;
//!
//! use epp_client::config::{EppClientConfig, EppClientConnection};
//! use epp_client::EppClient;
//! use epp_client::epp::{EppDomainCheck, EppDomainCheckResponse};
//! use epp_client::epp::generate_client_tr_id;
//!
//! #[tokio::main]
//! async fn main() {
//! // Create an instance of EppClient, specifying the name of the registry as in
//! // the config file
//! let mut client = match EppClient::new("verisign").await {
//! Ok(client) => client,
//! Err(e) => panic!("Failed to create EppClient: {}", e)
//! };
//!
//! // Make a EPP Hello call to the registry
//! let greeting = client.hello().await.unwrap();
//! println!("{:?}", greeting);
//! // Create a config
//! let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
//! registry.insert(
//! "registry_name".to_owned(),
//! EppClientConnection {
//! host: "example.com".to_owned(),
//! port: 700,
//! username: "username".to_owned(),
//! password: "password".to_owned(),
//! ext_uris: None,
//! tls_files: None,
//! },
//! );
//! let config = EppClientConfig { registry };
//!
//! // Create an instance of EppClient, passing the config and the registry you want to connect to
//! let mut client = match EppClient::new(&config, "registry_name").await {
//! Ok(client) => client,
//! Err(e) => panic!("Failed to create EppClient: {}", e)
//! };
//!
//! // Make a EPP Hello call to the registry
//! let greeting = client.hello().await.unwrap();
//! println!("{:?}", greeting);
//!
//! // Execute an EPP Command against the registry with distinct request and response objects
//! let domain_check = EppDomainCheck::new(vec!["eppdev.com", "eppdev.net"], generate_client_tr_id(&client).as_str());
//! let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
//! println!("{:?}", response);
//!
//! // Execute an EPP Command against the registry with distinct request and response objects
//! let domain_check = EppDomainCheck::new(vec!["eppdev.com", "eppdev.net"], generate_client_tr_id(&client).as_str());
//! let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
//! println!("{:?}", response);
//! }
//! ```

28
epp-client/src/epp/request/contact/check.rs
View File

@ -1,5 +1,4 @@
//! Types for EPP contact check request
/// Types for EPP contact check request
use epp_client_macros::*;
use crate::epp::object::{ElementName, EppObject, StringValue, StringValueTrait};
@ -11,16 +10,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```rust
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppContactCheck, EppContactCheckResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/contact/create.rs
View File

@ -12,7 +12,10 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::object::data::{Address, Phone, PostalInfo};
/// use epp_client::epp::{EppContactCreate, EppContactCreateResponse};
@ -20,9 +23,23 @@ use serde::{Deserialize, Serialize};
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/contact/delete.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppContactDelete, EppContactDeleteResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/contact/info.rs
View File

@ -12,16 +12,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppContactInfo, EppContactInfoResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

26
epp-client/src/epp/request/contact/update.rs
View File

@ -14,16 +14,34 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppContactUpdate, EppContactUpdateResponse};
/// use epp_client::epp::generate_client_tr_id;
/// use epp_client::epp::object::data::ContactStatus;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/check.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```rust
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainCheck, EppDomainCheckResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/create.rs
View File

@ -15,7 +15,10 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::object::data::DomainContact;
/// use epp_client::epp::{EppDomainCreate, EppDomainCreateResponse};
@ -23,9 +26,23 @@ use serde::{Deserialize, Serialize};
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/delete.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainDelete, EppDomainDeleteResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/info.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainInfo, EppDomainInfoResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

26
epp-client/src/epp/request/domain/renew.rs
View File

@ -13,17 +13,35 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use chrono::NaiveDate;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainRenew, EppDomainRenewResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/rgp/report.rs
View File

@ -16,7 +16,10 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainRgpRestoreReport, EppDomainRgpRestoreReportResponse};
/// use epp_client::epp::generate_client_tr_id;
@ -25,9 +28,23 @@ use serde::{Deserialize, Serialize};
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/rgp/request.rs
View File

@ -15,16 +15,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainRgpRestoreRequest, EppDomainRgpRestoreRequestResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

125
epp-client/src/epp/request/domain/transfer.rs
View File

@ -12,16 +12,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainTransferRequest, EppDomainTransferRequestResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
@ -43,16 +60,33 @@ pub type EppDomainTransferRequest = EppObject<Command<DomainTransfer>>;
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainTransferApprove, EppDomainTransferApproveResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
@ -74,16 +108,33 @@ pub type EppDomainTransferApprove = EppObject<Command<DomainTransfer>>;
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainTransferReject, EppDomainTransferRejectResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
@ -105,16 +156,33 @@ pub type EppDomainTransferReject = EppObject<Command<DomainTransfer>>;
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainTransferCancel, EppDomainTransferCancelResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
@ -136,16 +204,33 @@ pub type EppDomainTransferCancel = EppObject<Command<DomainTransfer>>;
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppDomainTransferQuery, EppDomainTransferQueryResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/domain/update.rs
View File

@ -13,7 +13,10 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::object::data::{DomainStatus, DomainContact};
/// use epp_client::epp::{EppDomainUpdate, EppDomainUpdateResponse, DomainAddRemove};
@ -21,9 +24,23 @@ use serde::{Deserialize, Serialize};
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/host/check.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```rust
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppHostCheck, EppHostCheckResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/host/create.rs
View File

@ -12,7 +12,10 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::object::data::HostAddr;
/// use epp_client::epp::{EppHostCreate, EppHostCreateResponse};
@ -20,9 +23,23 @@ use serde::{Deserialize, Serialize};
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/host/delete.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppHostDelete, EppHostDeleteResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/host/info.rs
View File

@ -11,16 +11,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppHostInfo, EppHostInfoResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/host/update.rs
View File

@ -12,7 +12,10 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::object::StringValueTrait;
/// use epp_client::epp::object::data::{HostAddr, HostStatus};
@ -21,9 +24,23 @@ use serde::{Deserialize, Serialize};
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/message/ack.rs
View File

@ -9,16 +9,33 @@ use serde::{Deserialize, Serialize};
/// Type that represents the &lt;epp&gt; request for registry <poll op="ack"> command
/// ## Usage
///
/// ```ignore
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppMessageAck, EppMessageAckResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

25
epp-client/src/epp/request/message/poll.rs
View File

@ -10,16 +10,33 @@ use serde::{Deserialize, Serialize};
///
/// ## Usage
///
/// ```rust
/// ```no_run
/// use std::collections::HashMap;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::epp::{EppMessagePoll, EppMessagePollResponse};
/// use epp_client::epp::generate_client_tr_id;
///
/// #[tokio::main]
/// async fn main() {
/// // Create an instance of EppClient, specifying the name of the registry as in
/// // the config file
/// let mut client = match EppClient::new("verisign").await {
/// // Create a config
/// let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
/// registry.insert(
/// "registry_name".to_owned(),
/// EppClientConnection {
/// host: "example.com".to_owned(),
/// port: 700,
/// username: "username".to_owned(),
/// password: "password".to_owned(),
/// ext_uris: None,
/// tls_files: None,
/// },
/// );
/// let config = EppClientConfig { registry };
///
/// // Create an instance of EppClient, passing the config and the registry you want to connect to
/// let mut client = match EppClient::new(&config, "registry_name").await {
/// Ok(client) => client,
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };

81
epp-client/src/lib.rs
View File

@ -33,68 +33,63 @@
//! - RGP Restore Request - [`EppDomainRgpRestoreRequest`](epp/request/domain/rgp/request/type.EppDomainRgpRestoreRequest.html)
//! - RGP Restore Report - [`EppDomainRgpRestoreReport`](epp/request/domain/rgp/report/type.EppDomainRgpRestoreReport.html)
//!
//! ## Prerequisites
//!
//! To use the library, you must have an `epp-client/epp-client.toml` config file with the relevant registry
//! credentials in your default user configuration directory on your OS. For Linux, this is the `XDG user directory`,
//! usually located at `$HOME/.config` or defined by the `XDG_CONFIG_HOME` environment variable.
//!
//! An example config looks like this:
//!
//! ```toml
//! [registry.verisign]
//! host = 'epp.verisign-grs.com'
//! port = 700
//! username = 'username'
//! password = 'password'
//! # service extensions
//! ext_uris = []
//!
//! [registry.verisign.tls_files]
//! # the full client certificate chain in PEM format
//! cert_chain = '/path/to/certificate/chain/pemfile'
//! # the RSA private key for your certificate
//! key = '/path/to/private/key/pemfile'
//! ```
//!
//! ## Operation
//!
//! Once the config is set correctly, you can create a mut variable of type [`EppClient`] to transact
//! with the domain registry
//!
//! ```rust
//! ```no_run
//! use std::collections::HashMap;
//!
//! use epp_client::config::{EppClientConfig, EppClientConnection};
//! use epp_client::EppClient;
//! use epp_client::epp::{EppDomainCheck, EppDomainCheckResponse};
//! use epp_client::epp::generate_client_tr_id;
//!
//! #[tokio::main]
//! async fn main() {
//! // Create an instance of EppClient, specifying the name of the registry as in
//! // the config file
//! let mut client = match EppClient::new("verisign").await {
//! Ok(client) => client,
//! Err(e) => panic!("Failed to create EppClient: {}", e)
//! };
//!
//! // Make a domain check call, which returns an object of type EppDomainCheckResponse
//! // that contains the result of the call
//! let domain_check = EppDomainCheck::new(
//! vec!["eppdev.com", "eppdev.net"],
//! generate_client_tr_id(&client).as_str()
//! );
//! // Create a config
//! let mut registry: HashMap<String, EppClientConnection> = HashMap::new();
//! registry.insert(
//! "registry_name".to_owned(),
//! EppClientConnection {
//! host: "example.com".to_owned(),
//! port: 700,
//! username: "username".to_owned(),
//! password: "password".to_owned(),
//! ext_uris: None,
//! tls_files: None,
//! },
//! );
//! let config = EppClientConfig { registry };
//!
//! let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
//! // Create an instance of EppClient, passing the config and the registry you want to connect to
//! let mut client = match EppClient::new(&config, "registry_name").await {
//! Ok(client) => client,
//! Err(e) => panic!("Failed to create EppClient: {}", e)
//! };
//!
//! // Make a domain check call, which returns an object of type EppDomainCheckResponse
//! // that contains the result of the call
//! let domain_check = EppDomainCheck::new(
//! vec!["eppdev.com", "eppdev.net"],
//! generate_client_tr_id(&client).as_str()
//! );
//!
//! let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
//!
//! // print the availability results
//! response.data.res_data.unwrap().check_data.domain_list
//! .iter()
//! .for_each(|chk| println!("Domain: {}, Available: {}", chk.domain.name, chk.domain.available));
//!
//! // print the availability results
//! response.data.res_data.unwrap().check_data.domain_list
//! .iter()
//! .for_each(|chk| println!("Domain: {}, Available: {}", chk.domain.name, chk.domain.available));
//! }
//! ```
//!
//! The output would look similar to the following
//!
//! ```
//! ```text
//! Domain: eppdev.com, Available: 1
//! Domain: eppdev.net, Available: 1
//! ```