class Openwsman::Client
Instances of Client represent a connection to a client used for sending WS-Management operation requests.
Public Class Methods
new(uri)
click to toggle source
new(host, port, path, scheme, username, password)
new("http://user:pass@host.domain.com:1234/path")
new("host.domain.com", 1234, "/path", "http", "user", "pass")
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
( 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" );
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" );
return client;
}
/* destructor */
~_WsManClient() {
wsmc_release( $self );
}
/* set dumpfile */
%rename( "dumpfile=" ) set_dumpfile( FILE *f );
/*
* 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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
Public Instance Methods
build_envelope_from_response() → XmlDoc
click to toggle source
Build envelope from response
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
delete(options, uri) → XmlDoc
click to toggle source
WS-Transport
delete: Delete a resource
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);
}
}
delete_from_epr(options, end_point_reference) → XmlDoc
click to toggle source
WS-Delete
delete_from_epr: Remove a resource via an endpoint reference
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);
}
}
dumpfile = File.open(...)
click to toggle source
Set the dumpfile (for debugging) to dump xml requests
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
encoding → "utf-8"
click to toggle source
Get client encoding
char *encoding() {
return wsmc_get_encoding($self);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
encoding = "utf-8"
click to toggle source
Set client encoding
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);
}
}
enumerate(options, filter, uri) → XmlDoc
click to toggle source
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.
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);
}
}
fault_string → String
click to toggle source
Get a string representation of the last fault
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);
}
}
get(options, uri) → XmlDoc
click to toggle source
WS-Transport
get: Get a resource
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);
}
}
get_from_epr(options, end_point_reference) → XmlDoc
click to toggle source
WS-Get
get_from_epr: Get a resource via an endpoint reference
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);
}
}
host()
click to toggle source
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
identify(options) → XmlDoc
click to toggle source
WS-Identify
identify: Sends an identify request
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);
}
}
last_error → Integer
click to toggle source
Get a numeric representation of the last fault
int last_error() {
return wsmc_get_last_error($self);
}
}
password()
click to toggle source
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
path()
click to toggle source
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
port()
click to toggle source
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
pull(options, filter, uri, context) → XmlDoc
click to toggle source
WS-Transport
pull: Get resources from enumeration context
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);
}
}
release(options, uri, context) → XmlDoc
click to toggle source
WS-Release
release: Release enumeration context
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);
}
}
renew(options, uri, identifier) → XmlDoc
click to toggle source
WS-Eventing
renew: Renew a subscription
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);
}
}
reponse_code → Integer
click to toggle source
Response code of the last request (HTTP response code)
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
scheme → String
click to toggle source
String representation of the transport scheme
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
send_request(XmlDoc.new("<xml ...>...</xml>")) → Integer
click to toggle source
Send a (raw) SOAP request to the client
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
subscribe(options, filter, uri) → XmlDoc
click to toggle source
WS-Eventing
subscribe: Subscribe a listener to events
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);
}
}
transport()
click to toggle source
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}
unsubscribe(options, filter, uri, identifier) → XmlDoc
click to toggle source
WS-Eventing
unsubscribe: Remove a listener from events
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);
}
}
user()
click to toggle source
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);
}
%rename( "encoding=" ) set_encoding( const char *encoding );
/*
* 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);
}
}