epp client

Biblioteca EPP (Protocolo de aprovisionamiento extensible) para registro y gestión de dominios

Descripción

epp-client es una biblioteca cliente escrita en Rust para el registro y la gestión de dominios de Internet para registradores de dominios.

Admite las siguientes llamadas básicas de administración de dominio, contacto, host y mensajes, con planes para agregar más llamadas y otras extensiones EPP en el futuro y, eventualmente, cumplir con RFC con el protocolo EPP.

• Verificación de dominio

• Crear dominio

• Información del dominio

• Actualización de dominio

• Eliminar dominio

• Renovación de Dominio

• Transferencia de Dominio

• Verificación de contacto

• Contacto Crear

• Información de contacto

• Actualización de contacto

• Contacto Eliminar

• Cheque de anfitrión

• Crear anfitrión

• Información del anfitrión

• Actualización del anfitrión

• Eliminar anfitrión

• Encuesta de mensajes

• Mensaje de confirmación

• Solicitud de restauración RGP

• Informe de restauración de RGP

Uso

Simplemente agregue lo siguiente al Cargo.toml de su proyecto

 epp-client = " 0.4 " 

Operación

Puede crear una variable mut de tipo EppClient con la configuración del registro de dominio.

 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 ) ) ;
}

La salida se vería así:

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

Pedido

Actualmente no tengo acceso a una cuenta de OT&E de un registro para realizar pruebas exhaustivas. Estoy usando el EPP Gateway de hexonet para realizar pruebas, pero el acceso a una cuenta OT&E de un registro sería muy útil, así que si alguien pudiera ayudarme con uno, estaría muy agradecido.