wsman-client.i

client declarations for openwsman swig bindings

%rename(Client) _WsManClient; %nodefault _WsManClient; typedef struct _WsManClient { } WsManClient;

 Document-class: Client

 Instances of Client represent a connection to a client used for
 sending WS-Management operation requests.

/

%extend _WsManClient {

/*
   Create a client connection.

   There are two ways to connect to a client, either by specifying a
   URL or by passing all client parameters separately

   call-seq:
    Client.new(uri)
    Client.new(host, port, path, scheme, username, password)

    Client.new("http://user:pass@host.domain.com:1234/path")
    Client.new("host.domain.com", 1234, "/path", "http", "user", "pass")

  /
_WsManClient( const char *uri ) {
  struct _WsManClient *client = wsmc_create_from_uri( uri );
  if (client == NULL)
    SWIG_exception( SWIG_ValueError, "Can't create Openwsman::Client from given URI" );

if defined(SWIGPYTHON) || defined(SWIGPERL) || defined(SWIGJAVA)

fail:

endif

  return client;
}

/*

  /
_WsManClient(const char *hostname,
            const int port, const char *path,
            const char *scheme,
            const char *username,
            const char *password) {
  struct _WsManClient *client = wsmc_create( hostname, port, path, scheme, username, password );
  if (client == NULL)
    SWIG_exception( SWIG_ValueError, "Can't create Openwsman::Client from given values" );

if defined(SWIGPYTHON) || defined(SWIGPERL) || defined(SWIGJAVA)

fail:

endif

  return client;
}

/* destructor   
~_WsManClient() {
  wsmc_release( $self );
}

/* set dumpfile */

if defined(SWIGRUBY)

%rename( "dumpfile=" ) set_dumpfile( FILE *f );

endif

/*
   Set the dumpfile (for debugging) to dump xml requests

   call-seq:
    client.dumpfile = File.open(...)

  /
void set_dumpfile( FILE *f ) {
  wsmc_set_dumpfile( $self, f );
}

/*
   Response code of the last request (HTTP response code)

   call-seq:
    client.reponse_code -> Integer

  /
long response_code() {
  return wsmc_get_response_code( $self );
}

%newobject scheme;
/*
   String representation of the transport scheme

   call-seq:
     client.scheme -> String

  /
char *scheme() {
  return wsmc_get_scheme( $self );
}

%newobject host;
/*
   The host part of the client URL

  /
char *host() {
  return wsmc_get_hostname( $self );
}

/*
   The TCP port used in the connection

  /
int port() {
  return wsmc_get_port( $self );
}

%newobject path;
/*
   The path of the clien URL

  /
char *path() {
  return wsmc_get_path( $self );
}

%newobject user;
/*
   The user name used for authentication

  /
char *user() {
  return wsmc_get_user( $self );
}

%newobject password;
/*
   The password used for authentication

  /
char *password() {
  return wsmc_get_password( $self );
}

/*
   The Transport instance associated to the client
  /
WsManTransport *transport() {
  wsmc_transport_init($self, NULL);
  wsmc_transport_set_auth_request_func( $self, auth_request_callback );

  return (WsManTransport *)$self;
}

/*
   Send a (raw) SOAP request to the client

   call-seq:
     client.send_request(XmlDoc.new("<xml ...>...</xml>")) -> Integer

  /
int send_request(WsXmlDocH request) {
  return wsman_send_request($self, request);
}

/*
   Build envelope from response

   call-seq:
     client.build_envelope_from_response() -> XmlDoc

  /
WsXmlDocH build_envelope_from_response() {
  return wsmc_build_envelope_from_response($self);
}

/*
   Get client encoding

   call-seq:
     client.encoding -> "utf-8"

  /
char *encoding() {
  return wsmc_get_encoding($self);
}

if defined(SWIGRUBY)

%rename( "encoding=" ) set_encoding( const char *encoding );

endif

/*
   Set client encoding

   call-seq:
     client.encoding = "utf-8"

  /
void set_encoding(const char *encoding) {
  wsmc_set_encoding($self, encoding);
}

/—————————————————————–/ /* actions */

/*
   WS-Identify

   identify: Sends an identify request

   call-seq:
     client.identify(options) -> XmlDoc

  /
WsXmlDocH identify( client_opt_t *options ) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_identify_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_identify_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_identify( $self, options );

endif

}

/*
   WS-Get

   get_from_epr: Get a resource via an endpoint reference

   call-seq:
     client.get_from_epr(options, end_point_reference) -> XmlDoc

  /
WsXmlDocH get_from_epr( client_opt_t *options , epr_t *epr) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.epr = epr;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_get_from_epr_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_get_from_epr_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_get_from_epr( $self, epr, options);

endif

}

/*
   WS-Delete

   delete_from_epr: Remove a resource via an endpoint reference

   call-seq:
     client.delete_from_epr(options, end_point_reference) -> XmlDoc

  /
WsXmlDocH delete_from_epr( client_opt_t *options , epr_t *epr) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.epr = epr;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_delete_from_epr_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_delete_from_epr_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_delete_from_epr( $self, epr, options);

endif

}

/*
   WS-Enumerate

   enumerate: List resources

   It is highly recommended to do an optimized enumeration by
   setting the client options
     options.flags = Openwsman::FLAG_ENUMERATION_OPTIMIZATION
     options.max_elements = 999
   to get the enumeration result as part of the http request.

   Otherwise separate pull requests are needed resulting in extra
   round-trips (client -> wsman -> cimom & back), dramatically
   affecting performance.

   call-seq:
     client.enumerate(options, filter, uri) -> XmlDoc

  /
WsXmlDocH enumerate( client_opt_t *options , filter_t *filter, char *resource_uri) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.filter = filter;
args.resource_uri = resource_uri;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_enumerate_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_enumerate_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_enumerate( $self, resource_uri, options, filter);

endif

}

/*
   WS-Transport

   pull: Get resources from enumeration context

   call-seq:
     client.pull(options, filter, uri, context) -> XmlDoc

  /
WsXmlDocH pull( client_opt_t *options , filter_t *filter, const char *resource_uri, const char *context) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.filter = filter;
args.resource_uri = resource_uri;
args.context = context;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_pull_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_pull_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_pull( $self, resource_uri, options, filter, context);

endif

}

/*
   WS-Create

   create: Create a resource

   call-seq:
     client.create(options, uri, xml, xml.size, "utf-8") -> XmlDoc

  /
WsXmlDocH create( client_opt_t *options, const char *resource_uri, const char *data, size_t size, const char *encoding = "utf-8") {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;
args.data = data;
args.size = size;
args.encoding = encoding;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_create_fromtext_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_create_fromtext_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_create_fromtext( $self, resource_uri, options, data, size, encoding);

endif

}

/*
   WS-Transport

   put: Change a resource

   call-seq:
     client.put(options, uri, xml, xml.size, "utf-8") -> XmlDoc

  /
WsXmlDocH put( client_opt_t *options, const char *resource_uri, const char *data, size_t size, const char *encoding = "utf-8") {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;
args.data = data;
args.size = size;
args.encoding = encoding;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_put_fromtext_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_put_fromtext_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_put_fromtext( $self, resource_uri, options, data, size, encoding);

endif

}

/*
   WS-Release

   release: Release enumeration context

   call-seq:
     client.release(options, uri, context) -> XmlDoc

  /
WsXmlDocH release( client_opt_t *options, const char *resource_uri, const char *context) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;
args.context = context;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_release_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_release_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_release( $self, resource_uri, options, context);

endif

}

/*
   WS-Transport

   get: Get a resource

   call-seq:
     client.get(options, uri) -> XmlDoc

  /
WsXmlDocH get( client_opt_t *options, const char *resource_uri) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_get_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_get_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_get( $self, resource_uri, options);

endif

}

/*
   WS-Transport

   delete: Delete a resource

   call-seq:
     client.delete(options, uri) -> XmlDoc

  /
WsXmlDocH delete( client_opt_t *options, const char *resource_uri) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_delete_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_delete_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_delete( $self, resource_uri, options);

endif

}

/*
   WS-Invoke

   invoke: Invoke a resource function

   call-seq:
     client.invoke(options, uri, "method-name") -> XmlDoc
     client.invoke(options, uri, "method-name", xml_doc) -> XmlDoc

  /
WsXmlDocH invoke( client_opt_t *options, const char *resource_uri, const char *method, WsXmlDocH data = NULL) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;
args.method = method;
args.method_args = data;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_invoke_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_invoke_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_invoke( $self, resource_uri, options, method, data);

endif

}

/*
   WS-Eventing

   subscribe: Subscribe a listener to events

   call-seq:
     client.subscribe(options, filter, uri) -> XmlDoc

  /
WsXmlDocH subscribe(client_opt_t *options, filter_t *filter, const char *resource_uri) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.filter = filter;
args.resource_uri = resource_uri;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_subscribe_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_subscribe_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_subscribe($self,  resource_uri, options, filter);

endif

}

/*
   WS-Eventing

   unsubscribe: Remove a listener from events

   call-seq:
     client.unsubscribe(options, filter, uri, identifier) -> XmlDoc

  /
WsXmlDocH unsubscribe(client_opt_t *options, filter_t *filter, const char *resource_uri, const char *identifier) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.filter = filter;
args.resource_uri = resource_uri;
args.identifier = identifier;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_unsubscribe_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_unsubscribe_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_unsubscribe($self, resource_uri, options, identifier);

endif

}

/*
   WS-Eventing

   renew: Renew a subscription

   call-seq:
     client.renew(options, uri, identifier) -> XmlDoc

  /
WsXmlDocH renew(client_opt_t *options , char *resource_uri, char *identifier) {

if RUBY_VERSION > 18 /* YARV */

wsmc_action_args_t args;
args.client = $self;
args.options = options;
args.resource_uri = resource_uri;
args.identifier = identifier;

if RUBY_VERSION > 20 /* New threading model */

return (WsXmlDocH)rb_thread_call_without_gvl((void * (*)(void *))ruby_renew_thread, &args, RUBY_UBF_IO, 0);

else

return (WsXmlDocH)rb_thread_blocking_region((rb_blocking_function_t*)ruby_renew_thread, &args, RUBY_UBF_IO, 0);

endif else

return wsmc_action_renew($self, resource_uri, options, identifier);

endif

}

/*
   Get a string representation of the last fault

   call-seq:
     client.fault_string -> String

  /
char *fault_string() {
  return wsmc_get_fault_string($self);
}

/*
   Get a numeric representation of the last fault

   call-seq:
     client.last_error -> Integer

  /
 int last_error() {
   return wsmc_get_last_error($self);
 }

}