use serde_derive :: { Deserialize , Serialize } ; use std :: io :: BufRead ; use std :: sync :: { Arc , RwLock } ; use varlink :: { self , CallTrait } ; # [allow (dead_code)] # [derive (Clone , PartialEq , Debug)] pub enum ErrorKind { Varlink_Error , VarlinkReply_Error , InterfaceNotFound (Option < InterfaceNotFound_Args >) } impl :: std :: fmt :: Display for ErrorKind { fn fmt (& self , f : & mut :: std :: fmt :: Formatter) -> :: std :: fmt :: Result { match self { ErrorKind :: Varlink_Error => write ! (f , "Varlink Error") , ErrorKind :: VarlinkReply_Error => write ! (f , "Varlink error reply") , ErrorKind :: InterfaceNotFound (v) => write ! (f , "org.varlink.resolver.InterfaceNotFound: {:#?}" , v) } } } pub struct Error (pub ErrorKind , pub Option < Box < dyn std :: error :: Error + 'static + Send + Sync >> , pub Option < & 'static str > ,) ; impl Error { # [allow (dead_code)] pub fn kind (& self) -> & ErrorKind { & self . 0 } } impl From < ErrorKind > for Error { fn from (e : ErrorKind) -> Self { Error (e , None , None) } } impl std :: error :: Error for Error { fn source (& self) -> Option < & (dyn std :: error :: Error + 'static) > { self . 1 . as_ref () . map (| e | e . as_ref () as & (dyn std :: error :: Error + 'static)) } } impl std :: fmt :: Display for Error { fn fmt (& self , f : & mut std :: fmt :: Formatter) -> std :: fmt :: Result { std :: fmt :: Display :: fmt (& self . 0 , f) } } impl std :: fmt :: Debug for Error { fn fmt (& self , f : & mut std :: fmt :: Formatter) -> std :: fmt :: Result { use std :: error :: Error as StdError ; if let Some (ref o) = self . 2 { std :: fmt :: Display :: fmt (o , f) ? ; } std :: fmt :: Debug :: fmt (& self . 0 , f) ? ; if let Some (e) = self . source () { std :: fmt :: Display :: fmt ("\nCaused by:\n" , f) ? ; std :: fmt :: Debug :: fmt (& e , f) ? ; } Ok (()) } } # [allow (dead_code)] pub type Result < T > = std :: result :: Result < T , Error > ; impl From < varlink :: Error > for Error { fn from (e : varlink :: Error ,) -> Self { match e . kind () { varlink :: ErrorKind :: VarlinkErrorReply (r) => Error (ErrorKind :: from (r) , Some (Box :: from (e)) , Some (concat ! (file ! () , ":" , line ! () , ": "))) , _ => Error (ErrorKind :: Varlink_Error , Some (Box :: from (e)) , Some (concat ! (file ! () , ":" , line ! () , ": "))) } } } # [allow (dead_code)] impl Error { pub fn source_varlink_kind (& self) -> Option < & varlink :: ErrorKind > { use std :: error :: Error as StdError ; let mut s : & dyn StdError = self ; while let Some (c) = s . source () { let k = self . source () . and_then (| e | e . downcast_ref :: < varlink :: Error > ()) . map (| e | e . kind ()) ; if k . is_some () { return k ; } s = c ; } None } } impl From < & varlink :: Reply > for ErrorKind { # [allow (unused_variables)] fn from (e : & varlink :: Reply) -> Self { match e { varlink :: Reply { error : Some (ref t) , .. } if t == "org.varlink.resolver.InterfaceNotFound" => { match e { varlink :: Reply { parameters : Some (p) , .. } => match serde_json :: from_value (p . clone ()) { Ok (v) => ErrorKind :: InterfaceNotFound (v) , Err (_) => ErrorKind :: InterfaceNotFound (None) , } , _ => ErrorKind :: InterfaceNotFound (None) , } } _ => ErrorKind :: VarlinkReply_Error , } } } pub trait VarlinkCallError : varlink :: CallTrait { fn reply_interface_not_found (& mut self , r#interface : String) -> varlink :: Result < () > { self . reply_struct (varlink :: Reply :: error ("org.varlink.resolver.InterfaceNotFound" , Some (serde_json :: to_value (InterfaceNotFound_Args { r#interface }) . map_err (varlink :: map_context ! ()) ?))) } } impl < 'a > VarlinkCallError for varlink :: Call < 'a > { } # [derive (Serialize , Deserialize , Debug , PartialEq , Clone)] pub struct InterfaceNotFound_Args { pub r#interface : String , } # [derive (Serialize , Deserialize , Debug , PartialEq , Clone)] pub struct GetInfo_Reply { pub r#vendor : String , pub r#product : String , pub r#version : String , pub r#url : String , pub r#interfaces : Vec < String > , } impl varlink :: VarlinkReply for GetInfo_Reply { } # [derive (Serialize , Deserialize , Debug , PartialEq , Clone)] pub struct GetInfo_Args { } pub trait Call_GetInfo : VarlinkCallError { fn reply (& mut self , r#vendor : String , r#product : String , r#version : String , r#url : String , r#interfaces : Vec < String >) -> varlink :: Result < () > { self . reply_struct (GetInfo_Reply { r#vendor , r#product , r#version , r#url , r#interfaces } . into ()) } } impl < 'a > Call_GetInfo for varlink :: Call < 'a > { } # [derive (Serialize , Deserialize , Debug , PartialEq , Clone)] pub struct Resolve_Reply { pub r#address : String , } impl varlink :: VarlinkReply for Resolve_Reply { } # [derive (Serialize , Deserialize , Debug , PartialEq , Clone)] pub struct Resolve_Args { pub r#interface : String , } pub trait Call_Resolve : VarlinkCallError { fn reply (& mut self , r#address : String) -> varlink :: Result < () > { self . reply_struct (Resolve_Reply { r#address } . into ()) } } impl < 'a > Call_Resolve for varlink :: Call < 'a > { } pub trait VarlinkInterface { fn get_info (& self , call : & mut dyn Call_GetInfo ,) -> varlink :: Result < () > ; fn resolve (& self , call : & mut dyn Call_Resolve , r#interface : String) -> varlink :: Result < () > ; fn call_upgraded (& self , _call : & mut varlink :: Call , _bufreader : & mut dyn BufRead) -> varlink :: Result < Vec < u8 >> { Ok (Vec :: new ()) } } pub trait VarlinkClientInterface { fn get_info (& mut self ,) -> varlink :: MethodCall < GetInfo_Args , GetInfo_Reply , Error > ; fn resolve (& mut self , r#interface : String) -> varlink :: MethodCall < Resolve_Args , Resolve_Reply , Error > ; } # [allow (dead_code)] pub struct VarlinkClient { connection : Arc < RwLock < varlink :: Connection >> , } impl VarlinkClient { # [allow (dead_code)] pub fn new (connection : Arc < RwLock < varlink :: Connection >>) -> Self { VarlinkClient { connection , } } } impl VarlinkClientInterface for VarlinkClient { fn get_info (& mut self ,) -> varlink :: MethodCall < GetInfo_Args , GetInfo_Reply , Error > { varlink :: MethodCall :: < GetInfo_Args , GetInfo_Reply , Error > :: new (self . connection . clone () , "org.varlink.resolver.GetInfo" , GetInfo_Args { }) } fn resolve (& mut self , r#interface : String) -> varlink :: MethodCall < Resolve_Args , Resolve_Reply , Error > { varlink :: MethodCall :: < Resolve_Args , Resolve_Reply , Error > :: new (self . connection . clone () , "org.varlink.resolver.Resolve" , Resolve_Args { r#interface }) } } # [allow (dead_code)] pub struct VarlinkInterfaceProxy { inner : Box < dyn VarlinkInterface + Send + Sync > , } # [allow (dead_code)] pub fn new (inner : Box < dyn VarlinkInterface + Send + Sync >) -> VarlinkInterfaceProxy { VarlinkInterfaceProxy { inner } } impl varlink :: Interface for VarlinkInterfaceProxy { fn get_description (& self) -> & 'static str { "# Interface to resolve reverse-domain interface names to\n# service adresses\ninterface org.varlink.resolver\n\n# Get a list of all resolvable interfaces and information\n# about the resolver's identity.\nmethod GetInfo() -> (\n  vendor: string,\n  product: string,\n  version: string,\n  url: string,\n  interfaces: []string\n)\n\n# Resolve an interface name to a registered varlink service address\nmethod Resolve(interface: string) -> (address: string)\n\nerror InterfaceNotFound (interface: string)\n" } fn get_name (& self) -> & 'static str { "org.varlink.resolver" } fn call_upgraded (& self , call : & mut varlink :: Call , bufreader : & mut dyn BufRead) -> varlink :: Result < Vec < u8 >> { self . inner . call_upgraded (call , bufreader) } fn call (& self , call : & mut varlink :: Call) -> varlink :: Result < () > { let req = call . request . unwrap () ; match req . method . as_ref () { "org.varlink.resolver.GetInfo" => self . inner . get_info (call as & mut dyn Call_GetInfo) , "org.varlink.resolver.Resolve" => { if let Some (args) = req . parameters . clone () { let args : Resolve_Args = match serde_json :: from_value (args) { Ok (v) => v , Err (e) => { let es = format ! ("{}" , e) ; let _ = call . reply_invalid_parameter (es . clone ()) ; return Err (varlink :: context ! (varlink :: ErrorKind :: SerdeJsonDe (es))) ; } } ; self . inner . resolve (call as & mut dyn Call_Resolve , args . r#interface) } else { call . reply_invalid_parameter ("parameters" . into ()) } } , m => { call . reply_method_not_found (String :: from (m)) } } } }