| /* |
| * 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; |
| } |
| |
| /* |
| * :nodoc: |
| */ |
| _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); |
| } |
| } |