Go to file
Rudi Floren 4922c4e370
Add support for idle keepalive
Using the idle_timeout paramter during connection creation, the
connection is prevented from being closed server-side due to beeing idle
for too long. Internally, while waiting for an API request, if
idle_timeout reaches zero before a new request comes in, a hello request
is send as a keepalive measure.
2023-01-17 18:13:50 +01:00
src Add support for idle keepalive 2023-01-17 18:13:50 +01:00
tests Add support for idle keepalive 2023-01-17 18:13:50 +01:00
.drone.yml update doc and release 0.4 2022-07-26 14:49:37 +08:00
.gitignore update doc and release 0.4 2022-07-26 14:49:37 +08:00
Cargo.toml Split client and connection into two halfes 2023-01-17 18:13:42 +01:00
LICENSE added MIT licence 2021-07-27 01:51:28 +08:00
README.md update doc and release 0.4 2022-07-26 14:49:37 +08:00

README.md

EPP (Extensible Provisioning Protocol) Library for Domain Registration and Management

Build Documentation

Description

epp-client is a client library written in Rust for Internet domain registration and management for domain registrars.

It supports the following basic Domain, Contact, Host, and Message management calls, with plans to add more calls and other EPP extensions in the future, and to eventually be RFC compliant with the EPP protocol.

  • Domain Check

  • Domain Create

  • Domain Info

  • Domain Update

  • Domain Delete

  • Domain Renew

  • Domain Transfer

  • Contact Check

  • Contact Create

  • Contact Info

  • Contact Update

  • Contact Delete

  • Host Check

  • Host Create

  • Host Info

  • Host Update

  • Host Delete

  • Message Poll

  • Message Ack

  • RGP Restore Request

  • RGP Restore Report

Usage

Just add the following to your project's Cargo.toml

epp-client = "0.4"

Operation

You can create a mut variable of type EppClient with the domain registry config.

use std::net::ToSocketAddrs;
use std::time::Duration;

use epp_client::EppClient;
use epp_client::domain::DomainCheck;
use epp_client::login::Login;

#[tokio::main]
async fn main() {
    // Create an instance of EppClient
    let host = "example.com";
    let addr = (host, 700).to_socket_addrs().unwrap().next().unwrap();
    let timeout = Duration::from_secs(5);
    let mut client = match EppClient::connect("registry_name".to_string(), addr, host, None, timeout).await {
        Ok(client) => client,
        Err(e) => panic!("Failed to create EppClient: {}",  e)
    };

    let login = Login::new("username", "password", None);
    client.transact(&login, "transaction-id").await.unwrap();

    // Execute an EPP Command against the registry with distinct request and response objects
    let domain_check = DomainCheck { domains: &["eppdev.com", "eppdev.net"] };
    let response = client.transact(&domain_check, "transaction-id").await.unwrap();

    response.res_data.unwrap().list
        .iter()
        .for_each(|chk| println!("Domain: {}, Available: {}", chk.id, chk.available));
}

The output would look like this:

Domain: eppdev.com, Available: 1
Domain: eppdev.net, Available: 1

Request

Currently I don't have access to a registry's OT&E account to do extensive testing. I am using hexonet's EPP Gateway for testing, but access to a registry's OT&E account would be very helpful, so if anyone could help me out with one I would be very grateful!