4
* axis2_stub_EucalyptusNC.c
6
* This file was auto-generated from WSDL for "EucalyptusNC|http://eucalyptus.ucsb.edu/" service
7
* by the Apache Axis2/Java version: 1.4 Built on : Apr 26, 2008 (06:24:30 EDT)
10
#include "axis2_stub_EucalyptusNC.h"
11
#include <axis2_msg.h>
14
* axis2_stub_EucalyptusNC C implementation
18
axis2_stub_create_EucalyptusNC(const axutil_env_t *env,
19
axis2_char_t *client_home,
20
axis2_char_t *endpoint_uri)
22
axis2_stub_t *stub = NULL;
23
axis2_endpoint_ref_t *endpoint_ref = NULL;
24
AXIS2_FUNC_PARAM_CHECK (client_home, env, NULL)
26
if (NULL == endpoint_uri)
28
endpoint_uri = axis2_stub_get_endpoint_uri_of_EucalyptusNC(env);
31
endpoint_ref = axis2_endpoint_ref_create(env, endpoint_uri);
33
stub = axis2_stub_create_with_endpoint_ref_and_client_home (env, endpoint_ref, client_home);
37
if(NULL != endpoint_ref)
39
axis2_endpoint_ref_free(endpoint_ref, env);
45
axis2_stub_populate_services_for_EucalyptusNC(stub, env);
51
axis2_stub_populate_services_for_EucalyptusNC(axis2_stub_t *stub, const axutil_env_t *env)
53
axis2_svc_client_t *svc_client = NULL;
54
axutil_qname_t *svc_qname = NULL;
55
axutil_qname_t *op_qname = NULL;
56
axis2_svc_t *svc = NULL;
57
axis2_op_t *op = NULL;
58
axis2_op_t *annon_op = NULL;
59
axis2_msg_t *msg_out = NULL;
60
axis2_msg_t *msg_in = NULL;
61
axis2_msg_t *msg_out_fault = NULL;
62
axis2_msg_t *msg_in_fault = NULL;
65
/* Modifying the Service */
66
svc_client = axis2_stub_get_svc_client (stub, env );
67
svc = (axis2_svc_t*)axis2_svc_client_get_svc( svc_client, env );
69
annon_op = axis2_svc_get_op_with_name(svc, env, AXIS2_ANON_OUT_IN_OP);
70
msg_out = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT);
71
msg_in = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN);
72
msg_out_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT_FAULT);
73
msg_in_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN_FAULT);
75
svc_qname = axutil_qname_create(env,"EucalyptusNC" ,NULL, NULL);
76
axis2_svc_set_qname (svc, env, svc_qname);
78
/* creating the operations*/
81
op_qname = axutil_qname_create(env,
83
"http://eucalyptus.ucsb.edu/",
85
op = axis2_op_create_with_qname(env, op_qname);
87
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
89
axis2_msg_increment_ref(msg_out, env);
90
axis2_msg_increment_ref(msg_in, env);
91
axis2_msg_increment_ref(msg_out_fault, env);
92
axis2_msg_increment_ref(msg_in_fault, env);
93
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
94
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
95
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
96
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
98
axis2_svc_add_op(svc, env, op);
101
op_qname = axutil_qname_create(env,
103
"http://eucalyptus.ucsb.edu/",
105
op = axis2_op_create_with_qname(env, op_qname);
107
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
109
axis2_msg_increment_ref(msg_out, env);
110
axis2_msg_increment_ref(msg_in, env);
111
axis2_msg_increment_ref(msg_out_fault, env);
112
axis2_msg_increment_ref(msg_in_fault, env);
113
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
114
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
115
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
116
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
118
axis2_svc_add_op(svc, env, op);
121
op_qname = axutil_qname_create(env,
122
"ncGetConsoleOutput" ,
123
"http://eucalyptus.ucsb.edu/",
125
op = axis2_op_create_with_qname(env, op_qname);
127
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
129
axis2_msg_increment_ref(msg_out, env);
130
axis2_msg_increment_ref(msg_in, env);
131
axis2_msg_increment_ref(msg_out_fault, env);
132
axis2_msg_increment_ref(msg_in_fault, env);
133
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
134
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
135
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
136
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
138
axis2_svc_add_op(svc, env, op);
141
op_qname = axutil_qname_create(env,
143
"http://eucalyptus.ucsb.edu/",
145
op = axis2_op_create_with_qname(env, op_qname);
147
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
149
axis2_msg_increment_ref(msg_out, env);
150
axis2_msg_increment_ref(msg_in, env);
151
axis2_msg_increment_ref(msg_out_fault, env);
152
axis2_msg_increment_ref(msg_in_fault, env);
153
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
154
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
155
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
156
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
158
axis2_svc_add_op(svc, env, op);
161
op_qname = axutil_qname_create(env,
162
"ncDescribeInstances" ,
163
"http://eucalyptus.ucsb.edu/",
165
op = axis2_op_create_with_qname(env, op_qname);
167
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
169
axis2_msg_increment_ref(msg_out, env);
170
axis2_msg_increment_ref(msg_in, env);
171
axis2_msg_increment_ref(msg_out_fault, env);
172
axis2_msg_increment_ref(msg_in_fault, env);
173
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
174
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
175
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
176
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
178
axis2_svc_add_op(svc, env, op);
181
op_qname = axutil_qname_create(env,
183
"http://eucalyptus.ucsb.edu/",
185
op = axis2_op_create_with_qname(env, op_qname);
187
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
189
axis2_msg_increment_ref(msg_out, env);
190
axis2_msg_increment_ref(msg_in, env);
191
axis2_msg_increment_ref(msg_out_fault, env);
192
axis2_msg_increment_ref(msg_in_fault, env);
193
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
194
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
195
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
196
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
198
axis2_svc_add_op(svc, env, op);
201
op_qname = axutil_qname_create(env,
203
"http://eucalyptus.ucsb.edu/",
205
op = axis2_op_create_with_qname(env, op_qname);
207
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
209
axis2_msg_increment_ref(msg_out, env);
210
axis2_msg_increment_ref(msg_in, env);
211
axis2_msg_increment_ref(msg_out_fault, env);
212
axis2_msg_increment_ref(msg_in_fault, env);
213
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
214
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
215
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
216
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
218
axis2_svc_add_op(svc, env, op);
221
op_qname = axutil_qname_create(env,
222
"ncDescribeResource" ,
223
"http://eucalyptus.ucsb.edu/",
225
op = axis2_op_create_with_qname(env, op_qname);
227
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
229
axis2_msg_increment_ref(msg_out, env);
230
axis2_msg_increment_ref(msg_in, env);
231
axis2_msg_increment_ref(msg_out_fault, env);
232
axis2_msg_increment_ref(msg_in_fault, env);
233
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
234
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
235
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
236
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
238
axis2_svc_add_op(svc, env, op);
241
op_qname = axutil_qname_create(env,
242
"ncTerminateInstance" ,
243
"http://eucalyptus.ucsb.edu/",
245
op = axis2_op_create_with_qname(env, op_qname);
247
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
249
axis2_msg_increment_ref(msg_out, env);
250
axis2_msg_increment_ref(msg_in, env);
251
axis2_msg_increment_ref(msg_out_fault, env);
252
axis2_msg_increment_ref(msg_in_fault, env);
253
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
254
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
255
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
256
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
258
axis2_svc_add_op(svc, env, op);
261
op_qname = axutil_qname_create(env,
263
"http://eucalyptus.ucsb.edu/",
265
op = axis2_op_create_with_qname(env, op_qname);
267
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
269
axis2_msg_increment_ref(msg_out, env);
270
axis2_msg_increment_ref(msg_in, env);
271
axis2_msg_increment_ref(msg_out_fault, env);
272
axis2_msg_increment_ref(msg_in_fault, env);
273
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
274
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
275
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
276
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
278
axis2_svc_add_op(svc, env, op);
284
*return end point picked from wsdl
287
axis2_stub_get_endpoint_uri_of_EucalyptusNC( const axutil_env_t *env )
289
axis2_char_t *endpoint_uri = NULL;
290
/* set the address from here */
292
endpoint_uri = "http://spinner.cs.ucsb.edu:9090/axis2/services/EucalyptusNC";
300
* auto generated method signature
301
* for "ncRunInstance|http://eucalyptus.ucsb.edu/" operation.
303
* @param _ncRunInstance
305
* @return adb_ncRunInstanceResponse_t*
307
adb_ncRunInstanceResponse_t*
308
axis2_stub_op_EucalyptusNC_ncRunInstance( axis2_stub_t *stub, const axutil_env_t *env,
309
adb_ncRunInstance_t* _ncRunInstance)
311
axis2_svc_client_t *svc_client = NULL;
312
axis2_options_t *options = NULL;
313
axiom_node_t *ret_node = NULL;
315
const axis2_char_t *soap_action = NULL;
316
axutil_qname_t *op_qname = NULL;
317
axiom_node_t *payload = NULL;
318
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
320
axutil_string_t *soap_act = NULL;
321
adb_ncRunInstanceResponse_t* ret_val = NULL;
323
payload = adb_ncRunInstance_serialize(_ncRunInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
325
svc_client = axis2_stub_get_svc_client(stub, env );
331
options = axis2_stub_get_options( stub, env);
334
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
335
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
338
soap_action = axis2_options_get_action( options, env );
339
if (NULL == soap_action)
341
is_soap_act_set = AXIS2_FALSE;
342
soap_action = "EucalyptusNC#ncRunInstance";
344
soap_act = axutil_string_create(env, "EucalyptusNC#ncRunInstance");
345
axis2_options_set_soap_action(options, env, soap_act);
347
axis2_options_set_action( options, env, soap_action );
350
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
352
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
354
if (!is_soap_act_set)
357
axis2_options_set_soap_action(options, env, NULL);
359
axis2_options_set_action( options, env, NULL);
364
if ( NULL == ret_node )
368
ret_val = adb_ncRunInstanceResponse_create(env);
370
if(adb_ncRunInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
374
adb_ncRunInstanceResponse_free(ret_val, env);
377
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncRunInstanceResponse_deserialize: "
378
"This should be due to an invalid XML");
386
* auto generated method signature
387
* for "ncRebootInstance|http://eucalyptus.ucsb.edu/" operation.
389
* @param _ncRebootInstance
391
* @return adb_ncRebootInstanceResponse_t*
393
adb_ncRebootInstanceResponse_t*
394
axis2_stub_op_EucalyptusNC_ncRebootInstance( axis2_stub_t *stub, const axutil_env_t *env,
395
adb_ncRebootInstance_t* _ncRebootInstance)
397
axis2_svc_client_t *svc_client = NULL;
398
axis2_options_t *options = NULL;
399
axiom_node_t *ret_node = NULL;
401
const axis2_char_t *soap_action = NULL;
402
axutil_qname_t *op_qname = NULL;
403
axiom_node_t *payload = NULL;
404
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
406
axutil_string_t *soap_act = NULL;
407
adb_ncRebootInstanceResponse_t* ret_val = NULL;
409
payload = adb_ncRebootInstance_serialize(_ncRebootInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
411
svc_client = axis2_stub_get_svc_client(stub, env );
417
options = axis2_stub_get_options( stub, env);
420
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
421
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
424
soap_action = axis2_options_get_action( options, env );
425
if (NULL == soap_action)
427
is_soap_act_set = AXIS2_FALSE;
428
soap_action = "EucalyptusNC#ncRebootInstance";
430
soap_act = axutil_string_create(env, "EucalyptusNC#ncRebootInstance");
431
axis2_options_set_soap_action(options, env, soap_act);
433
axis2_options_set_action( options, env, soap_action );
436
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
438
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
440
if (!is_soap_act_set)
443
axis2_options_set_soap_action(options, env, NULL);
445
axis2_options_set_action( options, env, NULL);
450
if ( NULL == ret_node )
454
ret_val = adb_ncRebootInstanceResponse_create(env);
456
if(adb_ncRebootInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
460
adb_ncRebootInstanceResponse_free(ret_val, env);
463
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncRebootInstanceResponse_deserialize: "
464
"This should be due to an invalid XML");
472
* auto generated method signature
473
* for "ncGetConsoleOutput|http://eucalyptus.ucsb.edu/" operation.
475
* @param _ncGetConsoleOutput
477
* @return adb_ncGetConsoleOutputResponse_t*
479
adb_ncGetConsoleOutputResponse_t*
480
axis2_stub_op_EucalyptusNC_ncGetConsoleOutput( axis2_stub_t *stub, const axutil_env_t *env,
481
adb_ncGetConsoleOutput_t* _ncGetConsoleOutput)
483
axis2_svc_client_t *svc_client = NULL;
484
axis2_options_t *options = NULL;
485
axiom_node_t *ret_node = NULL;
487
const axis2_char_t *soap_action = NULL;
488
axutil_qname_t *op_qname = NULL;
489
axiom_node_t *payload = NULL;
490
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
492
axutil_string_t *soap_act = NULL;
493
adb_ncGetConsoleOutputResponse_t* ret_val = NULL;
495
payload = adb_ncGetConsoleOutput_serialize(_ncGetConsoleOutput, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
497
svc_client = axis2_stub_get_svc_client(stub, env );
503
options = axis2_stub_get_options( stub, env);
506
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
507
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
510
soap_action = axis2_options_get_action( options, env );
511
if (NULL == soap_action)
513
is_soap_act_set = AXIS2_FALSE;
514
soap_action = "EucalyptusNC#ncGetConsoleOutput";
516
soap_act = axutil_string_create(env, "EucalyptusNC#ncGetConsoleOutput");
517
axis2_options_set_soap_action(options, env, soap_act);
519
axis2_options_set_action( options, env, soap_action );
522
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
524
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
526
if (!is_soap_act_set)
529
axis2_options_set_soap_action(options, env, NULL);
531
axis2_options_set_action( options, env, NULL);
536
if ( NULL == ret_node )
540
ret_val = adb_ncGetConsoleOutputResponse_create(env);
542
if(adb_ncGetConsoleOutputResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
546
adb_ncGetConsoleOutputResponse_free(ret_val, env);
549
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncGetConsoleOutputResponse_deserialize: "
550
"This should be due to an invalid XML");
558
* auto generated method signature
559
* for "ncDetachVolume|http://eucalyptus.ucsb.edu/" operation.
561
* @param _ncDetachVolume
563
* @return adb_ncDetachVolumeResponse_t*
565
adb_ncDetachVolumeResponse_t*
566
axis2_stub_op_EucalyptusNC_ncDetachVolume( axis2_stub_t *stub, const axutil_env_t *env,
567
adb_ncDetachVolume_t* _ncDetachVolume)
569
axis2_svc_client_t *svc_client = NULL;
570
axis2_options_t *options = NULL;
571
axiom_node_t *ret_node = NULL;
573
const axis2_char_t *soap_action = NULL;
574
axutil_qname_t *op_qname = NULL;
575
axiom_node_t *payload = NULL;
576
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
578
axutil_string_t *soap_act = NULL;
579
adb_ncDetachVolumeResponse_t* ret_val = NULL;
581
payload = adb_ncDetachVolume_serialize(_ncDetachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
583
svc_client = axis2_stub_get_svc_client(stub, env );
589
options = axis2_stub_get_options( stub, env);
592
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
593
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
596
soap_action = axis2_options_get_action( options, env );
597
if (NULL == soap_action)
599
is_soap_act_set = AXIS2_FALSE;
600
soap_action = "EucalyptusNC#ncDetachVolume";
602
soap_act = axutil_string_create(env, "EucalyptusNC#ncDetachVolume");
603
axis2_options_set_soap_action(options, env, soap_act);
605
axis2_options_set_action( options, env, soap_action );
608
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
610
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
612
if (!is_soap_act_set)
615
axis2_options_set_soap_action(options, env, NULL);
617
axis2_options_set_action( options, env, NULL);
622
if ( NULL == ret_node )
626
ret_val = adb_ncDetachVolumeResponse_create(env);
628
if(adb_ncDetachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
632
adb_ncDetachVolumeResponse_free(ret_val, env);
635
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDetachVolumeResponse_deserialize: "
636
"This should be due to an invalid XML");
644
* auto generated method signature
645
* for "ncDescribeInstances|http://eucalyptus.ucsb.edu/" operation.
647
* @param _ncDescribeInstances
649
* @return adb_ncDescribeInstancesResponse_t*
651
adb_ncDescribeInstancesResponse_t*
652
axis2_stub_op_EucalyptusNC_ncDescribeInstances( axis2_stub_t *stub, const axutil_env_t *env,
653
adb_ncDescribeInstances_t* _ncDescribeInstances)
655
axis2_svc_client_t *svc_client = NULL;
656
axis2_options_t *options = NULL;
657
axiom_node_t *ret_node = NULL;
659
const axis2_char_t *soap_action = NULL;
660
axutil_qname_t *op_qname = NULL;
661
axiom_node_t *payload = NULL;
662
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
664
axutil_string_t *soap_act = NULL;
665
adb_ncDescribeInstancesResponse_t* ret_val = NULL;
667
payload = adb_ncDescribeInstances_serialize(_ncDescribeInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
669
svc_client = axis2_stub_get_svc_client(stub, env );
675
options = axis2_stub_get_options( stub, env);
678
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
679
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
682
soap_action = axis2_options_get_action( options, env );
683
if (NULL == soap_action)
685
is_soap_act_set = AXIS2_FALSE;
686
soap_action = "EucalyptusNC#ncDescribeInstances";
688
soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeInstances");
689
axis2_options_set_soap_action(options, env, soap_act);
691
axis2_options_set_action( options, env, soap_action );
694
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
696
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
698
if (!is_soap_act_set)
701
axis2_options_set_soap_action(options, env, NULL);
703
axis2_options_set_action( options, env, NULL);
708
if ( NULL == ret_node )
712
ret_val = adb_ncDescribeInstancesResponse_create(env);
714
if(adb_ncDescribeInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
718
adb_ncDescribeInstancesResponse_free(ret_val, env);
721
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDescribeInstancesResponse_deserialize: "
722
"This should be due to an invalid XML");
730
* auto generated method signature
731
* for "ncAttachVolume|http://eucalyptus.ucsb.edu/" operation.
733
* @param _ncAttachVolume
735
* @return adb_ncAttachVolumeResponse_t*
737
adb_ncAttachVolumeResponse_t*
738
axis2_stub_op_EucalyptusNC_ncAttachVolume( axis2_stub_t *stub, const axutil_env_t *env,
739
adb_ncAttachVolume_t* _ncAttachVolume)
741
axis2_svc_client_t *svc_client = NULL;
742
axis2_options_t *options = NULL;
743
axiom_node_t *ret_node = NULL;
745
const axis2_char_t *soap_action = NULL;
746
axutil_qname_t *op_qname = NULL;
747
axiom_node_t *payload = NULL;
748
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
750
axutil_string_t *soap_act = NULL;
751
adb_ncAttachVolumeResponse_t* ret_val = NULL;
753
payload = adb_ncAttachVolume_serialize(_ncAttachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
755
svc_client = axis2_stub_get_svc_client(stub, env );
761
options = axis2_stub_get_options( stub, env);
764
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
765
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
768
soap_action = axis2_options_get_action( options, env );
769
if (NULL == soap_action)
771
is_soap_act_set = AXIS2_FALSE;
772
soap_action = "EucalyptusNC#ncAttachVolume";
774
soap_act = axutil_string_create(env, "EucalyptusNC#ncAttachVolume");
775
axis2_options_set_soap_action(options, env, soap_act);
777
axis2_options_set_action( options, env, soap_action );
780
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
782
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
784
if (!is_soap_act_set)
787
axis2_options_set_soap_action(options, env, NULL);
789
axis2_options_set_action( options, env, NULL);
794
if ( NULL == ret_node )
798
ret_val = adb_ncAttachVolumeResponse_create(env);
800
if(adb_ncAttachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
804
adb_ncAttachVolumeResponse_free(ret_val, env);
807
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncAttachVolumeResponse_deserialize: "
808
"This should be due to an invalid XML");
816
* auto generated method signature
817
* for "ncPowerDown|http://eucalyptus.ucsb.edu/" operation.
819
* @param _ncPowerDown
821
* @return adb_ncPowerDownResponse_t*
823
adb_ncPowerDownResponse_t*
824
axis2_stub_op_EucalyptusNC_ncPowerDown( axis2_stub_t *stub, const axutil_env_t *env,
825
adb_ncPowerDown_t* _ncPowerDown)
827
axis2_svc_client_t *svc_client = NULL;
828
axis2_options_t *options = NULL;
829
axiom_node_t *ret_node = NULL;
831
const axis2_char_t *soap_action = NULL;
832
axutil_qname_t *op_qname = NULL;
833
axiom_node_t *payload = NULL;
834
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
836
axutil_string_t *soap_act = NULL;
837
adb_ncPowerDownResponse_t* ret_val = NULL;
839
payload = adb_ncPowerDown_serialize(_ncPowerDown, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
841
svc_client = axis2_stub_get_svc_client(stub, env );
847
options = axis2_stub_get_options( stub, env);
850
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
851
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
854
soap_action = axis2_options_get_action( options, env );
855
if (NULL == soap_action)
857
is_soap_act_set = AXIS2_FALSE;
858
soap_action = "EucalyptusNC#ncPowerDown";
860
soap_act = axutil_string_create(env, "EucalyptusNC#ncPowerDown");
861
axis2_options_set_soap_action(options, env, soap_act);
863
axis2_options_set_action( options, env, soap_action );
866
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
868
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
870
if (!is_soap_act_set)
873
axis2_options_set_soap_action(options, env, NULL);
875
axis2_options_set_action( options, env, NULL);
880
if ( NULL == ret_node )
884
ret_val = adb_ncPowerDownResponse_create(env);
886
if(adb_ncPowerDownResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
890
adb_ncPowerDownResponse_free(ret_val, env);
893
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncPowerDownResponse_deserialize: "
894
"This should be due to an invalid XML");
902
* auto generated method signature
903
* for "ncDescribeResource|http://eucalyptus.ucsb.edu/" operation.
905
* @param _ncDescribeResource
907
* @return adb_ncDescribeResourceResponse_t*
909
adb_ncDescribeResourceResponse_t*
910
axis2_stub_op_EucalyptusNC_ncDescribeResource( axis2_stub_t *stub, const axutil_env_t *env,
911
adb_ncDescribeResource_t* _ncDescribeResource)
913
axis2_svc_client_t *svc_client = NULL;
914
axis2_options_t *options = NULL;
915
axiom_node_t *ret_node = NULL;
917
const axis2_char_t *soap_action = NULL;
918
axutil_qname_t *op_qname = NULL;
919
axiom_node_t *payload = NULL;
920
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
922
axutil_string_t *soap_act = NULL;
923
adb_ncDescribeResourceResponse_t* ret_val = NULL;
925
payload = adb_ncDescribeResource_serialize(_ncDescribeResource, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
927
svc_client = axis2_stub_get_svc_client(stub, env );
933
options = axis2_stub_get_options( stub, env);
936
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
937
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
940
soap_action = axis2_options_get_action( options, env );
941
if (NULL == soap_action)
943
is_soap_act_set = AXIS2_FALSE;
944
soap_action = "EucalyptusNC#ncDescribeResource";
946
soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeResource");
947
axis2_options_set_soap_action(options, env, soap_act);
949
axis2_options_set_action( options, env, soap_action );
952
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
954
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
956
if (!is_soap_act_set)
959
axis2_options_set_soap_action(options, env, NULL);
961
axis2_options_set_action( options, env, NULL);
966
if ( NULL == ret_node )
970
ret_val = adb_ncDescribeResourceResponse_create(env);
972
if(adb_ncDescribeResourceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
976
adb_ncDescribeResourceResponse_free(ret_val, env);
979
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDescribeResourceResponse_deserialize: "
980
"This should be due to an invalid XML");
988
* auto generated method signature
989
* for "ncTerminateInstance|http://eucalyptus.ucsb.edu/" operation.
991
* @param _ncTerminateInstance
993
* @return adb_ncTerminateInstanceResponse_t*
995
adb_ncTerminateInstanceResponse_t*
996
axis2_stub_op_EucalyptusNC_ncTerminateInstance( axis2_stub_t *stub, const axutil_env_t *env,
997
adb_ncTerminateInstance_t* _ncTerminateInstance)
999
axis2_svc_client_t *svc_client = NULL;
1000
axis2_options_t *options = NULL;
1001
axiom_node_t *ret_node = NULL;
1003
const axis2_char_t *soap_action = NULL;
1004
axutil_qname_t *op_qname = NULL;
1005
axiom_node_t *payload = NULL;
1006
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1008
axutil_string_t *soap_act = NULL;
1009
adb_ncTerminateInstanceResponse_t* ret_val = NULL;
1011
payload = adb_ncTerminateInstance_serialize(_ncTerminateInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1013
svc_client = axis2_stub_get_svc_client(stub, env );
1019
options = axis2_stub_get_options( stub, env);
1020
if (NULL == options)
1022
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1023
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1026
soap_action = axis2_options_get_action( options, env );
1027
if (NULL == soap_action)
1029
is_soap_act_set = AXIS2_FALSE;
1030
soap_action = "EucalyptusNC#ncTerminateInstance";
1032
soap_act = axutil_string_create(env, "EucalyptusNC#ncTerminateInstance");
1033
axis2_options_set_soap_action(options, env, soap_act);
1035
axis2_options_set_action( options, env, soap_action );
1038
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1040
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1042
if (!is_soap_act_set)
1045
axis2_options_set_soap_action(options, env, NULL);
1047
axis2_options_set_action( options, env, NULL);
1052
if ( NULL == ret_node )
1056
ret_val = adb_ncTerminateInstanceResponse_create(env);
1058
if(adb_ncTerminateInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1062
adb_ncTerminateInstanceResponse_free(ret_val, env);
1065
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncTerminateInstanceResponse_deserialize: "
1066
"This should be due to an invalid XML");
1074
* auto generated method signature
1075
* for "ncStartNetwork|http://eucalyptus.ucsb.edu/" operation.
1077
* @param _ncStartNetwork
1079
* @return adb_ncStartNetworkResponse_t*
1081
adb_ncStartNetworkResponse_t*
1082
axis2_stub_op_EucalyptusNC_ncStartNetwork( axis2_stub_t *stub, const axutil_env_t *env,
1083
adb_ncStartNetwork_t* _ncStartNetwork)
1085
axis2_svc_client_t *svc_client = NULL;
1086
axis2_options_t *options = NULL;
1087
axiom_node_t *ret_node = NULL;
1089
const axis2_char_t *soap_action = NULL;
1090
axutil_qname_t *op_qname = NULL;
1091
axiom_node_t *payload = NULL;
1092
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1094
axutil_string_t *soap_act = NULL;
1095
adb_ncStartNetworkResponse_t* ret_val = NULL;
1097
payload = adb_ncStartNetwork_serialize(_ncStartNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1099
svc_client = axis2_stub_get_svc_client(stub, env );
1105
options = axis2_stub_get_options( stub, env);
1106
if (NULL == options)
1108
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1109
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1112
soap_action = axis2_options_get_action( options, env );
1113
if (NULL == soap_action)
1115
is_soap_act_set = AXIS2_FALSE;
1116
soap_action = "EucalyptusNC#ncStartNetwork";
1118
soap_act = axutil_string_create(env, "EucalyptusNC#ncStartNetwork");
1119
axis2_options_set_soap_action(options, env, soap_act);
1121
axis2_options_set_action( options, env, soap_action );
1124
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1126
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1128
if (!is_soap_act_set)
1131
axis2_options_set_soap_action(options, env, NULL);
1133
axis2_options_set_action( options, env, NULL);
1138
if ( NULL == ret_node )
1142
ret_val = adb_ncStartNetworkResponse_create(env);
1144
if(adb_ncStartNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1148
adb_ncStartNetworkResponse_free(ret_val, env);
1151
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncStartNetworkResponse_deserialize: "
1152
"This should be due to an invalid XML");
1160
struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data
1163
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRunInstanceResponse_t* _ncRunInstanceResponse, void *data);
1164
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1167
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncRunInstance(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1169
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1170
struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data* callback_data = NULL;
1171
void *user_data = NULL;
1173
axis2_status_t status;
1175
callback_data = (struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data*)axis2_callback_get_data(callback);
1177
user_data = callback_data->data;
1178
on_error = callback_data->on_error;
1180
status = on_error(env, exception, user_data);
1184
AXIS2_FREE(env->allocator, callback_data);
1189
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncRunInstance(axis2_callback_t *callback, const axutil_env_t *env)
1191
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRunInstanceResponse_t* _ncRunInstanceResponse, void *data);
1192
struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data* callback_data = NULL;
1193
void *user_data = NULL;
1194
axis2_status_t status = AXIS2_SUCCESS;
1196
adb_ncRunInstanceResponse_t* ret_val = NULL;
1199
axiom_node_t *ret_node = NULL;
1200
axiom_soap_envelope_t *soap_envelope = NULL;
1204
callback_data = (struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data*)axis2_callback_get_data(callback);
1206
soap_envelope = axis2_callback_get_envelope(callback, env);
1209
axiom_soap_body_t *soap_body;
1210
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1213
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1216
ret_node = axiom_node_get_first_child(body_node, env);
1223
user_data = callback_data->data;
1224
on_complete = callback_data->on_complete;
1227
if(ret_node != NULL)
1229
ret_val = adb_ncRunInstanceResponse_create(env);
1231
if(adb_ncRunInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1233
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1234
"This should be due to an invalid XML");
1235
adb_ncRunInstanceResponse_free(ret_val, env);
1243
status = on_complete(env, ret_val, user_data);
1248
AXIS2_FREE(env->allocator, callback_data);
1254
* auto generated method signature for asynchronous invocations
1255
* for "ncRunInstance|http://eucalyptus.ucsb.edu/" operation.
1258
* @param _ncRunInstance
1259
* @param on_complete callback to handle on complete
1260
* @param on_error callback to handle on error
1262
void axis2_stub_start_op_EucalyptusNC_ncRunInstance( axis2_stub_t *stub, const axutil_env_t *env,
1263
adb_ncRunInstance_t* _ncRunInstance,
1265
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRunInstanceResponse_t* _ncRunInstanceResponse, void *data) ,
1266
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
1269
axis2_callback_t *callback = NULL;
1271
axis2_svc_client_t *svc_client = NULL;
1272
axis2_options_t *options = NULL;
1274
const axis2_char_t *soap_action = NULL;
1275
axiom_node_t *payload = NULL;
1277
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1279
axutil_string_t *soap_act = NULL;
1282
struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data *callback_data;
1284
callback_data = (struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data*) AXIS2_MALLOC(env->allocator,
1285
sizeof(struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data));
1286
if(NULL == callback_data)
1288
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
1293
payload = adb_ncRunInstance_serialize(_ncRunInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1298
options = axis2_stub_get_options( stub, env);
1299
if (NULL == options)
1301
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1302
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
1305
svc_client = axis2_stub_get_svc_client (stub, env);
1306
soap_action =axis2_options_get_action (options, env);
1307
if (NULL == soap_action)
1309
is_soap_act_set = AXIS2_FALSE;
1310
soap_action = "EucalyptusNC#ncRunInstance";
1312
soap_act = axutil_string_create(env, "EucalyptusNC#ncRunInstance");
1313
axis2_options_set_soap_action(options, env, soap_act);
1315
axis2_options_set_action( options, env, soap_action);
1318
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
1321
callback = axis2_callback_create(env);
1322
/* Set our on_complete fucntion pointer to the callback object */
1323
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncRunInstance);
1324
/* Set our on_error function pointer to the callback object */
1325
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncRunInstance);
1327
callback_data-> data = user_data;
1328
callback_data-> on_complete = on_complete;
1329
callback_data-> on_error = on_error;
1331
axis2_callback_set_data(callback, (void*)callback_data);
1334
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
1336
if (!is_soap_act_set)
1339
axis2_options_set_soap_action(options, env, NULL);
1341
axis2_options_set_action(options, env, NULL);
1347
struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data
1350
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRebootInstanceResponse_t* _ncRebootInstanceResponse, void *data);
1351
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1354
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncRebootInstance(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1356
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1357
struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data* callback_data = NULL;
1358
void *user_data = NULL;
1360
axis2_status_t status;
1362
callback_data = (struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data*)axis2_callback_get_data(callback);
1364
user_data = callback_data->data;
1365
on_error = callback_data->on_error;
1367
status = on_error(env, exception, user_data);
1371
AXIS2_FREE(env->allocator, callback_data);
1376
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncRebootInstance(axis2_callback_t *callback, const axutil_env_t *env)
1378
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRebootInstanceResponse_t* _ncRebootInstanceResponse, void *data);
1379
struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data* callback_data = NULL;
1380
void *user_data = NULL;
1381
axis2_status_t status = AXIS2_SUCCESS;
1383
adb_ncRebootInstanceResponse_t* ret_val = NULL;
1386
axiom_node_t *ret_node = NULL;
1387
axiom_soap_envelope_t *soap_envelope = NULL;
1391
callback_data = (struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data*)axis2_callback_get_data(callback);
1393
soap_envelope = axis2_callback_get_envelope(callback, env);
1396
axiom_soap_body_t *soap_body;
1397
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1400
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1403
ret_node = axiom_node_get_first_child(body_node, env);
1410
user_data = callback_data->data;
1411
on_complete = callback_data->on_complete;
1414
if(ret_node != NULL)
1416
ret_val = adb_ncRebootInstanceResponse_create(env);
1418
if(adb_ncRebootInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1420
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1421
"This should be due to an invalid XML");
1422
adb_ncRebootInstanceResponse_free(ret_val, env);
1430
status = on_complete(env, ret_val, user_data);
1435
AXIS2_FREE(env->allocator, callback_data);
1441
* auto generated method signature for asynchronous invocations
1442
* for "ncRebootInstance|http://eucalyptus.ucsb.edu/" operation.
1445
* @param _ncRebootInstance
1446
* @param on_complete callback to handle on complete
1447
* @param on_error callback to handle on error
1449
void axis2_stub_start_op_EucalyptusNC_ncRebootInstance( axis2_stub_t *stub, const axutil_env_t *env,
1450
adb_ncRebootInstance_t* _ncRebootInstance,
1452
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRebootInstanceResponse_t* _ncRebootInstanceResponse, void *data) ,
1453
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
1456
axis2_callback_t *callback = NULL;
1458
axis2_svc_client_t *svc_client = NULL;
1459
axis2_options_t *options = NULL;
1461
const axis2_char_t *soap_action = NULL;
1462
axiom_node_t *payload = NULL;
1464
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1466
axutil_string_t *soap_act = NULL;
1469
struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data *callback_data;
1471
callback_data = (struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data*) AXIS2_MALLOC(env->allocator,
1472
sizeof(struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data));
1473
if(NULL == callback_data)
1475
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
1480
payload = adb_ncRebootInstance_serialize(_ncRebootInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1485
options = axis2_stub_get_options( stub, env);
1486
if (NULL == options)
1488
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1489
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
1492
svc_client = axis2_stub_get_svc_client (stub, env);
1493
soap_action =axis2_options_get_action (options, env);
1494
if (NULL == soap_action)
1496
is_soap_act_set = AXIS2_FALSE;
1497
soap_action = "EucalyptusNC#ncRebootInstance";
1499
soap_act = axutil_string_create(env, "EucalyptusNC#ncRebootInstance");
1500
axis2_options_set_soap_action(options, env, soap_act);
1502
axis2_options_set_action( options, env, soap_action);
1505
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
1508
callback = axis2_callback_create(env);
1509
/* Set our on_complete fucntion pointer to the callback object */
1510
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncRebootInstance);
1511
/* Set our on_error function pointer to the callback object */
1512
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncRebootInstance);
1514
callback_data-> data = user_data;
1515
callback_data-> on_complete = on_complete;
1516
callback_data-> on_error = on_error;
1518
axis2_callback_set_data(callback, (void*)callback_data);
1521
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
1523
if (!is_soap_act_set)
1526
axis2_options_set_soap_action(options, env, NULL);
1528
axis2_options_set_action(options, env, NULL);
1534
struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data
1537
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncGetConsoleOutputResponse_t* _ncGetConsoleOutputResponse, void *data);
1538
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1541
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncGetConsoleOutput(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1543
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1544
struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data* callback_data = NULL;
1545
void *user_data = NULL;
1547
axis2_status_t status;
1549
callback_data = (struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data*)axis2_callback_get_data(callback);
1551
user_data = callback_data->data;
1552
on_error = callback_data->on_error;
1554
status = on_error(env, exception, user_data);
1558
AXIS2_FREE(env->allocator, callback_data);
1563
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncGetConsoleOutput(axis2_callback_t *callback, const axutil_env_t *env)
1565
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncGetConsoleOutputResponse_t* _ncGetConsoleOutputResponse, void *data);
1566
struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data* callback_data = NULL;
1567
void *user_data = NULL;
1568
axis2_status_t status = AXIS2_SUCCESS;
1570
adb_ncGetConsoleOutputResponse_t* ret_val = NULL;
1573
axiom_node_t *ret_node = NULL;
1574
axiom_soap_envelope_t *soap_envelope = NULL;
1578
callback_data = (struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data*)axis2_callback_get_data(callback);
1580
soap_envelope = axis2_callback_get_envelope(callback, env);
1583
axiom_soap_body_t *soap_body;
1584
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1587
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1590
ret_node = axiom_node_get_first_child(body_node, env);
1597
user_data = callback_data->data;
1598
on_complete = callback_data->on_complete;
1601
if(ret_node != NULL)
1603
ret_val = adb_ncGetConsoleOutputResponse_create(env);
1605
if(adb_ncGetConsoleOutputResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1607
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1608
"This should be due to an invalid XML");
1609
adb_ncGetConsoleOutputResponse_free(ret_val, env);
1617
status = on_complete(env, ret_val, user_data);
1622
AXIS2_FREE(env->allocator, callback_data);
1628
* auto generated method signature for asynchronous invocations
1629
* for "ncGetConsoleOutput|http://eucalyptus.ucsb.edu/" operation.
1632
* @param _ncGetConsoleOutput
1633
* @param on_complete callback to handle on complete
1634
* @param on_error callback to handle on error
1636
void axis2_stub_start_op_EucalyptusNC_ncGetConsoleOutput( axis2_stub_t *stub, const axutil_env_t *env,
1637
adb_ncGetConsoleOutput_t* _ncGetConsoleOutput,
1639
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncGetConsoleOutputResponse_t* _ncGetConsoleOutputResponse, void *data) ,
1640
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
1643
axis2_callback_t *callback = NULL;
1645
axis2_svc_client_t *svc_client = NULL;
1646
axis2_options_t *options = NULL;
1648
const axis2_char_t *soap_action = NULL;
1649
axiom_node_t *payload = NULL;
1651
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1653
axutil_string_t *soap_act = NULL;
1656
struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data *callback_data;
1658
callback_data = (struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data*) AXIS2_MALLOC(env->allocator,
1659
sizeof(struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data));
1660
if(NULL == callback_data)
1662
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
1667
payload = adb_ncGetConsoleOutput_serialize(_ncGetConsoleOutput, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1672
options = axis2_stub_get_options( stub, env);
1673
if (NULL == options)
1675
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1676
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
1679
svc_client = axis2_stub_get_svc_client (stub, env);
1680
soap_action =axis2_options_get_action (options, env);
1681
if (NULL == soap_action)
1683
is_soap_act_set = AXIS2_FALSE;
1684
soap_action = "EucalyptusNC#ncGetConsoleOutput";
1686
soap_act = axutil_string_create(env, "EucalyptusNC#ncGetConsoleOutput");
1687
axis2_options_set_soap_action(options, env, soap_act);
1689
axis2_options_set_action( options, env, soap_action);
1692
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
1695
callback = axis2_callback_create(env);
1696
/* Set our on_complete fucntion pointer to the callback object */
1697
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncGetConsoleOutput);
1698
/* Set our on_error function pointer to the callback object */
1699
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncGetConsoleOutput);
1701
callback_data-> data = user_data;
1702
callback_data-> on_complete = on_complete;
1703
callback_data-> on_error = on_error;
1705
axis2_callback_set_data(callback, (void*)callback_data);
1708
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
1710
if (!is_soap_act_set)
1713
axis2_options_set_soap_action(options, env, NULL);
1715
axis2_options_set_action(options, env, NULL);
1721
struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data
1724
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDetachVolumeResponse_t* _ncDetachVolumeResponse, void *data);
1725
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1728
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncDetachVolume(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1730
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1731
struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data* callback_data = NULL;
1732
void *user_data = NULL;
1734
axis2_status_t status;
1736
callback_data = (struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data*)axis2_callback_get_data(callback);
1738
user_data = callback_data->data;
1739
on_error = callback_data->on_error;
1741
status = on_error(env, exception, user_data);
1745
AXIS2_FREE(env->allocator, callback_data);
1750
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncDetachVolume(axis2_callback_t *callback, const axutil_env_t *env)
1752
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDetachVolumeResponse_t* _ncDetachVolumeResponse, void *data);
1753
struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data* callback_data = NULL;
1754
void *user_data = NULL;
1755
axis2_status_t status = AXIS2_SUCCESS;
1757
adb_ncDetachVolumeResponse_t* ret_val = NULL;
1760
axiom_node_t *ret_node = NULL;
1761
axiom_soap_envelope_t *soap_envelope = NULL;
1765
callback_data = (struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data*)axis2_callback_get_data(callback);
1767
soap_envelope = axis2_callback_get_envelope(callback, env);
1770
axiom_soap_body_t *soap_body;
1771
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1774
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1777
ret_node = axiom_node_get_first_child(body_node, env);
1784
user_data = callback_data->data;
1785
on_complete = callback_data->on_complete;
1788
if(ret_node != NULL)
1790
ret_val = adb_ncDetachVolumeResponse_create(env);
1792
if(adb_ncDetachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1794
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1795
"This should be due to an invalid XML");
1796
adb_ncDetachVolumeResponse_free(ret_val, env);
1804
status = on_complete(env, ret_val, user_data);
1809
AXIS2_FREE(env->allocator, callback_data);
1815
* auto generated method signature for asynchronous invocations
1816
* for "ncDetachVolume|http://eucalyptus.ucsb.edu/" operation.
1819
* @param _ncDetachVolume
1820
* @param on_complete callback to handle on complete
1821
* @param on_error callback to handle on error
1823
void axis2_stub_start_op_EucalyptusNC_ncDetachVolume( axis2_stub_t *stub, const axutil_env_t *env,
1824
adb_ncDetachVolume_t* _ncDetachVolume,
1826
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDetachVolumeResponse_t* _ncDetachVolumeResponse, void *data) ,
1827
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
1830
axis2_callback_t *callback = NULL;
1832
axis2_svc_client_t *svc_client = NULL;
1833
axis2_options_t *options = NULL;
1835
const axis2_char_t *soap_action = NULL;
1836
axiom_node_t *payload = NULL;
1838
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1840
axutil_string_t *soap_act = NULL;
1843
struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data *callback_data;
1845
callback_data = (struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data*) AXIS2_MALLOC(env->allocator,
1846
sizeof(struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data));
1847
if(NULL == callback_data)
1849
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
1854
payload = adb_ncDetachVolume_serialize(_ncDetachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1859
options = axis2_stub_get_options( stub, env);
1860
if (NULL == options)
1862
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1863
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
1866
svc_client = axis2_stub_get_svc_client (stub, env);
1867
soap_action =axis2_options_get_action (options, env);
1868
if (NULL == soap_action)
1870
is_soap_act_set = AXIS2_FALSE;
1871
soap_action = "EucalyptusNC#ncDetachVolume";
1873
soap_act = axutil_string_create(env, "EucalyptusNC#ncDetachVolume");
1874
axis2_options_set_soap_action(options, env, soap_act);
1876
axis2_options_set_action( options, env, soap_action);
1879
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
1882
callback = axis2_callback_create(env);
1883
/* Set our on_complete fucntion pointer to the callback object */
1884
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncDetachVolume);
1885
/* Set our on_error function pointer to the callback object */
1886
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncDetachVolume);
1888
callback_data-> data = user_data;
1889
callback_data-> on_complete = on_complete;
1890
callback_data-> on_error = on_error;
1892
axis2_callback_set_data(callback, (void*)callback_data);
1895
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
1897
if (!is_soap_act_set)
1900
axis2_options_set_soap_action(options, env, NULL);
1902
axis2_options_set_action(options, env, NULL);
1908
struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data
1911
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeInstancesResponse_t* _ncDescribeInstancesResponse, void *data);
1912
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1915
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncDescribeInstances(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1917
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1918
struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data* callback_data = NULL;
1919
void *user_data = NULL;
1921
axis2_status_t status;
1923
callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data*)axis2_callback_get_data(callback);
1925
user_data = callback_data->data;
1926
on_error = callback_data->on_error;
1928
status = on_error(env, exception, user_data);
1932
AXIS2_FREE(env->allocator, callback_data);
1937
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncDescribeInstances(axis2_callback_t *callback, const axutil_env_t *env)
1939
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeInstancesResponse_t* _ncDescribeInstancesResponse, void *data);
1940
struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data* callback_data = NULL;
1941
void *user_data = NULL;
1942
axis2_status_t status = AXIS2_SUCCESS;
1944
adb_ncDescribeInstancesResponse_t* ret_val = NULL;
1947
axiom_node_t *ret_node = NULL;
1948
axiom_soap_envelope_t *soap_envelope = NULL;
1952
callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data*)axis2_callback_get_data(callback);
1954
soap_envelope = axis2_callback_get_envelope(callback, env);
1957
axiom_soap_body_t *soap_body;
1958
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1961
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1964
ret_node = axiom_node_get_first_child(body_node, env);
1971
user_data = callback_data->data;
1972
on_complete = callback_data->on_complete;
1975
if(ret_node != NULL)
1977
ret_val = adb_ncDescribeInstancesResponse_create(env);
1979
if(adb_ncDescribeInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1981
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1982
"This should be due to an invalid XML");
1983
adb_ncDescribeInstancesResponse_free(ret_val, env);
1991
status = on_complete(env, ret_val, user_data);
1996
AXIS2_FREE(env->allocator, callback_data);
2002
* auto generated method signature for asynchronous invocations
2003
* for "ncDescribeInstances|http://eucalyptus.ucsb.edu/" operation.
2006
* @param _ncDescribeInstances
2007
* @param on_complete callback to handle on complete
2008
* @param on_error callback to handle on error
2010
void axis2_stub_start_op_EucalyptusNC_ncDescribeInstances( axis2_stub_t *stub, const axutil_env_t *env,
2011
adb_ncDescribeInstances_t* _ncDescribeInstances,
2013
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeInstancesResponse_t* _ncDescribeInstancesResponse, void *data) ,
2014
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2017
axis2_callback_t *callback = NULL;
2019
axis2_svc_client_t *svc_client = NULL;
2020
axis2_options_t *options = NULL;
2022
const axis2_char_t *soap_action = NULL;
2023
axiom_node_t *payload = NULL;
2025
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2027
axutil_string_t *soap_act = NULL;
2030
struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data *callback_data;
2032
callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data*) AXIS2_MALLOC(env->allocator,
2033
sizeof(struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data));
2034
if(NULL == callback_data)
2036
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2041
payload = adb_ncDescribeInstances_serialize(_ncDescribeInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2046
options = axis2_stub_get_options( stub, env);
2047
if (NULL == options)
2049
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2050
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2053
svc_client = axis2_stub_get_svc_client (stub, env);
2054
soap_action =axis2_options_get_action (options, env);
2055
if (NULL == soap_action)
2057
is_soap_act_set = AXIS2_FALSE;
2058
soap_action = "EucalyptusNC#ncDescribeInstances";
2060
soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeInstances");
2061
axis2_options_set_soap_action(options, env, soap_act);
2063
axis2_options_set_action( options, env, soap_action);
2066
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2069
callback = axis2_callback_create(env);
2070
/* Set our on_complete fucntion pointer to the callback object */
2071
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncDescribeInstances);
2072
/* Set our on_error function pointer to the callback object */
2073
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncDescribeInstances);
2075
callback_data-> data = user_data;
2076
callback_data-> on_complete = on_complete;
2077
callback_data-> on_error = on_error;
2079
axis2_callback_set_data(callback, (void*)callback_data);
2082
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2084
if (!is_soap_act_set)
2087
axis2_options_set_soap_action(options, env, NULL);
2089
axis2_options_set_action(options, env, NULL);
2095
struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data
2098
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncAttachVolumeResponse_t* _ncAttachVolumeResponse, void *data);
2099
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2102
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncAttachVolume(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2104
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2105
struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data* callback_data = NULL;
2106
void *user_data = NULL;
2108
axis2_status_t status;
2110
callback_data = (struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data*)axis2_callback_get_data(callback);
2112
user_data = callback_data->data;
2113
on_error = callback_data->on_error;
2115
status = on_error(env, exception, user_data);
2119
AXIS2_FREE(env->allocator, callback_data);
2124
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncAttachVolume(axis2_callback_t *callback, const axutil_env_t *env)
2126
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncAttachVolumeResponse_t* _ncAttachVolumeResponse, void *data);
2127
struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data* callback_data = NULL;
2128
void *user_data = NULL;
2129
axis2_status_t status = AXIS2_SUCCESS;
2131
adb_ncAttachVolumeResponse_t* ret_val = NULL;
2134
axiom_node_t *ret_node = NULL;
2135
axiom_soap_envelope_t *soap_envelope = NULL;
2139
callback_data = (struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data*)axis2_callback_get_data(callback);
2141
soap_envelope = axis2_callback_get_envelope(callback, env);
2144
axiom_soap_body_t *soap_body;
2145
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2148
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2151
ret_node = axiom_node_get_first_child(body_node, env);
2158
user_data = callback_data->data;
2159
on_complete = callback_data->on_complete;
2162
if(ret_node != NULL)
2164
ret_val = adb_ncAttachVolumeResponse_create(env);
2166
if(adb_ncAttachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2168
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2169
"This should be due to an invalid XML");
2170
adb_ncAttachVolumeResponse_free(ret_val, env);
2178
status = on_complete(env, ret_val, user_data);
2183
AXIS2_FREE(env->allocator, callback_data);
2189
* auto generated method signature for asynchronous invocations
2190
* for "ncAttachVolume|http://eucalyptus.ucsb.edu/" operation.
2193
* @param _ncAttachVolume
2194
* @param on_complete callback to handle on complete
2195
* @param on_error callback to handle on error
2197
void axis2_stub_start_op_EucalyptusNC_ncAttachVolume( axis2_stub_t *stub, const axutil_env_t *env,
2198
adb_ncAttachVolume_t* _ncAttachVolume,
2200
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncAttachVolumeResponse_t* _ncAttachVolumeResponse, void *data) ,
2201
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2204
axis2_callback_t *callback = NULL;
2206
axis2_svc_client_t *svc_client = NULL;
2207
axis2_options_t *options = NULL;
2209
const axis2_char_t *soap_action = NULL;
2210
axiom_node_t *payload = NULL;
2212
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2214
axutil_string_t *soap_act = NULL;
2217
struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data *callback_data;
2219
callback_data = (struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data*) AXIS2_MALLOC(env->allocator,
2220
sizeof(struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data));
2221
if(NULL == callback_data)
2223
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2228
payload = adb_ncAttachVolume_serialize(_ncAttachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2233
options = axis2_stub_get_options( stub, env);
2234
if (NULL == options)
2236
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2237
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2240
svc_client = axis2_stub_get_svc_client (stub, env);
2241
soap_action =axis2_options_get_action (options, env);
2242
if (NULL == soap_action)
2244
is_soap_act_set = AXIS2_FALSE;
2245
soap_action = "EucalyptusNC#ncAttachVolume";
2247
soap_act = axutil_string_create(env, "EucalyptusNC#ncAttachVolume");
2248
axis2_options_set_soap_action(options, env, soap_act);
2250
axis2_options_set_action( options, env, soap_action);
2253
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2256
callback = axis2_callback_create(env);
2257
/* Set our on_complete fucntion pointer to the callback object */
2258
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncAttachVolume);
2259
/* Set our on_error function pointer to the callback object */
2260
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncAttachVolume);
2262
callback_data-> data = user_data;
2263
callback_data-> on_complete = on_complete;
2264
callback_data-> on_error = on_error;
2266
axis2_callback_set_data(callback, (void*)callback_data);
2269
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2271
if (!is_soap_act_set)
2274
axis2_options_set_soap_action(options, env, NULL);
2276
axis2_options_set_action(options, env, NULL);
2282
struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data
2285
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncPowerDownResponse_t* _ncPowerDownResponse, void *data);
2286
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2289
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncPowerDown(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2291
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2292
struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data* callback_data = NULL;
2293
void *user_data = NULL;
2295
axis2_status_t status;
2297
callback_data = (struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data*)axis2_callback_get_data(callback);
2299
user_data = callback_data->data;
2300
on_error = callback_data->on_error;
2302
status = on_error(env, exception, user_data);
2306
AXIS2_FREE(env->allocator, callback_data);
2311
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncPowerDown(axis2_callback_t *callback, const axutil_env_t *env)
2313
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncPowerDownResponse_t* _ncPowerDownResponse, void *data);
2314
struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data* callback_data = NULL;
2315
void *user_data = NULL;
2316
axis2_status_t status = AXIS2_SUCCESS;
2318
adb_ncPowerDownResponse_t* ret_val = NULL;
2321
axiom_node_t *ret_node = NULL;
2322
axiom_soap_envelope_t *soap_envelope = NULL;
2326
callback_data = (struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data*)axis2_callback_get_data(callback);
2328
soap_envelope = axis2_callback_get_envelope(callback, env);
2331
axiom_soap_body_t *soap_body;
2332
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2335
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2338
ret_node = axiom_node_get_first_child(body_node, env);
2345
user_data = callback_data->data;
2346
on_complete = callback_data->on_complete;
2349
if(ret_node != NULL)
2351
ret_val = adb_ncPowerDownResponse_create(env);
2353
if(adb_ncPowerDownResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2355
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2356
"This should be due to an invalid XML");
2357
adb_ncPowerDownResponse_free(ret_val, env);
2365
status = on_complete(env, ret_val, user_data);
2370
AXIS2_FREE(env->allocator, callback_data);
2376
* auto generated method signature for asynchronous invocations
2377
* for "ncPowerDown|http://eucalyptus.ucsb.edu/" operation.
2380
* @param _ncPowerDown
2381
* @param on_complete callback to handle on complete
2382
* @param on_error callback to handle on error
2384
void axis2_stub_start_op_EucalyptusNC_ncPowerDown( axis2_stub_t *stub, const axutil_env_t *env,
2385
adb_ncPowerDown_t* _ncPowerDown,
2387
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncPowerDownResponse_t* _ncPowerDownResponse, void *data) ,
2388
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2391
axis2_callback_t *callback = NULL;
2393
axis2_svc_client_t *svc_client = NULL;
2394
axis2_options_t *options = NULL;
2396
const axis2_char_t *soap_action = NULL;
2397
axiom_node_t *payload = NULL;
2399
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2401
axutil_string_t *soap_act = NULL;
2404
struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data *callback_data;
2406
callback_data = (struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data*) AXIS2_MALLOC(env->allocator,
2407
sizeof(struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data));
2408
if(NULL == callback_data)
2410
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2415
payload = adb_ncPowerDown_serialize(_ncPowerDown, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2420
options = axis2_stub_get_options( stub, env);
2421
if (NULL == options)
2423
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2424
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2427
svc_client = axis2_stub_get_svc_client (stub, env);
2428
soap_action =axis2_options_get_action (options, env);
2429
if (NULL == soap_action)
2431
is_soap_act_set = AXIS2_FALSE;
2432
soap_action = "EucalyptusNC#ncPowerDown";
2434
soap_act = axutil_string_create(env, "EucalyptusNC#ncPowerDown");
2435
axis2_options_set_soap_action(options, env, soap_act);
2437
axis2_options_set_action( options, env, soap_action);
2440
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2443
callback = axis2_callback_create(env);
2444
/* Set our on_complete fucntion pointer to the callback object */
2445
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncPowerDown);
2446
/* Set our on_error function pointer to the callback object */
2447
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncPowerDown);
2449
callback_data-> data = user_data;
2450
callback_data-> on_complete = on_complete;
2451
callback_data-> on_error = on_error;
2453
axis2_callback_set_data(callback, (void*)callback_data);
2456
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2458
if (!is_soap_act_set)
2461
axis2_options_set_soap_action(options, env, NULL);
2463
axis2_options_set_action(options, env, NULL);
2469
struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data
2472
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeResourceResponse_t* _ncDescribeResourceResponse, void *data);
2473
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2476
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncDescribeResource(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2478
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2479
struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data* callback_data = NULL;
2480
void *user_data = NULL;
2482
axis2_status_t status;
2484
callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data*)axis2_callback_get_data(callback);
2486
user_data = callback_data->data;
2487
on_error = callback_data->on_error;
2489
status = on_error(env, exception, user_data);
2493
AXIS2_FREE(env->allocator, callback_data);
2498
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncDescribeResource(axis2_callback_t *callback, const axutil_env_t *env)
2500
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeResourceResponse_t* _ncDescribeResourceResponse, void *data);
2501
struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data* callback_data = NULL;
2502
void *user_data = NULL;
2503
axis2_status_t status = AXIS2_SUCCESS;
2505
adb_ncDescribeResourceResponse_t* ret_val = NULL;
2508
axiom_node_t *ret_node = NULL;
2509
axiom_soap_envelope_t *soap_envelope = NULL;
2513
callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data*)axis2_callback_get_data(callback);
2515
soap_envelope = axis2_callback_get_envelope(callback, env);
2518
axiom_soap_body_t *soap_body;
2519
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2522
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2525
ret_node = axiom_node_get_first_child(body_node, env);
2532
user_data = callback_data->data;
2533
on_complete = callback_data->on_complete;
2536
if(ret_node != NULL)
2538
ret_val = adb_ncDescribeResourceResponse_create(env);
2540
if(adb_ncDescribeResourceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2542
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2543
"This should be due to an invalid XML");
2544
adb_ncDescribeResourceResponse_free(ret_val, env);
2552
status = on_complete(env, ret_val, user_data);
2557
AXIS2_FREE(env->allocator, callback_data);
2563
* auto generated method signature for asynchronous invocations
2564
* for "ncDescribeResource|http://eucalyptus.ucsb.edu/" operation.
2567
* @param _ncDescribeResource
2568
* @param on_complete callback to handle on complete
2569
* @param on_error callback to handle on error
2571
void axis2_stub_start_op_EucalyptusNC_ncDescribeResource( axis2_stub_t *stub, const axutil_env_t *env,
2572
adb_ncDescribeResource_t* _ncDescribeResource,
2574
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeResourceResponse_t* _ncDescribeResourceResponse, void *data) ,
2575
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2578
axis2_callback_t *callback = NULL;
2580
axis2_svc_client_t *svc_client = NULL;
2581
axis2_options_t *options = NULL;
2583
const axis2_char_t *soap_action = NULL;
2584
axiom_node_t *payload = NULL;
2586
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2588
axutil_string_t *soap_act = NULL;
2591
struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data *callback_data;
2593
callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data*) AXIS2_MALLOC(env->allocator,
2594
sizeof(struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data));
2595
if(NULL == callback_data)
2597
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2602
payload = adb_ncDescribeResource_serialize(_ncDescribeResource, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2607
options = axis2_stub_get_options( stub, env);
2608
if (NULL == options)
2610
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2611
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2614
svc_client = axis2_stub_get_svc_client (stub, env);
2615
soap_action =axis2_options_get_action (options, env);
2616
if (NULL == soap_action)
2618
is_soap_act_set = AXIS2_FALSE;
2619
soap_action = "EucalyptusNC#ncDescribeResource";
2621
soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeResource");
2622
axis2_options_set_soap_action(options, env, soap_act);
2624
axis2_options_set_action( options, env, soap_action);
2627
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2630
callback = axis2_callback_create(env);
2631
/* Set our on_complete fucntion pointer to the callback object */
2632
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncDescribeResource);
2633
/* Set our on_error function pointer to the callback object */
2634
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncDescribeResource);
2636
callback_data-> data = user_data;
2637
callback_data-> on_complete = on_complete;
2638
callback_data-> on_error = on_error;
2640
axis2_callback_set_data(callback, (void*)callback_data);
2643
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2645
if (!is_soap_act_set)
2648
axis2_options_set_soap_action(options, env, NULL);
2650
axis2_options_set_action(options, env, NULL);
2656
struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data
2659
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncTerminateInstanceResponse_t* _ncTerminateInstanceResponse, void *data);
2660
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2663
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncTerminateInstance(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2665
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2666
struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data* callback_data = NULL;
2667
void *user_data = NULL;
2669
axis2_status_t status;
2671
callback_data = (struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data*)axis2_callback_get_data(callback);
2673
user_data = callback_data->data;
2674
on_error = callback_data->on_error;
2676
status = on_error(env, exception, user_data);
2680
AXIS2_FREE(env->allocator, callback_data);
2685
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncTerminateInstance(axis2_callback_t *callback, const axutil_env_t *env)
2687
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncTerminateInstanceResponse_t* _ncTerminateInstanceResponse, void *data);
2688
struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data* callback_data = NULL;
2689
void *user_data = NULL;
2690
axis2_status_t status = AXIS2_SUCCESS;
2692
adb_ncTerminateInstanceResponse_t* ret_val = NULL;
2695
axiom_node_t *ret_node = NULL;
2696
axiom_soap_envelope_t *soap_envelope = NULL;
2700
callback_data = (struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data*)axis2_callback_get_data(callback);
2702
soap_envelope = axis2_callback_get_envelope(callback, env);
2705
axiom_soap_body_t *soap_body;
2706
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2709
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2712
ret_node = axiom_node_get_first_child(body_node, env);
2719
user_data = callback_data->data;
2720
on_complete = callback_data->on_complete;
2723
if(ret_node != NULL)
2725
ret_val = adb_ncTerminateInstanceResponse_create(env);
2727
if(adb_ncTerminateInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2729
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2730
"This should be due to an invalid XML");
2731
adb_ncTerminateInstanceResponse_free(ret_val, env);
2739
status = on_complete(env, ret_val, user_data);
2744
AXIS2_FREE(env->allocator, callback_data);
2750
* auto generated method signature for asynchronous invocations
2751
* for "ncTerminateInstance|http://eucalyptus.ucsb.edu/" operation.
2754
* @param _ncTerminateInstance
2755
* @param on_complete callback to handle on complete
2756
* @param on_error callback to handle on error
2758
void axis2_stub_start_op_EucalyptusNC_ncTerminateInstance( axis2_stub_t *stub, const axutil_env_t *env,
2759
adb_ncTerminateInstance_t* _ncTerminateInstance,
2761
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncTerminateInstanceResponse_t* _ncTerminateInstanceResponse, void *data) ,
2762
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2765
axis2_callback_t *callback = NULL;
2767
axis2_svc_client_t *svc_client = NULL;
2768
axis2_options_t *options = NULL;
2770
const axis2_char_t *soap_action = NULL;
2771
axiom_node_t *payload = NULL;
2773
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2775
axutil_string_t *soap_act = NULL;
2778
struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data *callback_data;
2780
callback_data = (struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data*) AXIS2_MALLOC(env->allocator,
2781
sizeof(struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data));
2782
if(NULL == callback_data)
2784
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2789
payload = adb_ncTerminateInstance_serialize(_ncTerminateInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2794
options = axis2_stub_get_options( stub, env);
2795
if (NULL == options)
2797
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2798
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2801
svc_client = axis2_stub_get_svc_client (stub, env);
2802
soap_action =axis2_options_get_action (options, env);
2803
if (NULL == soap_action)
2805
is_soap_act_set = AXIS2_FALSE;
2806
soap_action = "EucalyptusNC#ncTerminateInstance";
2808
soap_act = axutil_string_create(env, "EucalyptusNC#ncTerminateInstance");
2809
axis2_options_set_soap_action(options, env, soap_act);
2811
axis2_options_set_action( options, env, soap_action);
2814
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2817
callback = axis2_callback_create(env);
2818
/* Set our on_complete fucntion pointer to the callback object */
2819
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncTerminateInstance);
2820
/* Set our on_error function pointer to the callback object */
2821
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncTerminateInstance);
2823
callback_data-> data = user_data;
2824
callback_data-> on_complete = on_complete;
2825
callback_data-> on_error = on_error;
2827
axis2_callback_set_data(callback, (void*)callback_data);
2830
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2832
if (!is_soap_act_set)
2835
axis2_options_set_soap_action(options, env, NULL);
2837
axis2_options_set_action(options, env, NULL);
2843
struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data
2846
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncStartNetworkResponse_t* _ncStartNetworkResponse, void *data);
2847
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2850
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncStartNetwork(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2852
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2853
struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data* callback_data = NULL;
2854
void *user_data = NULL;
2856
axis2_status_t status;
2858
callback_data = (struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data*)axis2_callback_get_data(callback);
2860
user_data = callback_data->data;
2861
on_error = callback_data->on_error;
2863
status = on_error(env, exception, user_data);
2867
AXIS2_FREE(env->allocator, callback_data);
2872
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncStartNetwork(axis2_callback_t *callback, const axutil_env_t *env)
2874
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncStartNetworkResponse_t* _ncStartNetworkResponse, void *data);
2875
struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data* callback_data = NULL;
2876
void *user_data = NULL;
2877
axis2_status_t status = AXIS2_SUCCESS;
2879
adb_ncStartNetworkResponse_t* ret_val = NULL;
2882
axiom_node_t *ret_node = NULL;
2883
axiom_soap_envelope_t *soap_envelope = NULL;
2887
callback_data = (struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data*)axis2_callback_get_data(callback);
2889
soap_envelope = axis2_callback_get_envelope(callback, env);
2892
axiom_soap_body_t *soap_body;
2893
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2896
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2899
ret_node = axiom_node_get_first_child(body_node, env);
2906
user_data = callback_data->data;
2907
on_complete = callback_data->on_complete;
2910
if(ret_node != NULL)
2912
ret_val = adb_ncStartNetworkResponse_create(env);
2914
if(adb_ncStartNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2916
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2917
"This should be due to an invalid XML");
2918
adb_ncStartNetworkResponse_free(ret_val, env);
2926
status = on_complete(env, ret_val, user_data);
2931
AXIS2_FREE(env->allocator, callback_data);
2937
* auto generated method signature for asynchronous invocations
2938
* for "ncStartNetwork|http://eucalyptus.ucsb.edu/" operation.
2941
* @param _ncStartNetwork
2942
* @param on_complete callback to handle on complete
2943
* @param on_error callback to handle on error
2945
void axis2_stub_start_op_EucalyptusNC_ncStartNetwork( axis2_stub_t *stub, const axutil_env_t *env,
2946
adb_ncStartNetwork_t* _ncStartNetwork,
2948
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncStartNetworkResponse_t* _ncStartNetworkResponse, void *data) ,
2949
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2952
axis2_callback_t *callback = NULL;
2954
axis2_svc_client_t *svc_client = NULL;
2955
axis2_options_t *options = NULL;
2957
const axis2_char_t *soap_action = NULL;
2958
axiom_node_t *payload = NULL;
2960
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2962
axutil_string_t *soap_act = NULL;
2965
struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data *callback_data;
2967
callback_data = (struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data*) AXIS2_MALLOC(env->allocator,
2968
sizeof(struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data));
2969
if(NULL == callback_data)
2971
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2976
payload = adb_ncStartNetwork_serialize(_ncStartNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2981
options = axis2_stub_get_options( stub, env);
2982
if (NULL == options)
2984
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2985
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2988
svc_client = axis2_stub_get_svc_client (stub, env);
2989
soap_action =axis2_options_get_action (options, env);
2990
if (NULL == soap_action)
2992
is_soap_act_set = AXIS2_FALSE;
2993
soap_action = "EucalyptusNC#ncStartNetwork";
2995
soap_act = axutil_string_create(env, "EucalyptusNC#ncStartNetwork");
2996
axis2_options_set_soap_action(options, env, soap_act);
2998
axis2_options_set_action( options, env, soap_action);
3001
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
3004
callback = axis2_callback_create(env);
3005
/* Set our on_complete fucntion pointer to the callback object */
3006
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncStartNetwork);
3007
/* Set our on_error function pointer to the callback object */
3008
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncStartNetwork);
3010
callback_data-> data = user_data;
3011
callback_data-> on_complete = on_complete;
3012
callback_data-> on_error = on_error;
3014
axis2_callback_set_data(callback, (void*)callback_data);
3017
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
3019
if (!is_soap_act_set)
3022
axis2_options_set_soap_action(options, env, NULL);
3024
axis2_options_set_action(options, env, NULL);
3032
* function to free any soap input headers
3038
* function to free any soap output headers