4
* axis2_stub_EucalyptusCC.c
6
* This file was auto-generated from WSDL for "EucalyptusCC|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_EucalyptusCC.h"
11
#include <axis2_msg.h>
14
* axis2_stub_EucalyptusCC C implementation
18
axis2_stub_create_EucalyptusCC(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_EucalyptusCC(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_EucalyptusCC(stub, env);
51
axis2_stub_populate_services_for_EucalyptusCC(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,"EucalyptusCC" ,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
"DescribeResources" ,
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,
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
"DescribePublicAddresses" ,
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,
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);
281
op_qname = axutil_qname_create(env,
283
"http://eucalyptus.ucsb.edu/",
285
op = axis2_op_create_with_qname(env, op_qname);
287
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
289
axis2_msg_increment_ref(msg_out, env);
290
axis2_msg_increment_ref(msg_in, env);
291
axis2_msg_increment_ref(msg_out_fault, env);
292
axis2_msg_increment_ref(msg_in_fault, env);
293
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
294
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
295
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
296
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
298
axis2_svc_add_op(svc, env, op);
301
op_qname = axutil_qname_create(env,
302
"TerminateInstances" ,
303
"http://eucalyptus.ucsb.edu/",
305
op = axis2_op_create_with_qname(env, op_qname);
307
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
309
axis2_msg_increment_ref(msg_out, env);
310
axis2_msg_increment_ref(msg_in, env);
311
axis2_msg_increment_ref(msg_out_fault, env);
312
axis2_msg_increment_ref(msg_in_fault, env);
313
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
314
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
315
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
316
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
318
axis2_svc_add_op(svc, env, op);
321
op_qname = axutil_qname_create(env,
323
"http://eucalyptus.ucsb.edu/",
325
op = axis2_op_create_with_qname(env, op_qname);
327
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
329
axis2_msg_increment_ref(msg_out, env);
330
axis2_msg_increment_ref(msg_in, env);
331
axis2_msg_increment_ref(msg_out_fault, env);
332
axis2_msg_increment_ref(msg_in_fault, env);
333
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
334
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
335
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
336
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
338
axis2_svc_add_op(svc, env, op);
341
op_qname = axutil_qname_create(env,
343
"http://eucalyptus.ucsb.edu/",
345
op = axis2_op_create_with_qname(env, op_qname);
347
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
349
axis2_msg_increment_ref(msg_out, env);
350
axis2_msg_increment_ref(msg_in, env);
351
axis2_msg_increment_ref(msg_out_fault, env);
352
axis2_msg_increment_ref(msg_in_fault, env);
353
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
354
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
355
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
356
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
358
axis2_svc_add_op(svc, env, op);
361
op_qname = axutil_qname_create(env,
363
"http://eucalyptus.ucsb.edu/",
365
op = axis2_op_create_with_qname(env, op_qname);
367
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
369
axis2_msg_increment_ref(msg_out, env);
370
axis2_msg_increment_ref(msg_in, env);
371
axis2_msg_increment_ref(msg_out_fault, env);
372
axis2_msg_increment_ref(msg_in_fault, env);
373
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
374
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
375
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
376
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
378
axis2_svc_add_op(svc, env, op);
384
*return end point picked from wsdl
387
axis2_stub_get_endpoint_uri_of_EucalyptusCC( const axutil_env_t *env )
389
axis2_char_t *endpoint_uri = NULL;
390
/* set the address from here */
392
endpoint_uri = "http://cc:9090/axis2/services/EucalyptusCC";
400
* auto generated method signature
401
* for "DescribeInstances|http://eucalyptus.ucsb.edu/" operation.
403
* @param _describeInstances
405
* @return adb_DescribeInstancesResponse_t*
407
adb_DescribeInstancesResponse_t*
408
axis2_stub_op_EucalyptusCC_DescribeInstances( axis2_stub_t *stub, const axutil_env_t *env,
409
adb_DescribeInstances_t* _describeInstances)
411
axis2_svc_client_t *svc_client = NULL;
412
axis2_options_t *options = NULL;
413
axiom_node_t *ret_node = NULL;
415
const axis2_char_t *soap_action = NULL;
416
axutil_qname_t *op_qname = NULL;
417
axiom_node_t *payload = NULL;
418
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
420
axutil_string_t *soap_act = NULL;
421
adb_DescribeInstancesResponse_t* ret_val = NULL;
423
payload = adb_DescribeInstances_serialize(_describeInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
425
svc_client = axis2_stub_get_svc_client(stub, env );
431
options = axis2_stub_get_options( stub, env);
434
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
435
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
438
soap_action = axis2_options_get_action( options, env );
439
if (NULL == soap_action)
441
is_soap_act_set = AXIS2_FALSE;
442
soap_action = "EucalyptusCC#DescribeInstances";
444
soap_act = axutil_string_create(env, "EucalyptusCC#DescribeInstances");
445
axis2_options_set_soap_action(options, env, soap_act);
447
axis2_options_set_action( options, env, soap_action );
450
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
452
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
454
if (!is_soap_act_set)
457
axis2_options_set_soap_action(options, env, NULL);
459
axis2_options_set_action( options, env, NULL);
464
if ( NULL == ret_node )
468
ret_val = adb_DescribeInstancesResponse_create(env);
470
if(adb_DescribeInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
474
adb_DescribeInstancesResponse_free(ret_val, env);
477
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the DescribeInstancesResponse_deserialize: "
478
"This should be due to an invalid XML");
486
* auto generated method signature
487
* for "ConfigureNetwork|http://eucalyptus.ucsb.edu/" operation.
489
* @param _configureNetwork
491
* @return adb_ConfigureNetworkResponse_t*
493
adb_ConfigureNetworkResponse_t*
494
axis2_stub_op_EucalyptusCC_ConfigureNetwork( axis2_stub_t *stub, const axutil_env_t *env,
495
adb_ConfigureNetwork_t* _configureNetwork)
497
axis2_svc_client_t *svc_client = NULL;
498
axis2_options_t *options = NULL;
499
axiom_node_t *ret_node = NULL;
501
const axis2_char_t *soap_action = NULL;
502
axutil_qname_t *op_qname = NULL;
503
axiom_node_t *payload = NULL;
504
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
506
axutil_string_t *soap_act = NULL;
507
adb_ConfigureNetworkResponse_t* ret_val = NULL;
509
payload = adb_ConfigureNetwork_serialize(_configureNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
511
svc_client = axis2_stub_get_svc_client(stub, env );
517
options = axis2_stub_get_options( stub, env);
520
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
521
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
524
soap_action = axis2_options_get_action( options, env );
525
if (NULL == soap_action)
527
is_soap_act_set = AXIS2_FALSE;
528
soap_action = "EucalyptusCC#ConfigureNetwork";
530
soap_act = axutil_string_create(env, "EucalyptusCC#ConfigureNetwork");
531
axis2_options_set_soap_action(options, env, soap_act);
533
axis2_options_set_action( options, env, soap_action );
536
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
538
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
540
if (!is_soap_act_set)
543
axis2_options_set_soap_action(options, env, NULL);
545
axis2_options_set_action( options, env, NULL);
550
if ( NULL == ret_node )
554
ret_val = adb_ConfigureNetworkResponse_create(env);
556
if(adb_ConfigureNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
560
adb_ConfigureNetworkResponse_free(ret_val, env);
563
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ConfigureNetworkResponse_deserialize: "
564
"This should be due to an invalid XML");
572
* auto generated method signature
573
* for "DescribeResources|http://eucalyptus.ucsb.edu/" operation.
575
* @param _describeResources
577
* @return adb_DescribeResourcesResponse_t*
579
adb_DescribeResourcesResponse_t*
580
axis2_stub_op_EucalyptusCC_DescribeResources( axis2_stub_t *stub, const axutil_env_t *env,
581
adb_DescribeResources_t* _describeResources)
583
axis2_svc_client_t *svc_client = NULL;
584
axis2_options_t *options = NULL;
585
axiom_node_t *ret_node = NULL;
587
const axis2_char_t *soap_action = NULL;
588
axutil_qname_t *op_qname = NULL;
589
axiom_node_t *payload = NULL;
590
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
592
axutil_string_t *soap_act = NULL;
593
adb_DescribeResourcesResponse_t* ret_val = NULL;
595
payload = adb_DescribeResources_serialize(_describeResources, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
597
svc_client = axis2_stub_get_svc_client(stub, env );
603
options = axis2_stub_get_options( stub, env);
606
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
607
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
610
soap_action = axis2_options_get_action( options, env );
611
if (NULL == soap_action)
613
is_soap_act_set = AXIS2_FALSE;
614
soap_action = "EucalyptusCC#DescribeResources";
616
soap_act = axutil_string_create(env, "EucalyptusCC#DescribeResources");
617
axis2_options_set_soap_action(options, env, soap_act);
619
axis2_options_set_action( options, env, soap_action );
622
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
624
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
626
if (!is_soap_act_set)
629
axis2_options_set_soap_action(options, env, NULL);
631
axis2_options_set_action( options, env, NULL);
636
if ( NULL == ret_node )
640
ret_val = adb_DescribeResourcesResponse_create(env);
642
if(adb_DescribeResourcesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
646
adb_DescribeResourcesResponse_free(ret_val, env);
649
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the DescribeResourcesResponse_deserialize: "
650
"This should be due to an invalid XML");
658
* auto generated method signature
659
* for "StartNetwork|http://eucalyptus.ucsb.edu/" operation.
661
* @param _startNetwork
663
* @return adb_StartNetworkResponse_t*
665
adb_StartNetworkResponse_t*
666
axis2_stub_op_EucalyptusCC_StartNetwork( axis2_stub_t *stub, const axutil_env_t *env,
667
adb_StartNetwork_t* _startNetwork)
669
axis2_svc_client_t *svc_client = NULL;
670
axis2_options_t *options = NULL;
671
axiom_node_t *ret_node = NULL;
673
const axis2_char_t *soap_action = NULL;
674
axutil_qname_t *op_qname = NULL;
675
axiom_node_t *payload = NULL;
676
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
678
axutil_string_t *soap_act = NULL;
679
adb_StartNetworkResponse_t* ret_val = NULL;
681
payload = adb_StartNetwork_serialize(_startNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
683
svc_client = axis2_stub_get_svc_client(stub, env );
689
options = axis2_stub_get_options( stub, env);
692
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
693
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
696
soap_action = axis2_options_get_action( options, env );
697
if (NULL == soap_action)
699
is_soap_act_set = AXIS2_FALSE;
700
soap_action = "EucalyptusCC#StartNetwork";
702
soap_act = axutil_string_create(env, "EucalyptusCC#StartNetwork");
703
axis2_options_set_soap_action(options, env, soap_act);
705
axis2_options_set_action( options, env, soap_action );
708
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
710
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
712
if (!is_soap_act_set)
715
axis2_options_set_soap_action(options, env, NULL);
717
axis2_options_set_action( options, env, NULL);
722
if ( NULL == ret_node )
726
ret_val = adb_StartNetworkResponse_create(env);
728
if(adb_StartNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
732
adb_StartNetworkResponse_free(ret_val, env);
735
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StartNetworkResponse_deserialize: "
736
"This should be due to an invalid XML");
744
* auto generated method signature
745
* for "StopNetwork|http://eucalyptus.ucsb.edu/" operation.
747
* @param _stopNetwork
749
* @return adb_StopNetworkResponse_t*
751
adb_StopNetworkResponse_t*
752
axis2_stub_op_EucalyptusCC_StopNetwork( axis2_stub_t *stub, const axutil_env_t *env,
753
adb_StopNetwork_t* _stopNetwork)
755
axis2_svc_client_t *svc_client = NULL;
756
axis2_options_t *options = NULL;
757
axiom_node_t *ret_node = NULL;
759
const axis2_char_t *soap_action = NULL;
760
axutil_qname_t *op_qname = NULL;
761
axiom_node_t *payload = NULL;
762
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
764
axutil_string_t *soap_act = NULL;
765
adb_StopNetworkResponse_t* ret_val = NULL;
767
payload = adb_StopNetwork_serialize(_stopNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
769
svc_client = axis2_stub_get_svc_client(stub, env );
775
options = axis2_stub_get_options( stub, env);
778
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
779
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
782
soap_action = axis2_options_get_action( options, env );
783
if (NULL == soap_action)
785
is_soap_act_set = AXIS2_FALSE;
786
soap_action = "EucalyptusCC#StopNetwork";
788
soap_act = axutil_string_create(env, "EucalyptusCC#StopNetwork");
789
axis2_options_set_soap_action(options, env, soap_act);
791
axis2_options_set_action( options, env, soap_action );
794
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
796
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
798
if (!is_soap_act_set)
801
axis2_options_set_soap_action(options, env, NULL);
803
axis2_options_set_action( options, env, NULL);
808
if ( NULL == ret_node )
812
ret_val = adb_StopNetworkResponse_create(env);
814
if(adb_StopNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
818
adb_StopNetworkResponse_free(ret_val, env);
821
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the StopNetworkResponse_deserialize: "
822
"This should be due to an invalid XML");
830
* auto generated method signature
831
* for "DescribeNetworks|http://eucalyptus.ucsb.edu/" operation.
833
* @param _describeNetworks
835
* @return adb_DescribeNetworksResponse_t*
837
adb_DescribeNetworksResponse_t*
838
axis2_stub_op_EucalyptusCC_DescribeNetworks( axis2_stub_t *stub, const axutil_env_t *env,
839
adb_DescribeNetworks_t* _describeNetworks)
841
axis2_svc_client_t *svc_client = NULL;
842
axis2_options_t *options = NULL;
843
axiom_node_t *ret_node = NULL;
845
const axis2_char_t *soap_action = NULL;
846
axutil_qname_t *op_qname = NULL;
847
axiom_node_t *payload = NULL;
848
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
850
axutil_string_t *soap_act = NULL;
851
adb_DescribeNetworksResponse_t* ret_val = NULL;
853
payload = adb_DescribeNetworks_serialize(_describeNetworks, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
855
svc_client = axis2_stub_get_svc_client(stub, env );
861
options = axis2_stub_get_options( stub, env);
864
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
865
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
868
soap_action = axis2_options_get_action( options, env );
869
if (NULL == soap_action)
871
is_soap_act_set = AXIS2_FALSE;
872
soap_action = "EucalyptusCC#DescribeNetworks";
874
soap_act = axutil_string_create(env, "EucalyptusCC#DescribeNetworks");
875
axis2_options_set_soap_action(options, env, soap_act);
877
axis2_options_set_action( options, env, soap_action );
880
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
882
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
884
if (!is_soap_act_set)
887
axis2_options_set_soap_action(options, env, NULL);
889
axis2_options_set_action( options, env, NULL);
894
if ( NULL == ret_node )
898
ret_val = adb_DescribeNetworksResponse_create(env);
900
if(adb_DescribeNetworksResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
904
adb_DescribeNetworksResponse_free(ret_val, env);
907
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the DescribeNetworksResponse_deserialize: "
908
"This should be due to an invalid XML");
916
* auto generated method signature
917
* for "AssignAddress|http://eucalyptus.ucsb.edu/" operation.
919
* @param _assignAddress
921
* @return adb_AssignAddressResponse_t*
923
adb_AssignAddressResponse_t*
924
axis2_stub_op_EucalyptusCC_AssignAddress( axis2_stub_t *stub, const axutil_env_t *env,
925
adb_AssignAddress_t* _assignAddress)
927
axis2_svc_client_t *svc_client = NULL;
928
axis2_options_t *options = NULL;
929
axiom_node_t *ret_node = NULL;
931
const axis2_char_t *soap_action = NULL;
932
axutil_qname_t *op_qname = NULL;
933
axiom_node_t *payload = NULL;
934
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
936
axutil_string_t *soap_act = NULL;
937
adb_AssignAddressResponse_t* ret_val = NULL;
939
payload = adb_AssignAddress_serialize(_assignAddress, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
941
svc_client = axis2_stub_get_svc_client(stub, env );
947
options = axis2_stub_get_options( stub, env);
950
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
951
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
954
soap_action = axis2_options_get_action( options, env );
955
if (NULL == soap_action)
957
is_soap_act_set = AXIS2_FALSE;
958
soap_action = "EucalyptusCC#AssignAddress";
960
soap_act = axutil_string_create(env, "EucalyptusCC#AssignAddress");
961
axis2_options_set_soap_action(options, env, soap_act);
963
axis2_options_set_action( options, env, soap_action );
966
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
968
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
970
if (!is_soap_act_set)
973
axis2_options_set_soap_action(options, env, NULL);
975
axis2_options_set_action( options, env, NULL);
980
if ( NULL == ret_node )
984
ret_val = adb_AssignAddressResponse_create(env);
986
if(adb_AssignAddressResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
990
adb_AssignAddressResponse_free(ret_val, env);
993
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the AssignAddressResponse_deserialize: "
994
"This should be due to an invalid XML");
1002
* auto generated method signature
1003
* for "DescribePublicAddresses|http://eucalyptus.ucsb.edu/" operation.
1005
* @param _describePublicAddresses
1007
* @return adb_DescribePublicAddressesResponse_t*
1009
adb_DescribePublicAddressesResponse_t*
1010
axis2_stub_op_EucalyptusCC_DescribePublicAddresses( axis2_stub_t *stub, const axutil_env_t *env,
1011
adb_DescribePublicAddresses_t* _describePublicAddresses)
1013
axis2_svc_client_t *svc_client = NULL;
1014
axis2_options_t *options = NULL;
1015
axiom_node_t *ret_node = NULL;
1017
const axis2_char_t *soap_action = NULL;
1018
axutil_qname_t *op_qname = NULL;
1019
axiom_node_t *payload = NULL;
1020
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1022
axutil_string_t *soap_act = NULL;
1023
adb_DescribePublicAddressesResponse_t* ret_val = NULL;
1025
payload = adb_DescribePublicAddresses_serialize(_describePublicAddresses, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1027
svc_client = axis2_stub_get_svc_client(stub, env );
1033
options = axis2_stub_get_options( stub, env);
1034
if (NULL == options)
1036
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1037
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1040
soap_action = axis2_options_get_action( options, env );
1041
if (NULL == soap_action)
1043
is_soap_act_set = AXIS2_FALSE;
1044
soap_action = "EucalyptusCC#DescribePublicAddresses";
1046
soap_act = axutil_string_create(env, "EucalyptusCC#DescribePublicAddresses");
1047
axis2_options_set_soap_action(options, env, soap_act);
1049
axis2_options_set_action( options, env, soap_action );
1052
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1054
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1056
if (!is_soap_act_set)
1059
axis2_options_set_soap_action(options, env, NULL);
1061
axis2_options_set_action( options, env, NULL);
1066
if ( NULL == ret_node )
1070
ret_val = adb_DescribePublicAddressesResponse_create(env);
1072
if(adb_DescribePublicAddressesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1076
adb_DescribePublicAddressesResponse_free(ret_val, env);
1079
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the DescribePublicAddressesResponse_deserialize: "
1080
"This should be due to an invalid XML");
1088
* auto generated method signature
1089
* for "RebootInstances|http://eucalyptus.ucsb.edu/" operation.
1091
* @param _rebootInstances
1093
* @return adb_RebootInstancesResponse_t*
1095
adb_RebootInstancesResponse_t*
1096
axis2_stub_op_EucalyptusCC_RebootInstances( axis2_stub_t *stub, const axutil_env_t *env,
1097
adb_RebootInstances_t* _rebootInstances)
1099
axis2_svc_client_t *svc_client = NULL;
1100
axis2_options_t *options = NULL;
1101
axiom_node_t *ret_node = NULL;
1103
const axis2_char_t *soap_action = NULL;
1104
axutil_qname_t *op_qname = NULL;
1105
axiom_node_t *payload = NULL;
1106
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1108
axutil_string_t *soap_act = NULL;
1109
adb_RebootInstancesResponse_t* ret_val = NULL;
1111
payload = adb_RebootInstances_serialize(_rebootInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1113
svc_client = axis2_stub_get_svc_client(stub, env );
1119
options = axis2_stub_get_options( stub, env);
1120
if (NULL == options)
1122
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1123
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1126
soap_action = axis2_options_get_action( options, env );
1127
if (NULL == soap_action)
1129
is_soap_act_set = AXIS2_FALSE;
1130
soap_action = "EucalyptusCC#RebootInstances";
1132
soap_act = axutil_string_create(env, "EucalyptusCC#RebootInstances");
1133
axis2_options_set_soap_action(options, env, soap_act);
1135
axis2_options_set_action( options, env, soap_action );
1138
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1140
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1142
if (!is_soap_act_set)
1145
axis2_options_set_soap_action(options, env, NULL);
1147
axis2_options_set_action( options, env, NULL);
1152
if ( NULL == ret_node )
1156
ret_val = adb_RebootInstancesResponse_create(env);
1158
if(adb_RebootInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1162
adb_RebootInstancesResponse_free(ret_val, env);
1165
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the RebootInstancesResponse_deserialize: "
1166
"This should be due to an invalid XML");
1174
* auto generated method signature
1175
* for "GetConsoleOutput|http://eucalyptus.ucsb.edu/" operation.
1177
* @param _getConsoleOutput
1179
* @return adb_GetConsoleOutputResponse_t*
1181
adb_GetConsoleOutputResponse_t*
1182
axis2_stub_op_EucalyptusCC_GetConsoleOutput( axis2_stub_t *stub, const axutil_env_t *env,
1183
adb_GetConsoleOutput_t* _getConsoleOutput)
1185
axis2_svc_client_t *svc_client = NULL;
1186
axis2_options_t *options = NULL;
1187
axiom_node_t *ret_node = NULL;
1189
const axis2_char_t *soap_action = NULL;
1190
axutil_qname_t *op_qname = NULL;
1191
axiom_node_t *payload = NULL;
1192
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1194
axutil_string_t *soap_act = NULL;
1195
adb_GetConsoleOutputResponse_t* ret_val = NULL;
1197
payload = adb_GetConsoleOutput_serialize(_getConsoleOutput, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1199
svc_client = axis2_stub_get_svc_client(stub, env );
1205
options = axis2_stub_get_options( stub, env);
1206
if (NULL == options)
1208
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1209
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1212
soap_action = axis2_options_get_action( options, env );
1213
if (NULL == soap_action)
1215
is_soap_act_set = AXIS2_FALSE;
1216
soap_action = "EucalyptusCC#GetConsoleOutput";
1218
soap_act = axutil_string_create(env, "EucalyptusCC#GetConsoleOutput");
1219
axis2_options_set_soap_action(options, env, soap_act);
1221
axis2_options_set_action( options, env, soap_action );
1224
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1226
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1228
if (!is_soap_act_set)
1231
axis2_options_set_soap_action(options, env, NULL);
1233
axis2_options_set_action( options, env, NULL);
1238
if ( NULL == ret_node )
1242
ret_val = adb_GetConsoleOutputResponse_create(env);
1244
if(adb_GetConsoleOutputResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1248
adb_GetConsoleOutputResponse_free(ret_val, env);
1251
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the GetConsoleOutputResponse_deserialize: "
1252
"This should be due to an invalid XML");
1260
* auto generated method signature
1261
* for "UnassignAddress|http://eucalyptus.ucsb.edu/" operation.
1263
* @param _unassignAddress
1265
* @return adb_UnassignAddressResponse_t*
1267
adb_UnassignAddressResponse_t*
1268
axis2_stub_op_EucalyptusCC_UnassignAddress( axis2_stub_t *stub, const axutil_env_t *env,
1269
adb_UnassignAddress_t* _unassignAddress)
1271
axis2_svc_client_t *svc_client = NULL;
1272
axis2_options_t *options = NULL;
1273
axiom_node_t *ret_node = NULL;
1275
const axis2_char_t *soap_action = NULL;
1276
axutil_qname_t *op_qname = NULL;
1277
axiom_node_t *payload = NULL;
1278
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1280
axutil_string_t *soap_act = NULL;
1281
adb_UnassignAddressResponse_t* ret_val = NULL;
1283
payload = adb_UnassignAddress_serialize(_unassignAddress, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1285
svc_client = axis2_stub_get_svc_client(stub, env );
1291
options = axis2_stub_get_options( stub, env);
1292
if (NULL == options)
1294
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1295
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1298
soap_action = axis2_options_get_action( options, env );
1299
if (NULL == soap_action)
1301
is_soap_act_set = AXIS2_FALSE;
1302
soap_action = "EucalyptusCC#UnassignAddress";
1304
soap_act = axutil_string_create(env, "EucalyptusCC#UnassignAddress");
1305
axis2_options_set_soap_action(options, env, soap_act);
1307
axis2_options_set_action( options, env, soap_action );
1310
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1312
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1314
if (!is_soap_act_set)
1317
axis2_options_set_soap_action(options, env, NULL);
1319
axis2_options_set_action( options, env, NULL);
1324
if ( NULL == ret_node )
1328
ret_val = adb_UnassignAddressResponse_create(env);
1330
if(adb_UnassignAddressResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1334
adb_UnassignAddressResponse_free(ret_val, env);
1337
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the UnassignAddressResponse_deserialize: "
1338
"This should be due to an invalid XML");
1346
* auto generated method signature
1347
* for "TerminateInstances|http://eucalyptus.ucsb.edu/" operation.
1349
* @param _terminateInstances
1351
* @return adb_TerminateInstancesResponse_t*
1353
adb_TerminateInstancesResponse_t*
1354
axis2_stub_op_EucalyptusCC_TerminateInstances( axis2_stub_t *stub, const axutil_env_t *env,
1355
adb_TerminateInstances_t* _terminateInstances)
1357
axis2_svc_client_t *svc_client = NULL;
1358
axis2_options_t *options = NULL;
1359
axiom_node_t *ret_node = NULL;
1361
const axis2_char_t *soap_action = NULL;
1362
axutil_qname_t *op_qname = NULL;
1363
axiom_node_t *payload = NULL;
1364
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1366
axutil_string_t *soap_act = NULL;
1367
adb_TerminateInstancesResponse_t* ret_val = NULL;
1369
payload = adb_TerminateInstances_serialize(_terminateInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1371
svc_client = axis2_stub_get_svc_client(stub, env );
1377
options = axis2_stub_get_options( stub, env);
1378
if (NULL == options)
1380
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1381
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1384
soap_action = axis2_options_get_action( options, env );
1385
if (NULL == soap_action)
1387
is_soap_act_set = AXIS2_FALSE;
1388
soap_action = "EucalyptusCC#TerminateInstances";
1390
soap_act = axutil_string_create(env, "EucalyptusCC#TerminateInstances");
1391
axis2_options_set_soap_action(options, env, soap_act);
1393
axis2_options_set_action( options, env, soap_action );
1396
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1398
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1400
if (!is_soap_act_set)
1403
axis2_options_set_soap_action(options, env, NULL);
1405
axis2_options_set_action( options, env, NULL);
1410
if ( NULL == ret_node )
1414
ret_val = adb_TerminateInstancesResponse_create(env);
1416
if(adb_TerminateInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1420
adb_TerminateInstancesResponse_free(ret_val, env);
1423
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the TerminateInstancesResponse_deserialize: "
1424
"This should be due to an invalid XML");
1432
* auto generated method signature
1433
* for "DetachVolume|http://eucalyptus.ucsb.edu/" operation.
1435
* @param _detachVolume
1437
* @return adb_DetachVolumeResponse_t*
1439
adb_DetachVolumeResponse_t*
1440
axis2_stub_op_EucalyptusCC_DetachVolume( axis2_stub_t *stub, const axutil_env_t *env,
1441
adb_DetachVolume_t* _detachVolume)
1443
axis2_svc_client_t *svc_client = NULL;
1444
axis2_options_t *options = NULL;
1445
axiom_node_t *ret_node = NULL;
1447
const axis2_char_t *soap_action = NULL;
1448
axutil_qname_t *op_qname = NULL;
1449
axiom_node_t *payload = NULL;
1450
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1452
axutil_string_t *soap_act = NULL;
1453
adb_DetachVolumeResponse_t* ret_val = NULL;
1455
payload = adb_DetachVolume_serialize(_detachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1457
svc_client = axis2_stub_get_svc_client(stub, env );
1463
options = axis2_stub_get_options( stub, env);
1464
if (NULL == options)
1466
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1467
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1470
soap_action = axis2_options_get_action( options, env );
1471
if (NULL == soap_action)
1473
is_soap_act_set = AXIS2_FALSE;
1474
soap_action = "EucalyptusCC#DetachVolume";
1476
soap_act = axutil_string_create(env, "EucalyptusCC#DetachVolume");
1477
axis2_options_set_soap_action(options, env, soap_act);
1479
axis2_options_set_action( options, env, soap_action );
1482
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1484
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1486
if (!is_soap_act_set)
1489
axis2_options_set_soap_action(options, env, NULL);
1491
axis2_options_set_action( options, env, NULL);
1496
if ( NULL == ret_node )
1500
ret_val = adb_DetachVolumeResponse_create(env);
1502
if(adb_DetachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1506
adb_DetachVolumeResponse_free(ret_val, env);
1509
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the DetachVolumeResponse_deserialize: "
1510
"This should be due to an invalid XML");
1518
* auto generated method signature
1519
* for "AttachVolume|http://eucalyptus.ucsb.edu/" operation.
1521
* @param _attachVolume
1523
* @return adb_AttachVolumeResponse_t*
1525
adb_AttachVolumeResponse_t*
1526
axis2_stub_op_EucalyptusCC_AttachVolume( axis2_stub_t *stub, const axutil_env_t *env,
1527
adb_AttachVolume_t* _attachVolume)
1529
axis2_svc_client_t *svc_client = NULL;
1530
axis2_options_t *options = NULL;
1531
axiom_node_t *ret_node = NULL;
1533
const axis2_char_t *soap_action = NULL;
1534
axutil_qname_t *op_qname = NULL;
1535
axiom_node_t *payload = NULL;
1536
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1538
axutil_string_t *soap_act = NULL;
1539
adb_AttachVolumeResponse_t* ret_val = NULL;
1541
payload = adb_AttachVolume_serialize(_attachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1543
svc_client = axis2_stub_get_svc_client(stub, env );
1549
options = axis2_stub_get_options( stub, env);
1550
if (NULL == options)
1552
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1553
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1556
soap_action = axis2_options_get_action( options, env );
1557
if (NULL == soap_action)
1559
is_soap_act_set = AXIS2_FALSE;
1560
soap_action = "EucalyptusCC#AttachVolume";
1562
soap_act = axutil_string_create(env, "EucalyptusCC#AttachVolume");
1563
axis2_options_set_soap_action(options, env, soap_act);
1565
axis2_options_set_action( options, env, soap_action );
1568
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1570
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1572
if (!is_soap_act_set)
1575
axis2_options_set_soap_action(options, env, NULL);
1577
axis2_options_set_action( options, env, NULL);
1582
if ( NULL == ret_node )
1586
ret_val = adb_AttachVolumeResponse_create(env);
1588
if(adb_AttachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1592
adb_AttachVolumeResponse_free(ret_val, env);
1595
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the AttachVolumeResponse_deserialize: "
1596
"This should be due to an invalid XML");
1604
* auto generated method signature
1605
* for "RunInstances|http://eucalyptus.ucsb.edu/" operation.
1607
* @param _runInstances
1609
* @return adb_RunInstancesResponse_t*
1611
adb_RunInstancesResponse_t*
1612
axis2_stub_op_EucalyptusCC_RunInstances( axis2_stub_t *stub, const axutil_env_t *env,
1613
adb_RunInstances_t* _runInstances)
1615
axis2_svc_client_t *svc_client = NULL;
1616
axis2_options_t *options = NULL;
1617
axiom_node_t *ret_node = NULL;
1619
const axis2_char_t *soap_action = NULL;
1620
axutil_qname_t *op_qname = NULL;
1621
axiom_node_t *payload = NULL;
1622
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1624
axutil_string_t *soap_act = NULL;
1625
adb_RunInstancesResponse_t* ret_val = NULL;
1627
payload = adb_RunInstances_serialize(_runInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1629
svc_client = axis2_stub_get_svc_client(stub, env );
1635
options = axis2_stub_get_options( stub, env);
1636
if (NULL == options)
1638
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1639
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
1642
soap_action = axis2_options_get_action( options, env );
1643
if (NULL == soap_action)
1645
is_soap_act_set = AXIS2_FALSE;
1646
soap_action = "EucalyptusCC#RunInstances";
1648
soap_act = axutil_string_create(env, "EucalyptusCC#RunInstances");
1649
axis2_options_set_soap_action(options, env, soap_act);
1651
axis2_options_set_action( options, env, soap_action );
1654
axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
1656
ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
1658
if (!is_soap_act_set)
1661
axis2_options_set_soap_action(options, env, NULL);
1663
axis2_options_set_action( options, env, NULL);
1668
if ( NULL == ret_node )
1672
ret_val = adb_RunInstancesResponse_create(env);
1674
if(adb_RunInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1678
adb_RunInstancesResponse_free(ret_val, env);
1681
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the RunInstancesResponse_deserialize: "
1682
"This should be due to an invalid XML");
1690
struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data
1693
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeInstancesResponse_t* _describeInstancesResponse, void *data);
1694
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1697
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_DescribeInstances(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1699
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1700
struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data* callback_data = NULL;
1701
void *user_data = NULL;
1703
axis2_status_t status;
1705
callback_data = (struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data*)axis2_callback_get_data(callback);
1707
user_data = callback_data->data;
1708
on_error = callback_data->on_error;
1710
status = on_error(env, exception, user_data);
1714
AXIS2_FREE(env->allocator, callback_data);
1719
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_DescribeInstances(axis2_callback_t *callback, const axutil_env_t *env)
1721
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeInstancesResponse_t* _describeInstancesResponse, void *data);
1722
struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data* callback_data = NULL;
1723
void *user_data = NULL;
1724
axis2_status_t status = AXIS2_SUCCESS;
1726
adb_DescribeInstancesResponse_t* ret_val = NULL;
1729
axiom_node_t *ret_node = NULL;
1730
axiom_soap_envelope_t *soap_envelope = NULL;
1734
callback_data = (struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data*)axis2_callback_get_data(callback);
1736
soap_envelope = axis2_callback_get_envelope(callback, env);
1739
axiom_soap_body_t *soap_body;
1740
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1743
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1746
ret_node = axiom_node_get_first_child(body_node, env);
1753
user_data = callback_data->data;
1754
on_complete = callback_data->on_complete;
1757
if(ret_node != NULL)
1759
ret_val = adb_DescribeInstancesResponse_create(env);
1761
if(adb_DescribeInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1763
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1764
"This should be due to an invalid XML");
1765
adb_DescribeInstancesResponse_free(ret_val, env);
1773
status = on_complete(env, ret_val, user_data);
1778
AXIS2_FREE(env->allocator, callback_data);
1784
* auto generated method signature for asynchronous invocations
1785
* for "DescribeInstances|http://eucalyptus.ucsb.edu/" operation.
1788
* @param _describeInstances
1789
* @param on_complete callback to handle on complete
1790
* @param on_error callback to handle on error
1792
void axis2_stub_start_op_EucalyptusCC_DescribeInstances( axis2_stub_t *stub, const axutil_env_t *env,
1793
adb_DescribeInstances_t* _describeInstances,
1795
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeInstancesResponse_t* _describeInstancesResponse, void *data) ,
1796
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
1799
axis2_callback_t *callback = NULL;
1801
axis2_svc_client_t *svc_client = NULL;
1802
axis2_options_t *options = NULL;
1804
const axis2_char_t *soap_action = NULL;
1805
axiom_node_t *payload = NULL;
1807
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1809
axutil_string_t *soap_act = NULL;
1812
struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data *callback_data;
1814
callback_data = (struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data*) AXIS2_MALLOC(env->allocator,
1815
sizeof(struct axis2_stub_EucalyptusCC_DescribeInstances_callback_data));
1816
if(NULL == callback_data)
1818
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
1823
payload = adb_DescribeInstances_serialize(_describeInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
1828
options = axis2_stub_get_options( stub, env);
1829
if (NULL == options)
1831
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1832
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
1835
svc_client = axis2_stub_get_svc_client (stub, env);
1836
soap_action =axis2_options_get_action (options, env);
1837
if (NULL == soap_action)
1839
is_soap_act_set = AXIS2_FALSE;
1840
soap_action = "EucalyptusCC#DescribeInstances";
1842
soap_act = axutil_string_create(env, "EucalyptusCC#DescribeInstances");
1843
axis2_options_set_soap_action(options, env, soap_act);
1845
axis2_options_set_action( options, env, soap_action);
1848
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
1851
callback = axis2_callback_create(env);
1852
/* Set our on_complete fucntion pointer to the callback object */
1853
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_DescribeInstances);
1854
/* Set our on_error function pointer to the callback object */
1855
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_DescribeInstances);
1857
callback_data-> data = user_data;
1858
callback_data-> on_complete = on_complete;
1859
callback_data-> on_error = on_error;
1861
axis2_callback_set_data(callback, (void*)callback_data);
1864
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
1866
if (!is_soap_act_set)
1869
axis2_options_set_soap_action(options, env, NULL);
1871
axis2_options_set_action(options, env, NULL);
1877
struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data
1880
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ConfigureNetworkResponse_t* _configureNetworkResponse, void *data);
1881
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
1884
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_ConfigureNetwork(axis2_callback_t *callback, const axutil_env_t *env, int exception)
1886
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
1887
struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data* callback_data = NULL;
1888
void *user_data = NULL;
1890
axis2_status_t status;
1892
callback_data = (struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data*)axis2_callback_get_data(callback);
1894
user_data = callback_data->data;
1895
on_error = callback_data->on_error;
1897
status = on_error(env, exception, user_data);
1901
AXIS2_FREE(env->allocator, callback_data);
1906
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_ConfigureNetwork(axis2_callback_t *callback, const axutil_env_t *env)
1908
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ConfigureNetworkResponse_t* _configureNetworkResponse, void *data);
1909
struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data* callback_data = NULL;
1910
void *user_data = NULL;
1911
axis2_status_t status = AXIS2_SUCCESS;
1913
adb_ConfigureNetworkResponse_t* ret_val = NULL;
1916
axiom_node_t *ret_node = NULL;
1917
axiom_soap_envelope_t *soap_envelope = NULL;
1921
callback_data = (struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data*)axis2_callback_get_data(callback);
1923
soap_envelope = axis2_callback_get_envelope(callback, env);
1926
axiom_soap_body_t *soap_body;
1927
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
1930
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
1933
ret_node = axiom_node_get_first_child(body_node, env);
1940
user_data = callback_data->data;
1941
on_complete = callback_data->on_complete;
1944
if(ret_node != NULL)
1946
ret_val = adb_ConfigureNetworkResponse_create(env);
1948
if(adb_ConfigureNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1950
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
1951
"This should be due to an invalid XML");
1952
adb_ConfigureNetworkResponse_free(ret_val, env);
1960
status = on_complete(env, ret_val, user_data);
1965
AXIS2_FREE(env->allocator, callback_data);
1971
* auto generated method signature for asynchronous invocations
1972
* for "ConfigureNetwork|http://eucalyptus.ucsb.edu/" operation.
1975
* @param _configureNetwork
1976
* @param on_complete callback to handle on complete
1977
* @param on_error callback to handle on error
1979
void axis2_stub_start_op_EucalyptusCC_ConfigureNetwork( axis2_stub_t *stub, const axutil_env_t *env,
1980
adb_ConfigureNetwork_t* _configureNetwork,
1982
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ConfigureNetworkResponse_t* _configureNetworkResponse, void *data) ,
1983
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
1986
axis2_callback_t *callback = NULL;
1988
axis2_svc_client_t *svc_client = NULL;
1989
axis2_options_t *options = NULL;
1991
const axis2_char_t *soap_action = NULL;
1992
axiom_node_t *payload = NULL;
1994
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1996
axutil_string_t *soap_act = NULL;
1999
struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data *callback_data;
2001
callback_data = (struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data*) AXIS2_MALLOC(env->allocator,
2002
sizeof(struct axis2_stub_EucalyptusCC_ConfigureNetwork_callback_data));
2003
if(NULL == callback_data)
2005
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2010
payload = adb_ConfigureNetwork_serialize(_configureNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2015
options = axis2_stub_get_options( stub, env);
2016
if (NULL == options)
2018
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2019
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2022
svc_client = axis2_stub_get_svc_client (stub, env);
2023
soap_action =axis2_options_get_action (options, env);
2024
if (NULL == soap_action)
2026
is_soap_act_set = AXIS2_FALSE;
2027
soap_action = "EucalyptusCC#ConfigureNetwork";
2029
soap_act = axutil_string_create(env, "EucalyptusCC#ConfigureNetwork");
2030
axis2_options_set_soap_action(options, env, soap_act);
2032
axis2_options_set_action( options, env, soap_action);
2035
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2038
callback = axis2_callback_create(env);
2039
/* Set our on_complete fucntion pointer to the callback object */
2040
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_ConfigureNetwork);
2041
/* Set our on_error function pointer to the callback object */
2042
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_ConfigureNetwork);
2044
callback_data-> data = user_data;
2045
callback_data-> on_complete = on_complete;
2046
callback_data-> on_error = on_error;
2048
axis2_callback_set_data(callback, (void*)callback_data);
2051
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2053
if (!is_soap_act_set)
2056
axis2_options_set_soap_action(options, env, NULL);
2058
axis2_options_set_action(options, env, NULL);
2064
struct axis2_stub_EucalyptusCC_DescribeResources_callback_data
2067
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeResourcesResponse_t* _describeResourcesResponse, void *data);
2068
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2071
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_DescribeResources(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2073
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2074
struct axis2_stub_EucalyptusCC_DescribeResources_callback_data* callback_data = NULL;
2075
void *user_data = NULL;
2077
axis2_status_t status;
2079
callback_data = (struct axis2_stub_EucalyptusCC_DescribeResources_callback_data*)axis2_callback_get_data(callback);
2081
user_data = callback_data->data;
2082
on_error = callback_data->on_error;
2084
status = on_error(env, exception, user_data);
2088
AXIS2_FREE(env->allocator, callback_data);
2093
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_DescribeResources(axis2_callback_t *callback, const axutil_env_t *env)
2095
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeResourcesResponse_t* _describeResourcesResponse, void *data);
2096
struct axis2_stub_EucalyptusCC_DescribeResources_callback_data* callback_data = NULL;
2097
void *user_data = NULL;
2098
axis2_status_t status = AXIS2_SUCCESS;
2100
adb_DescribeResourcesResponse_t* ret_val = NULL;
2103
axiom_node_t *ret_node = NULL;
2104
axiom_soap_envelope_t *soap_envelope = NULL;
2108
callback_data = (struct axis2_stub_EucalyptusCC_DescribeResources_callback_data*)axis2_callback_get_data(callback);
2110
soap_envelope = axis2_callback_get_envelope(callback, env);
2113
axiom_soap_body_t *soap_body;
2114
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2117
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2120
ret_node = axiom_node_get_first_child(body_node, env);
2127
user_data = callback_data->data;
2128
on_complete = callback_data->on_complete;
2131
if(ret_node != NULL)
2133
ret_val = adb_DescribeResourcesResponse_create(env);
2135
if(adb_DescribeResourcesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2137
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2138
"This should be due to an invalid XML");
2139
adb_DescribeResourcesResponse_free(ret_val, env);
2147
status = on_complete(env, ret_val, user_data);
2152
AXIS2_FREE(env->allocator, callback_data);
2158
* auto generated method signature for asynchronous invocations
2159
* for "DescribeResources|http://eucalyptus.ucsb.edu/" operation.
2162
* @param _describeResources
2163
* @param on_complete callback to handle on complete
2164
* @param on_error callback to handle on error
2166
void axis2_stub_start_op_EucalyptusCC_DescribeResources( axis2_stub_t *stub, const axutil_env_t *env,
2167
adb_DescribeResources_t* _describeResources,
2169
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeResourcesResponse_t* _describeResourcesResponse, void *data) ,
2170
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2173
axis2_callback_t *callback = NULL;
2175
axis2_svc_client_t *svc_client = NULL;
2176
axis2_options_t *options = NULL;
2178
const axis2_char_t *soap_action = NULL;
2179
axiom_node_t *payload = NULL;
2181
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2183
axutil_string_t *soap_act = NULL;
2186
struct axis2_stub_EucalyptusCC_DescribeResources_callback_data *callback_data;
2188
callback_data = (struct axis2_stub_EucalyptusCC_DescribeResources_callback_data*) AXIS2_MALLOC(env->allocator,
2189
sizeof(struct axis2_stub_EucalyptusCC_DescribeResources_callback_data));
2190
if(NULL == callback_data)
2192
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2197
payload = adb_DescribeResources_serialize(_describeResources, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2202
options = axis2_stub_get_options( stub, env);
2203
if (NULL == options)
2205
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2206
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2209
svc_client = axis2_stub_get_svc_client (stub, env);
2210
soap_action =axis2_options_get_action (options, env);
2211
if (NULL == soap_action)
2213
is_soap_act_set = AXIS2_FALSE;
2214
soap_action = "EucalyptusCC#DescribeResources";
2216
soap_act = axutil_string_create(env, "EucalyptusCC#DescribeResources");
2217
axis2_options_set_soap_action(options, env, soap_act);
2219
axis2_options_set_action( options, env, soap_action);
2222
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2225
callback = axis2_callback_create(env);
2226
/* Set our on_complete fucntion pointer to the callback object */
2227
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_DescribeResources);
2228
/* Set our on_error function pointer to the callback object */
2229
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_DescribeResources);
2231
callback_data-> data = user_data;
2232
callback_data-> on_complete = on_complete;
2233
callback_data-> on_error = on_error;
2235
axis2_callback_set_data(callback, (void*)callback_data);
2238
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2240
if (!is_soap_act_set)
2243
axis2_options_set_soap_action(options, env, NULL);
2245
axis2_options_set_action(options, env, NULL);
2251
struct axis2_stub_EucalyptusCC_StartNetwork_callback_data
2254
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StartNetworkResponse_t* _startNetworkResponse, void *data);
2255
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2258
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_StartNetwork(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2260
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2261
struct axis2_stub_EucalyptusCC_StartNetwork_callback_data* callback_data = NULL;
2262
void *user_data = NULL;
2264
axis2_status_t status;
2266
callback_data = (struct axis2_stub_EucalyptusCC_StartNetwork_callback_data*)axis2_callback_get_data(callback);
2268
user_data = callback_data->data;
2269
on_error = callback_data->on_error;
2271
status = on_error(env, exception, user_data);
2275
AXIS2_FREE(env->allocator, callback_data);
2280
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_StartNetwork(axis2_callback_t *callback, const axutil_env_t *env)
2282
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StartNetworkResponse_t* _startNetworkResponse, void *data);
2283
struct axis2_stub_EucalyptusCC_StartNetwork_callback_data* callback_data = NULL;
2284
void *user_data = NULL;
2285
axis2_status_t status = AXIS2_SUCCESS;
2287
adb_StartNetworkResponse_t* ret_val = NULL;
2290
axiom_node_t *ret_node = NULL;
2291
axiom_soap_envelope_t *soap_envelope = NULL;
2295
callback_data = (struct axis2_stub_EucalyptusCC_StartNetwork_callback_data*)axis2_callback_get_data(callback);
2297
soap_envelope = axis2_callback_get_envelope(callback, env);
2300
axiom_soap_body_t *soap_body;
2301
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2304
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2307
ret_node = axiom_node_get_first_child(body_node, env);
2314
user_data = callback_data->data;
2315
on_complete = callback_data->on_complete;
2318
if(ret_node != NULL)
2320
ret_val = adb_StartNetworkResponse_create(env);
2322
if(adb_StartNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2324
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2325
"This should be due to an invalid XML");
2326
adb_StartNetworkResponse_free(ret_val, env);
2334
status = on_complete(env, ret_val, user_data);
2339
AXIS2_FREE(env->allocator, callback_data);
2345
* auto generated method signature for asynchronous invocations
2346
* for "StartNetwork|http://eucalyptus.ucsb.edu/" operation.
2349
* @param _startNetwork
2350
* @param on_complete callback to handle on complete
2351
* @param on_error callback to handle on error
2353
void axis2_stub_start_op_EucalyptusCC_StartNetwork( axis2_stub_t *stub, const axutil_env_t *env,
2354
adb_StartNetwork_t* _startNetwork,
2356
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StartNetworkResponse_t* _startNetworkResponse, void *data) ,
2357
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2360
axis2_callback_t *callback = NULL;
2362
axis2_svc_client_t *svc_client = NULL;
2363
axis2_options_t *options = NULL;
2365
const axis2_char_t *soap_action = NULL;
2366
axiom_node_t *payload = NULL;
2368
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2370
axutil_string_t *soap_act = NULL;
2373
struct axis2_stub_EucalyptusCC_StartNetwork_callback_data *callback_data;
2375
callback_data = (struct axis2_stub_EucalyptusCC_StartNetwork_callback_data*) AXIS2_MALLOC(env->allocator,
2376
sizeof(struct axis2_stub_EucalyptusCC_StartNetwork_callback_data));
2377
if(NULL == callback_data)
2379
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2384
payload = adb_StartNetwork_serialize(_startNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2389
options = axis2_stub_get_options( stub, env);
2390
if (NULL == options)
2392
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2393
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2396
svc_client = axis2_stub_get_svc_client (stub, env);
2397
soap_action =axis2_options_get_action (options, env);
2398
if (NULL == soap_action)
2400
is_soap_act_set = AXIS2_FALSE;
2401
soap_action = "EucalyptusCC#StartNetwork";
2403
soap_act = axutil_string_create(env, "EucalyptusCC#StartNetwork");
2404
axis2_options_set_soap_action(options, env, soap_act);
2406
axis2_options_set_action( options, env, soap_action);
2409
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2412
callback = axis2_callback_create(env);
2413
/* Set our on_complete fucntion pointer to the callback object */
2414
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_StartNetwork);
2415
/* Set our on_error function pointer to the callback object */
2416
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_StartNetwork);
2418
callback_data-> data = user_data;
2419
callback_data-> on_complete = on_complete;
2420
callback_data-> on_error = on_error;
2422
axis2_callback_set_data(callback, (void*)callback_data);
2425
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2427
if (!is_soap_act_set)
2430
axis2_options_set_soap_action(options, env, NULL);
2432
axis2_options_set_action(options, env, NULL);
2438
struct axis2_stub_EucalyptusCC_StopNetwork_callback_data
2441
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StopNetworkResponse_t* _stopNetworkResponse, void *data);
2442
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2445
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_StopNetwork(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2447
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2448
struct axis2_stub_EucalyptusCC_StopNetwork_callback_data* callback_data = NULL;
2449
void *user_data = NULL;
2451
axis2_status_t status;
2453
callback_data = (struct axis2_stub_EucalyptusCC_StopNetwork_callback_data*)axis2_callback_get_data(callback);
2455
user_data = callback_data->data;
2456
on_error = callback_data->on_error;
2458
status = on_error(env, exception, user_data);
2462
AXIS2_FREE(env->allocator, callback_data);
2467
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_StopNetwork(axis2_callback_t *callback, const axutil_env_t *env)
2469
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StopNetworkResponse_t* _stopNetworkResponse, void *data);
2470
struct axis2_stub_EucalyptusCC_StopNetwork_callback_data* callback_data = NULL;
2471
void *user_data = NULL;
2472
axis2_status_t status = AXIS2_SUCCESS;
2474
adb_StopNetworkResponse_t* ret_val = NULL;
2477
axiom_node_t *ret_node = NULL;
2478
axiom_soap_envelope_t *soap_envelope = NULL;
2482
callback_data = (struct axis2_stub_EucalyptusCC_StopNetwork_callback_data*)axis2_callback_get_data(callback);
2484
soap_envelope = axis2_callback_get_envelope(callback, env);
2487
axiom_soap_body_t *soap_body;
2488
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2491
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2494
ret_node = axiom_node_get_first_child(body_node, env);
2501
user_data = callback_data->data;
2502
on_complete = callback_data->on_complete;
2505
if(ret_node != NULL)
2507
ret_val = adb_StopNetworkResponse_create(env);
2509
if(adb_StopNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2511
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2512
"This should be due to an invalid XML");
2513
adb_StopNetworkResponse_free(ret_val, env);
2521
status = on_complete(env, ret_val, user_data);
2526
AXIS2_FREE(env->allocator, callback_data);
2532
* auto generated method signature for asynchronous invocations
2533
* for "StopNetwork|http://eucalyptus.ucsb.edu/" operation.
2536
* @param _stopNetwork
2537
* @param on_complete callback to handle on complete
2538
* @param on_error callback to handle on error
2540
void axis2_stub_start_op_EucalyptusCC_StopNetwork( axis2_stub_t *stub, const axutil_env_t *env,
2541
adb_StopNetwork_t* _stopNetwork,
2543
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_StopNetworkResponse_t* _stopNetworkResponse, void *data) ,
2544
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2547
axis2_callback_t *callback = NULL;
2549
axis2_svc_client_t *svc_client = NULL;
2550
axis2_options_t *options = NULL;
2552
const axis2_char_t *soap_action = NULL;
2553
axiom_node_t *payload = NULL;
2555
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2557
axutil_string_t *soap_act = NULL;
2560
struct axis2_stub_EucalyptusCC_StopNetwork_callback_data *callback_data;
2562
callback_data = (struct axis2_stub_EucalyptusCC_StopNetwork_callback_data*) AXIS2_MALLOC(env->allocator,
2563
sizeof(struct axis2_stub_EucalyptusCC_StopNetwork_callback_data));
2564
if(NULL == callback_data)
2566
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2571
payload = adb_StopNetwork_serialize(_stopNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2576
options = axis2_stub_get_options( stub, env);
2577
if (NULL == options)
2579
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2580
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2583
svc_client = axis2_stub_get_svc_client (stub, env);
2584
soap_action =axis2_options_get_action (options, env);
2585
if (NULL == soap_action)
2587
is_soap_act_set = AXIS2_FALSE;
2588
soap_action = "EucalyptusCC#StopNetwork";
2590
soap_act = axutil_string_create(env, "EucalyptusCC#StopNetwork");
2591
axis2_options_set_soap_action(options, env, soap_act);
2593
axis2_options_set_action( options, env, soap_action);
2596
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2599
callback = axis2_callback_create(env);
2600
/* Set our on_complete fucntion pointer to the callback object */
2601
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_StopNetwork);
2602
/* Set our on_error function pointer to the callback object */
2603
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_StopNetwork);
2605
callback_data-> data = user_data;
2606
callback_data-> on_complete = on_complete;
2607
callback_data-> on_error = on_error;
2609
axis2_callback_set_data(callback, (void*)callback_data);
2612
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2614
if (!is_soap_act_set)
2617
axis2_options_set_soap_action(options, env, NULL);
2619
axis2_options_set_action(options, env, NULL);
2625
struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data
2628
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeNetworksResponse_t* _describeNetworksResponse, void *data);
2629
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2632
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_DescribeNetworks(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2634
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2635
struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data* callback_data = NULL;
2636
void *user_data = NULL;
2638
axis2_status_t status;
2640
callback_data = (struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data*)axis2_callback_get_data(callback);
2642
user_data = callback_data->data;
2643
on_error = callback_data->on_error;
2645
status = on_error(env, exception, user_data);
2649
AXIS2_FREE(env->allocator, callback_data);
2654
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_DescribeNetworks(axis2_callback_t *callback, const axutil_env_t *env)
2656
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeNetworksResponse_t* _describeNetworksResponse, void *data);
2657
struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data* callback_data = NULL;
2658
void *user_data = NULL;
2659
axis2_status_t status = AXIS2_SUCCESS;
2661
adb_DescribeNetworksResponse_t* ret_val = NULL;
2664
axiom_node_t *ret_node = NULL;
2665
axiom_soap_envelope_t *soap_envelope = NULL;
2669
callback_data = (struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data*)axis2_callback_get_data(callback);
2671
soap_envelope = axis2_callback_get_envelope(callback, env);
2674
axiom_soap_body_t *soap_body;
2675
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2678
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2681
ret_node = axiom_node_get_first_child(body_node, env);
2688
user_data = callback_data->data;
2689
on_complete = callback_data->on_complete;
2692
if(ret_node != NULL)
2694
ret_val = adb_DescribeNetworksResponse_create(env);
2696
if(adb_DescribeNetworksResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2698
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2699
"This should be due to an invalid XML");
2700
adb_DescribeNetworksResponse_free(ret_val, env);
2708
status = on_complete(env, ret_val, user_data);
2713
AXIS2_FREE(env->allocator, callback_data);
2719
* auto generated method signature for asynchronous invocations
2720
* for "DescribeNetworks|http://eucalyptus.ucsb.edu/" operation.
2723
* @param _describeNetworks
2724
* @param on_complete callback to handle on complete
2725
* @param on_error callback to handle on error
2727
void axis2_stub_start_op_EucalyptusCC_DescribeNetworks( axis2_stub_t *stub, const axutil_env_t *env,
2728
adb_DescribeNetworks_t* _describeNetworks,
2730
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribeNetworksResponse_t* _describeNetworksResponse, void *data) ,
2731
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2734
axis2_callback_t *callback = NULL;
2736
axis2_svc_client_t *svc_client = NULL;
2737
axis2_options_t *options = NULL;
2739
const axis2_char_t *soap_action = NULL;
2740
axiom_node_t *payload = NULL;
2742
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2744
axutil_string_t *soap_act = NULL;
2747
struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data *callback_data;
2749
callback_data = (struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data*) AXIS2_MALLOC(env->allocator,
2750
sizeof(struct axis2_stub_EucalyptusCC_DescribeNetworks_callback_data));
2751
if(NULL == callback_data)
2753
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2758
payload = adb_DescribeNetworks_serialize(_describeNetworks, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2763
options = axis2_stub_get_options( stub, env);
2764
if (NULL == options)
2766
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2767
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2770
svc_client = axis2_stub_get_svc_client (stub, env);
2771
soap_action =axis2_options_get_action (options, env);
2772
if (NULL == soap_action)
2774
is_soap_act_set = AXIS2_FALSE;
2775
soap_action = "EucalyptusCC#DescribeNetworks";
2777
soap_act = axutil_string_create(env, "EucalyptusCC#DescribeNetworks");
2778
axis2_options_set_soap_action(options, env, soap_act);
2780
axis2_options_set_action( options, env, soap_action);
2783
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2786
callback = axis2_callback_create(env);
2787
/* Set our on_complete fucntion pointer to the callback object */
2788
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_DescribeNetworks);
2789
/* Set our on_error function pointer to the callback object */
2790
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_DescribeNetworks);
2792
callback_data-> data = user_data;
2793
callback_data-> on_complete = on_complete;
2794
callback_data-> on_error = on_error;
2796
axis2_callback_set_data(callback, (void*)callback_data);
2799
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2801
if (!is_soap_act_set)
2804
axis2_options_set_soap_action(options, env, NULL);
2806
axis2_options_set_action(options, env, NULL);
2812
struct axis2_stub_EucalyptusCC_AssignAddress_callback_data
2815
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_AssignAddressResponse_t* _assignAddressResponse, void *data);
2816
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
2819
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_AssignAddress(axis2_callback_t *callback, const axutil_env_t *env, int exception)
2821
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
2822
struct axis2_stub_EucalyptusCC_AssignAddress_callback_data* callback_data = NULL;
2823
void *user_data = NULL;
2825
axis2_status_t status;
2827
callback_data = (struct axis2_stub_EucalyptusCC_AssignAddress_callback_data*)axis2_callback_get_data(callback);
2829
user_data = callback_data->data;
2830
on_error = callback_data->on_error;
2832
status = on_error(env, exception, user_data);
2836
AXIS2_FREE(env->allocator, callback_data);
2841
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_AssignAddress(axis2_callback_t *callback, const axutil_env_t *env)
2843
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_AssignAddressResponse_t* _assignAddressResponse, void *data);
2844
struct axis2_stub_EucalyptusCC_AssignAddress_callback_data* callback_data = NULL;
2845
void *user_data = NULL;
2846
axis2_status_t status = AXIS2_SUCCESS;
2848
adb_AssignAddressResponse_t* ret_val = NULL;
2851
axiom_node_t *ret_node = NULL;
2852
axiom_soap_envelope_t *soap_envelope = NULL;
2856
callback_data = (struct axis2_stub_EucalyptusCC_AssignAddress_callback_data*)axis2_callback_get_data(callback);
2858
soap_envelope = axis2_callback_get_envelope(callback, env);
2861
axiom_soap_body_t *soap_body;
2862
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
2865
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
2868
ret_node = axiom_node_get_first_child(body_node, env);
2875
user_data = callback_data->data;
2876
on_complete = callback_data->on_complete;
2879
if(ret_node != NULL)
2881
ret_val = adb_AssignAddressResponse_create(env);
2883
if(adb_AssignAddressResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
2885
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
2886
"This should be due to an invalid XML");
2887
adb_AssignAddressResponse_free(ret_val, env);
2895
status = on_complete(env, ret_val, user_data);
2900
AXIS2_FREE(env->allocator, callback_data);
2906
* auto generated method signature for asynchronous invocations
2907
* for "AssignAddress|http://eucalyptus.ucsb.edu/" operation.
2910
* @param _assignAddress
2911
* @param on_complete callback to handle on complete
2912
* @param on_error callback to handle on error
2914
void axis2_stub_start_op_EucalyptusCC_AssignAddress( axis2_stub_t *stub, const axutil_env_t *env,
2915
adb_AssignAddress_t* _assignAddress,
2917
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_AssignAddressResponse_t* _assignAddressResponse, void *data) ,
2918
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
2921
axis2_callback_t *callback = NULL;
2923
axis2_svc_client_t *svc_client = NULL;
2924
axis2_options_t *options = NULL;
2926
const axis2_char_t *soap_action = NULL;
2927
axiom_node_t *payload = NULL;
2929
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
2931
axutil_string_t *soap_act = NULL;
2934
struct axis2_stub_EucalyptusCC_AssignAddress_callback_data *callback_data;
2936
callback_data = (struct axis2_stub_EucalyptusCC_AssignAddress_callback_data*) AXIS2_MALLOC(env->allocator,
2937
sizeof(struct axis2_stub_EucalyptusCC_AssignAddress_callback_data));
2938
if(NULL == callback_data)
2940
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
2945
payload = adb_AssignAddress_serialize(_assignAddress, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
2950
options = axis2_stub_get_options( stub, env);
2951
if (NULL == options)
2953
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
2954
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
2957
svc_client = axis2_stub_get_svc_client (stub, env);
2958
soap_action =axis2_options_get_action (options, env);
2959
if (NULL == soap_action)
2961
is_soap_act_set = AXIS2_FALSE;
2962
soap_action = "EucalyptusCC#AssignAddress";
2964
soap_act = axutil_string_create(env, "EucalyptusCC#AssignAddress");
2965
axis2_options_set_soap_action(options, env, soap_act);
2967
axis2_options_set_action( options, env, soap_action);
2970
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
2973
callback = axis2_callback_create(env);
2974
/* Set our on_complete fucntion pointer to the callback object */
2975
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_AssignAddress);
2976
/* Set our on_error function pointer to the callback object */
2977
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_AssignAddress);
2979
callback_data-> data = user_data;
2980
callback_data-> on_complete = on_complete;
2981
callback_data-> on_error = on_error;
2983
axis2_callback_set_data(callback, (void*)callback_data);
2986
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
2988
if (!is_soap_act_set)
2991
axis2_options_set_soap_action(options, env, NULL);
2993
axis2_options_set_action(options, env, NULL);
2999
struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data
3002
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribePublicAddressesResponse_t* _describePublicAddressesResponse, void *data);
3003
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
3006
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_DescribePublicAddresses(axis2_callback_t *callback, const axutil_env_t *env, int exception)
3008
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
3009
struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data* callback_data = NULL;
3010
void *user_data = NULL;
3012
axis2_status_t status;
3014
callback_data = (struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data*)axis2_callback_get_data(callback);
3016
user_data = callback_data->data;
3017
on_error = callback_data->on_error;
3019
status = on_error(env, exception, user_data);
3023
AXIS2_FREE(env->allocator, callback_data);
3028
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_DescribePublicAddresses(axis2_callback_t *callback, const axutil_env_t *env)
3030
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribePublicAddressesResponse_t* _describePublicAddressesResponse, void *data);
3031
struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data* callback_data = NULL;
3032
void *user_data = NULL;
3033
axis2_status_t status = AXIS2_SUCCESS;
3035
adb_DescribePublicAddressesResponse_t* ret_val = NULL;
3038
axiom_node_t *ret_node = NULL;
3039
axiom_soap_envelope_t *soap_envelope = NULL;
3043
callback_data = (struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data*)axis2_callback_get_data(callback);
3045
soap_envelope = axis2_callback_get_envelope(callback, env);
3048
axiom_soap_body_t *soap_body;
3049
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
3052
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
3055
ret_node = axiom_node_get_first_child(body_node, env);
3062
user_data = callback_data->data;
3063
on_complete = callback_data->on_complete;
3066
if(ret_node != NULL)
3068
ret_val = adb_DescribePublicAddressesResponse_create(env);
3070
if(adb_DescribePublicAddressesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
3072
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
3073
"This should be due to an invalid XML");
3074
adb_DescribePublicAddressesResponse_free(ret_val, env);
3082
status = on_complete(env, ret_val, user_data);
3087
AXIS2_FREE(env->allocator, callback_data);
3093
* auto generated method signature for asynchronous invocations
3094
* for "DescribePublicAddresses|http://eucalyptus.ucsb.edu/" operation.
3097
* @param _describePublicAddresses
3098
* @param on_complete callback to handle on complete
3099
* @param on_error callback to handle on error
3101
void axis2_stub_start_op_EucalyptusCC_DescribePublicAddresses( axis2_stub_t *stub, const axutil_env_t *env,
3102
adb_DescribePublicAddresses_t* _describePublicAddresses,
3104
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DescribePublicAddressesResponse_t* _describePublicAddressesResponse, void *data) ,
3105
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
3108
axis2_callback_t *callback = NULL;
3110
axis2_svc_client_t *svc_client = NULL;
3111
axis2_options_t *options = NULL;
3113
const axis2_char_t *soap_action = NULL;
3114
axiom_node_t *payload = NULL;
3116
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
3118
axutil_string_t *soap_act = NULL;
3121
struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data *callback_data;
3123
callback_data = (struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data*) AXIS2_MALLOC(env->allocator,
3124
sizeof(struct axis2_stub_EucalyptusCC_DescribePublicAddresses_callback_data));
3125
if(NULL == callback_data)
3127
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
3132
payload = adb_DescribePublicAddresses_serialize(_describePublicAddresses, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
3137
options = axis2_stub_get_options( stub, env);
3138
if (NULL == options)
3140
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
3141
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
3144
svc_client = axis2_stub_get_svc_client (stub, env);
3145
soap_action =axis2_options_get_action (options, env);
3146
if (NULL == soap_action)
3148
is_soap_act_set = AXIS2_FALSE;
3149
soap_action = "EucalyptusCC#DescribePublicAddresses";
3151
soap_act = axutil_string_create(env, "EucalyptusCC#DescribePublicAddresses");
3152
axis2_options_set_soap_action(options, env, soap_act);
3154
axis2_options_set_action( options, env, soap_action);
3157
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
3160
callback = axis2_callback_create(env);
3161
/* Set our on_complete fucntion pointer to the callback object */
3162
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_DescribePublicAddresses);
3163
/* Set our on_error function pointer to the callback object */
3164
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_DescribePublicAddresses);
3166
callback_data-> data = user_data;
3167
callback_data-> on_complete = on_complete;
3168
callback_data-> on_error = on_error;
3170
axis2_callback_set_data(callback, (void*)callback_data);
3173
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
3175
if (!is_soap_act_set)
3178
axis2_options_set_soap_action(options, env, NULL);
3180
axis2_options_set_action(options, env, NULL);
3186
struct axis2_stub_EucalyptusCC_RebootInstances_callback_data
3189
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_RebootInstancesResponse_t* _rebootInstancesResponse, void *data);
3190
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
3193
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_RebootInstances(axis2_callback_t *callback, const axutil_env_t *env, int exception)
3195
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
3196
struct axis2_stub_EucalyptusCC_RebootInstances_callback_data* callback_data = NULL;
3197
void *user_data = NULL;
3199
axis2_status_t status;
3201
callback_data = (struct axis2_stub_EucalyptusCC_RebootInstances_callback_data*)axis2_callback_get_data(callback);
3203
user_data = callback_data->data;
3204
on_error = callback_data->on_error;
3206
status = on_error(env, exception, user_data);
3210
AXIS2_FREE(env->allocator, callback_data);
3215
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_RebootInstances(axis2_callback_t *callback, const axutil_env_t *env)
3217
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_RebootInstancesResponse_t* _rebootInstancesResponse, void *data);
3218
struct axis2_stub_EucalyptusCC_RebootInstances_callback_data* callback_data = NULL;
3219
void *user_data = NULL;
3220
axis2_status_t status = AXIS2_SUCCESS;
3222
adb_RebootInstancesResponse_t* ret_val = NULL;
3225
axiom_node_t *ret_node = NULL;
3226
axiom_soap_envelope_t *soap_envelope = NULL;
3230
callback_data = (struct axis2_stub_EucalyptusCC_RebootInstances_callback_data*)axis2_callback_get_data(callback);
3232
soap_envelope = axis2_callback_get_envelope(callback, env);
3235
axiom_soap_body_t *soap_body;
3236
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
3239
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
3242
ret_node = axiom_node_get_first_child(body_node, env);
3249
user_data = callback_data->data;
3250
on_complete = callback_data->on_complete;
3253
if(ret_node != NULL)
3255
ret_val = adb_RebootInstancesResponse_create(env);
3257
if(adb_RebootInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
3259
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
3260
"This should be due to an invalid XML");
3261
adb_RebootInstancesResponse_free(ret_val, env);
3269
status = on_complete(env, ret_val, user_data);
3274
AXIS2_FREE(env->allocator, callback_data);
3280
* auto generated method signature for asynchronous invocations
3281
* for "RebootInstances|http://eucalyptus.ucsb.edu/" operation.
3284
* @param _rebootInstances
3285
* @param on_complete callback to handle on complete
3286
* @param on_error callback to handle on error
3288
void axis2_stub_start_op_EucalyptusCC_RebootInstances( axis2_stub_t *stub, const axutil_env_t *env,
3289
adb_RebootInstances_t* _rebootInstances,
3291
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_RebootInstancesResponse_t* _rebootInstancesResponse, void *data) ,
3292
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
3295
axis2_callback_t *callback = NULL;
3297
axis2_svc_client_t *svc_client = NULL;
3298
axis2_options_t *options = NULL;
3300
const axis2_char_t *soap_action = NULL;
3301
axiom_node_t *payload = NULL;
3303
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
3305
axutil_string_t *soap_act = NULL;
3308
struct axis2_stub_EucalyptusCC_RebootInstances_callback_data *callback_data;
3310
callback_data = (struct axis2_stub_EucalyptusCC_RebootInstances_callback_data*) AXIS2_MALLOC(env->allocator,
3311
sizeof(struct axis2_stub_EucalyptusCC_RebootInstances_callback_data));
3312
if(NULL == callback_data)
3314
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
3319
payload = adb_RebootInstances_serialize(_rebootInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
3324
options = axis2_stub_get_options( stub, env);
3325
if (NULL == options)
3327
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
3328
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
3331
svc_client = axis2_stub_get_svc_client (stub, env);
3332
soap_action =axis2_options_get_action (options, env);
3333
if (NULL == soap_action)
3335
is_soap_act_set = AXIS2_FALSE;
3336
soap_action = "EucalyptusCC#RebootInstances";
3338
soap_act = axutil_string_create(env, "EucalyptusCC#RebootInstances");
3339
axis2_options_set_soap_action(options, env, soap_act);
3341
axis2_options_set_action( options, env, soap_action);
3344
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
3347
callback = axis2_callback_create(env);
3348
/* Set our on_complete fucntion pointer to the callback object */
3349
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_RebootInstances);
3350
/* Set our on_error function pointer to the callback object */
3351
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_RebootInstances);
3353
callback_data-> data = user_data;
3354
callback_data-> on_complete = on_complete;
3355
callback_data-> on_error = on_error;
3357
axis2_callback_set_data(callback, (void*)callback_data);
3360
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
3362
if (!is_soap_act_set)
3365
axis2_options_set_soap_action(options, env, NULL);
3367
axis2_options_set_action(options, env, NULL);
3373
struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data
3376
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetConsoleOutputResponse_t* _getConsoleOutputResponse, void *data);
3377
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
3380
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_GetConsoleOutput(axis2_callback_t *callback, const axutil_env_t *env, int exception)
3382
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
3383
struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data* callback_data = NULL;
3384
void *user_data = NULL;
3386
axis2_status_t status;
3388
callback_data = (struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data*)axis2_callback_get_data(callback);
3390
user_data = callback_data->data;
3391
on_error = callback_data->on_error;
3393
status = on_error(env, exception, user_data);
3397
AXIS2_FREE(env->allocator, callback_data);
3402
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_GetConsoleOutput(axis2_callback_t *callback, const axutil_env_t *env)
3404
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetConsoleOutputResponse_t* _getConsoleOutputResponse, void *data);
3405
struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data* callback_data = NULL;
3406
void *user_data = NULL;
3407
axis2_status_t status = AXIS2_SUCCESS;
3409
adb_GetConsoleOutputResponse_t* ret_val = NULL;
3412
axiom_node_t *ret_node = NULL;
3413
axiom_soap_envelope_t *soap_envelope = NULL;
3417
callback_data = (struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data*)axis2_callback_get_data(callback);
3419
soap_envelope = axis2_callback_get_envelope(callback, env);
3422
axiom_soap_body_t *soap_body;
3423
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
3426
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
3429
ret_node = axiom_node_get_first_child(body_node, env);
3436
user_data = callback_data->data;
3437
on_complete = callback_data->on_complete;
3440
if(ret_node != NULL)
3442
ret_val = adb_GetConsoleOutputResponse_create(env);
3444
if(adb_GetConsoleOutputResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
3446
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
3447
"This should be due to an invalid XML");
3448
adb_GetConsoleOutputResponse_free(ret_val, env);
3456
status = on_complete(env, ret_val, user_data);
3461
AXIS2_FREE(env->allocator, callback_data);
3467
* auto generated method signature for asynchronous invocations
3468
* for "GetConsoleOutput|http://eucalyptus.ucsb.edu/" operation.
3471
* @param _getConsoleOutput
3472
* @param on_complete callback to handle on complete
3473
* @param on_error callback to handle on error
3475
void axis2_stub_start_op_EucalyptusCC_GetConsoleOutput( axis2_stub_t *stub, const axutil_env_t *env,
3476
adb_GetConsoleOutput_t* _getConsoleOutput,
3478
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetConsoleOutputResponse_t* _getConsoleOutputResponse, void *data) ,
3479
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
3482
axis2_callback_t *callback = NULL;
3484
axis2_svc_client_t *svc_client = NULL;
3485
axis2_options_t *options = NULL;
3487
const axis2_char_t *soap_action = NULL;
3488
axiom_node_t *payload = NULL;
3490
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
3492
axutil_string_t *soap_act = NULL;
3495
struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data *callback_data;
3497
callback_data = (struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data*) AXIS2_MALLOC(env->allocator,
3498
sizeof(struct axis2_stub_EucalyptusCC_GetConsoleOutput_callback_data));
3499
if(NULL == callback_data)
3501
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
3506
payload = adb_GetConsoleOutput_serialize(_getConsoleOutput, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
3511
options = axis2_stub_get_options( stub, env);
3512
if (NULL == options)
3514
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
3515
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
3518
svc_client = axis2_stub_get_svc_client (stub, env);
3519
soap_action =axis2_options_get_action (options, env);
3520
if (NULL == soap_action)
3522
is_soap_act_set = AXIS2_FALSE;
3523
soap_action = "EucalyptusCC#GetConsoleOutput";
3525
soap_act = axutil_string_create(env, "EucalyptusCC#GetConsoleOutput");
3526
axis2_options_set_soap_action(options, env, soap_act);
3528
axis2_options_set_action( options, env, soap_action);
3531
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
3534
callback = axis2_callback_create(env);
3535
/* Set our on_complete fucntion pointer to the callback object */
3536
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_GetConsoleOutput);
3537
/* Set our on_error function pointer to the callback object */
3538
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_GetConsoleOutput);
3540
callback_data-> data = user_data;
3541
callback_data-> on_complete = on_complete;
3542
callback_data-> on_error = on_error;
3544
axis2_callback_set_data(callback, (void*)callback_data);
3547
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
3549
if (!is_soap_act_set)
3552
axis2_options_set_soap_action(options, env, NULL);
3554
axis2_options_set_action(options, env, NULL);
3560
struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data
3563
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_UnassignAddressResponse_t* _unassignAddressResponse, void *data);
3564
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
3567
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_UnassignAddress(axis2_callback_t *callback, const axutil_env_t *env, int exception)
3569
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
3570
struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data* callback_data = NULL;
3571
void *user_data = NULL;
3573
axis2_status_t status;
3575
callback_data = (struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data*)axis2_callback_get_data(callback);
3577
user_data = callback_data->data;
3578
on_error = callback_data->on_error;
3580
status = on_error(env, exception, user_data);
3584
AXIS2_FREE(env->allocator, callback_data);
3589
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_UnassignAddress(axis2_callback_t *callback, const axutil_env_t *env)
3591
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_UnassignAddressResponse_t* _unassignAddressResponse, void *data);
3592
struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data* callback_data = NULL;
3593
void *user_data = NULL;
3594
axis2_status_t status = AXIS2_SUCCESS;
3596
adb_UnassignAddressResponse_t* ret_val = NULL;
3599
axiom_node_t *ret_node = NULL;
3600
axiom_soap_envelope_t *soap_envelope = NULL;
3604
callback_data = (struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data*)axis2_callback_get_data(callback);
3606
soap_envelope = axis2_callback_get_envelope(callback, env);
3609
axiom_soap_body_t *soap_body;
3610
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
3613
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
3616
ret_node = axiom_node_get_first_child(body_node, env);
3623
user_data = callback_data->data;
3624
on_complete = callback_data->on_complete;
3627
if(ret_node != NULL)
3629
ret_val = adb_UnassignAddressResponse_create(env);
3631
if(adb_UnassignAddressResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
3633
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
3634
"This should be due to an invalid XML");
3635
adb_UnassignAddressResponse_free(ret_val, env);
3643
status = on_complete(env, ret_val, user_data);
3648
AXIS2_FREE(env->allocator, callback_data);
3654
* auto generated method signature for asynchronous invocations
3655
* for "UnassignAddress|http://eucalyptus.ucsb.edu/" operation.
3658
* @param _unassignAddress
3659
* @param on_complete callback to handle on complete
3660
* @param on_error callback to handle on error
3662
void axis2_stub_start_op_EucalyptusCC_UnassignAddress( axis2_stub_t *stub, const axutil_env_t *env,
3663
adb_UnassignAddress_t* _unassignAddress,
3665
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_UnassignAddressResponse_t* _unassignAddressResponse, void *data) ,
3666
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
3669
axis2_callback_t *callback = NULL;
3671
axis2_svc_client_t *svc_client = NULL;
3672
axis2_options_t *options = NULL;
3674
const axis2_char_t *soap_action = NULL;
3675
axiom_node_t *payload = NULL;
3677
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
3679
axutil_string_t *soap_act = NULL;
3682
struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data *callback_data;
3684
callback_data = (struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data*) AXIS2_MALLOC(env->allocator,
3685
sizeof(struct axis2_stub_EucalyptusCC_UnassignAddress_callback_data));
3686
if(NULL == callback_data)
3688
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
3693
payload = adb_UnassignAddress_serialize(_unassignAddress, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
3698
options = axis2_stub_get_options( stub, env);
3699
if (NULL == options)
3701
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
3702
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
3705
svc_client = axis2_stub_get_svc_client (stub, env);
3706
soap_action =axis2_options_get_action (options, env);
3707
if (NULL == soap_action)
3709
is_soap_act_set = AXIS2_FALSE;
3710
soap_action = "EucalyptusCC#UnassignAddress";
3712
soap_act = axutil_string_create(env, "EucalyptusCC#UnassignAddress");
3713
axis2_options_set_soap_action(options, env, soap_act);
3715
axis2_options_set_action( options, env, soap_action);
3718
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
3721
callback = axis2_callback_create(env);
3722
/* Set our on_complete fucntion pointer to the callback object */
3723
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_UnassignAddress);
3724
/* Set our on_error function pointer to the callback object */
3725
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_UnassignAddress);
3727
callback_data-> data = user_data;
3728
callback_data-> on_complete = on_complete;
3729
callback_data-> on_error = on_error;
3731
axis2_callback_set_data(callback, (void*)callback_data);
3734
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
3736
if (!is_soap_act_set)
3739
axis2_options_set_soap_action(options, env, NULL);
3741
axis2_options_set_action(options, env, NULL);
3747
struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data
3750
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_TerminateInstancesResponse_t* _terminateInstancesResponse, void *data);
3751
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
3754
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_TerminateInstances(axis2_callback_t *callback, const axutil_env_t *env, int exception)
3756
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
3757
struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data* callback_data = NULL;
3758
void *user_data = NULL;
3760
axis2_status_t status;
3762
callback_data = (struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data*)axis2_callback_get_data(callback);
3764
user_data = callback_data->data;
3765
on_error = callback_data->on_error;
3767
status = on_error(env, exception, user_data);
3771
AXIS2_FREE(env->allocator, callback_data);
3776
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_TerminateInstances(axis2_callback_t *callback, const axutil_env_t *env)
3778
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_TerminateInstancesResponse_t* _terminateInstancesResponse, void *data);
3779
struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data* callback_data = NULL;
3780
void *user_data = NULL;
3781
axis2_status_t status = AXIS2_SUCCESS;
3783
adb_TerminateInstancesResponse_t* ret_val = NULL;
3786
axiom_node_t *ret_node = NULL;
3787
axiom_soap_envelope_t *soap_envelope = NULL;
3791
callback_data = (struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data*)axis2_callback_get_data(callback);
3793
soap_envelope = axis2_callback_get_envelope(callback, env);
3796
axiom_soap_body_t *soap_body;
3797
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
3800
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
3803
ret_node = axiom_node_get_first_child(body_node, env);
3810
user_data = callback_data->data;
3811
on_complete = callback_data->on_complete;
3814
if(ret_node != NULL)
3816
ret_val = adb_TerminateInstancesResponse_create(env);
3818
if(adb_TerminateInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
3820
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
3821
"This should be due to an invalid XML");
3822
adb_TerminateInstancesResponse_free(ret_val, env);
3830
status = on_complete(env, ret_val, user_data);
3835
AXIS2_FREE(env->allocator, callback_data);
3841
* auto generated method signature for asynchronous invocations
3842
* for "TerminateInstances|http://eucalyptus.ucsb.edu/" operation.
3845
* @param _terminateInstances
3846
* @param on_complete callback to handle on complete
3847
* @param on_error callback to handle on error
3849
void axis2_stub_start_op_EucalyptusCC_TerminateInstances( axis2_stub_t *stub, const axutil_env_t *env,
3850
adb_TerminateInstances_t* _terminateInstances,
3852
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_TerminateInstancesResponse_t* _terminateInstancesResponse, void *data) ,
3853
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
3856
axis2_callback_t *callback = NULL;
3858
axis2_svc_client_t *svc_client = NULL;
3859
axis2_options_t *options = NULL;
3861
const axis2_char_t *soap_action = NULL;
3862
axiom_node_t *payload = NULL;
3864
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
3866
axutil_string_t *soap_act = NULL;
3869
struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data *callback_data;
3871
callback_data = (struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data*) AXIS2_MALLOC(env->allocator,
3872
sizeof(struct axis2_stub_EucalyptusCC_TerminateInstances_callback_data));
3873
if(NULL == callback_data)
3875
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
3880
payload = adb_TerminateInstances_serialize(_terminateInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
3885
options = axis2_stub_get_options( stub, env);
3886
if (NULL == options)
3888
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
3889
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
3892
svc_client = axis2_stub_get_svc_client (stub, env);
3893
soap_action =axis2_options_get_action (options, env);
3894
if (NULL == soap_action)
3896
is_soap_act_set = AXIS2_FALSE;
3897
soap_action = "EucalyptusCC#TerminateInstances";
3899
soap_act = axutil_string_create(env, "EucalyptusCC#TerminateInstances");
3900
axis2_options_set_soap_action(options, env, soap_act);
3902
axis2_options_set_action( options, env, soap_action);
3905
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
3908
callback = axis2_callback_create(env);
3909
/* Set our on_complete fucntion pointer to the callback object */
3910
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_TerminateInstances);
3911
/* Set our on_error function pointer to the callback object */
3912
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_TerminateInstances);
3914
callback_data-> data = user_data;
3915
callback_data-> on_complete = on_complete;
3916
callback_data-> on_error = on_error;
3918
axis2_callback_set_data(callback, (void*)callback_data);
3921
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
3923
if (!is_soap_act_set)
3926
axis2_options_set_soap_action(options, env, NULL);
3928
axis2_options_set_action(options, env, NULL);
3934
struct axis2_stub_EucalyptusCC_DetachVolume_callback_data
3937
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DetachVolumeResponse_t* _detachVolumeResponse, void *data);
3938
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
3941
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_DetachVolume(axis2_callback_t *callback, const axutil_env_t *env, int exception)
3943
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
3944
struct axis2_stub_EucalyptusCC_DetachVolume_callback_data* callback_data = NULL;
3945
void *user_data = NULL;
3947
axis2_status_t status;
3949
callback_data = (struct axis2_stub_EucalyptusCC_DetachVolume_callback_data*)axis2_callback_get_data(callback);
3951
user_data = callback_data->data;
3952
on_error = callback_data->on_error;
3954
status = on_error(env, exception, user_data);
3958
AXIS2_FREE(env->allocator, callback_data);
3963
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_DetachVolume(axis2_callback_t *callback, const axutil_env_t *env)
3965
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DetachVolumeResponse_t* _detachVolumeResponse, void *data);
3966
struct axis2_stub_EucalyptusCC_DetachVolume_callback_data* callback_data = NULL;
3967
void *user_data = NULL;
3968
axis2_status_t status = AXIS2_SUCCESS;
3970
adb_DetachVolumeResponse_t* ret_val = NULL;
3973
axiom_node_t *ret_node = NULL;
3974
axiom_soap_envelope_t *soap_envelope = NULL;
3978
callback_data = (struct axis2_stub_EucalyptusCC_DetachVolume_callback_data*)axis2_callback_get_data(callback);
3980
soap_envelope = axis2_callback_get_envelope(callback, env);
3983
axiom_soap_body_t *soap_body;
3984
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
3987
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
3990
ret_node = axiom_node_get_first_child(body_node, env);
3997
user_data = callback_data->data;
3998
on_complete = callback_data->on_complete;
4001
if(ret_node != NULL)
4003
ret_val = adb_DetachVolumeResponse_create(env);
4005
if(adb_DetachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
4007
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
4008
"This should be due to an invalid XML");
4009
adb_DetachVolumeResponse_free(ret_val, env);
4017
status = on_complete(env, ret_val, user_data);
4022
AXIS2_FREE(env->allocator, callback_data);
4028
* auto generated method signature for asynchronous invocations
4029
* for "DetachVolume|http://eucalyptus.ucsb.edu/" operation.
4032
* @param _detachVolume
4033
* @param on_complete callback to handle on complete
4034
* @param on_error callback to handle on error
4036
void axis2_stub_start_op_EucalyptusCC_DetachVolume( axis2_stub_t *stub, const axutil_env_t *env,
4037
adb_DetachVolume_t* _detachVolume,
4039
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_DetachVolumeResponse_t* _detachVolumeResponse, void *data) ,
4040
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
4043
axis2_callback_t *callback = NULL;
4045
axis2_svc_client_t *svc_client = NULL;
4046
axis2_options_t *options = NULL;
4048
const axis2_char_t *soap_action = NULL;
4049
axiom_node_t *payload = NULL;
4051
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
4053
axutil_string_t *soap_act = NULL;
4056
struct axis2_stub_EucalyptusCC_DetachVolume_callback_data *callback_data;
4058
callback_data = (struct axis2_stub_EucalyptusCC_DetachVolume_callback_data*) AXIS2_MALLOC(env->allocator,
4059
sizeof(struct axis2_stub_EucalyptusCC_DetachVolume_callback_data));
4060
if(NULL == callback_data)
4062
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
4067
payload = adb_DetachVolume_serialize(_detachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
4072
options = axis2_stub_get_options( stub, env);
4073
if (NULL == options)
4075
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
4076
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
4079
svc_client = axis2_stub_get_svc_client (stub, env);
4080
soap_action =axis2_options_get_action (options, env);
4081
if (NULL == soap_action)
4083
is_soap_act_set = AXIS2_FALSE;
4084
soap_action = "EucalyptusCC#DetachVolume";
4086
soap_act = axutil_string_create(env, "EucalyptusCC#DetachVolume");
4087
axis2_options_set_soap_action(options, env, soap_act);
4089
axis2_options_set_action( options, env, soap_action);
4092
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
4095
callback = axis2_callback_create(env);
4096
/* Set our on_complete fucntion pointer to the callback object */
4097
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_DetachVolume);
4098
/* Set our on_error function pointer to the callback object */
4099
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_DetachVolume);
4101
callback_data-> data = user_data;
4102
callback_data-> on_complete = on_complete;
4103
callback_data-> on_error = on_error;
4105
axis2_callback_set_data(callback, (void*)callback_data);
4108
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
4110
if (!is_soap_act_set)
4113
axis2_options_set_soap_action(options, env, NULL);
4115
axis2_options_set_action(options, env, NULL);
4121
struct axis2_stub_EucalyptusCC_AttachVolume_callback_data
4124
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_AttachVolumeResponse_t* _attachVolumeResponse, void *data);
4125
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
4128
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_AttachVolume(axis2_callback_t *callback, const axutil_env_t *env, int exception)
4130
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
4131
struct axis2_stub_EucalyptusCC_AttachVolume_callback_data* callback_data = NULL;
4132
void *user_data = NULL;
4134
axis2_status_t status;
4136
callback_data = (struct axis2_stub_EucalyptusCC_AttachVolume_callback_data*)axis2_callback_get_data(callback);
4138
user_data = callback_data->data;
4139
on_error = callback_data->on_error;
4141
status = on_error(env, exception, user_data);
4145
AXIS2_FREE(env->allocator, callback_data);
4150
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_AttachVolume(axis2_callback_t *callback, const axutil_env_t *env)
4152
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_AttachVolumeResponse_t* _attachVolumeResponse, void *data);
4153
struct axis2_stub_EucalyptusCC_AttachVolume_callback_data* callback_data = NULL;
4154
void *user_data = NULL;
4155
axis2_status_t status = AXIS2_SUCCESS;
4157
adb_AttachVolumeResponse_t* ret_val = NULL;
4160
axiom_node_t *ret_node = NULL;
4161
axiom_soap_envelope_t *soap_envelope = NULL;
4165
callback_data = (struct axis2_stub_EucalyptusCC_AttachVolume_callback_data*)axis2_callback_get_data(callback);
4167
soap_envelope = axis2_callback_get_envelope(callback, env);
4170
axiom_soap_body_t *soap_body;
4171
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
4174
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
4177
ret_node = axiom_node_get_first_child(body_node, env);
4184
user_data = callback_data->data;
4185
on_complete = callback_data->on_complete;
4188
if(ret_node != NULL)
4190
ret_val = adb_AttachVolumeResponse_create(env);
4192
if(adb_AttachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
4194
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
4195
"This should be due to an invalid XML");
4196
adb_AttachVolumeResponse_free(ret_val, env);
4204
status = on_complete(env, ret_val, user_data);
4209
AXIS2_FREE(env->allocator, callback_data);
4215
* auto generated method signature for asynchronous invocations
4216
* for "AttachVolume|http://eucalyptus.ucsb.edu/" operation.
4219
* @param _attachVolume
4220
* @param on_complete callback to handle on complete
4221
* @param on_error callback to handle on error
4223
void axis2_stub_start_op_EucalyptusCC_AttachVolume( axis2_stub_t *stub, const axutil_env_t *env,
4224
adb_AttachVolume_t* _attachVolume,
4226
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_AttachVolumeResponse_t* _attachVolumeResponse, void *data) ,
4227
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
4230
axis2_callback_t *callback = NULL;
4232
axis2_svc_client_t *svc_client = NULL;
4233
axis2_options_t *options = NULL;
4235
const axis2_char_t *soap_action = NULL;
4236
axiom_node_t *payload = NULL;
4238
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
4240
axutil_string_t *soap_act = NULL;
4243
struct axis2_stub_EucalyptusCC_AttachVolume_callback_data *callback_data;
4245
callback_data = (struct axis2_stub_EucalyptusCC_AttachVolume_callback_data*) AXIS2_MALLOC(env->allocator,
4246
sizeof(struct axis2_stub_EucalyptusCC_AttachVolume_callback_data));
4247
if(NULL == callback_data)
4249
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
4254
payload = adb_AttachVolume_serialize(_attachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
4259
options = axis2_stub_get_options( stub, env);
4260
if (NULL == options)
4262
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
4263
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
4266
svc_client = axis2_stub_get_svc_client (stub, env);
4267
soap_action =axis2_options_get_action (options, env);
4268
if (NULL == soap_action)
4270
is_soap_act_set = AXIS2_FALSE;
4271
soap_action = "EucalyptusCC#AttachVolume";
4273
soap_act = axutil_string_create(env, "EucalyptusCC#AttachVolume");
4274
axis2_options_set_soap_action(options, env, soap_act);
4276
axis2_options_set_action( options, env, soap_action);
4279
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
4282
callback = axis2_callback_create(env);
4283
/* Set our on_complete fucntion pointer to the callback object */
4284
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_AttachVolume);
4285
/* Set our on_error function pointer to the callback object */
4286
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_AttachVolume);
4288
callback_data-> data = user_data;
4289
callback_data-> on_complete = on_complete;
4290
callback_data-> on_error = on_error;
4292
axis2_callback_set_data(callback, (void*)callback_data);
4295
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
4297
if (!is_soap_act_set)
4300
axis2_options_set_soap_action(options, env, NULL);
4302
axis2_options_set_action(options, env, NULL);
4308
struct axis2_stub_EucalyptusCC_RunInstances_callback_data
4311
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_RunInstancesResponse_t* _runInstancesResponse, void *data);
4312
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
4315
static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusCC_RunInstances(axis2_callback_t *callback, const axutil_env_t *env, int exception)
4317
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
4318
struct axis2_stub_EucalyptusCC_RunInstances_callback_data* callback_data = NULL;
4319
void *user_data = NULL;
4321
axis2_status_t status;
4323
callback_data = (struct axis2_stub_EucalyptusCC_RunInstances_callback_data*)axis2_callback_get_data(callback);
4325
user_data = callback_data->data;
4326
on_error = callback_data->on_error;
4328
status = on_error(env, exception, user_data);
4332
AXIS2_FREE(env->allocator, callback_data);
4337
axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusCC_RunInstances(axis2_callback_t *callback, const axutil_env_t *env)
4339
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_RunInstancesResponse_t* _runInstancesResponse, void *data);
4340
struct axis2_stub_EucalyptusCC_RunInstances_callback_data* callback_data = NULL;
4341
void *user_data = NULL;
4342
axis2_status_t status = AXIS2_SUCCESS;
4344
adb_RunInstancesResponse_t* ret_val = NULL;
4347
axiom_node_t *ret_node = NULL;
4348
axiom_soap_envelope_t *soap_envelope = NULL;
4352
callback_data = (struct axis2_stub_EucalyptusCC_RunInstances_callback_data*)axis2_callback_get_data(callback);
4354
soap_envelope = axis2_callback_get_envelope(callback, env);
4357
axiom_soap_body_t *soap_body;
4358
soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
4361
axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
4364
ret_node = axiom_node_get_first_child(body_node, env);
4371
user_data = callback_data->data;
4372
on_complete = callback_data->on_complete;
4375
if(ret_node != NULL)
4377
ret_val = adb_RunInstancesResponse_create(env);
4379
if(adb_RunInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
4381
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
4382
"This should be due to an invalid XML");
4383
adb_RunInstancesResponse_free(ret_val, env);
4391
status = on_complete(env, ret_val, user_data);
4396
AXIS2_FREE(env->allocator, callback_data);
4402
* auto generated method signature for asynchronous invocations
4403
* for "RunInstances|http://eucalyptus.ucsb.edu/" operation.
4406
* @param _runInstances
4407
* @param on_complete callback to handle on complete
4408
* @param on_error callback to handle on error
4410
void axis2_stub_start_op_EucalyptusCC_RunInstances( axis2_stub_t *stub, const axutil_env_t *env,
4411
adb_RunInstances_t* _runInstances,
4413
axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_RunInstancesResponse_t* _runInstancesResponse, void *data) ,
4414
axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
4417
axis2_callback_t *callback = NULL;
4419
axis2_svc_client_t *svc_client = NULL;
4420
axis2_options_t *options = NULL;
4422
const axis2_char_t *soap_action = NULL;
4423
axiom_node_t *payload = NULL;
4425
axis2_bool_t is_soap_act_set = AXIS2_TRUE;
4427
axutil_string_t *soap_act = NULL;
4430
struct axis2_stub_EucalyptusCC_RunInstances_callback_data *callback_data;
4432
callback_data = (struct axis2_stub_EucalyptusCC_RunInstances_callback_data*) AXIS2_MALLOC(env->allocator,
4433
sizeof(struct axis2_stub_EucalyptusCC_RunInstances_callback_data));
4434
if(NULL == callback_data)
4436
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
4441
payload = adb_RunInstances_serialize(_runInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
4446
options = axis2_stub_get_options( stub, env);
4447
if (NULL == options)
4449
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
4450
AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
4453
svc_client = axis2_stub_get_svc_client (stub, env);
4454
soap_action =axis2_options_get_action (options, env);
4455
if (NULL == soap_action)
4457
is_soap_act_set = AXIS2_FALSE;
4458
soap_action = "EucalyptusCC#RunInstances";
4460
soap_act = axutil_string_create(env, "EucalyptusCC#RunInstances");
4461
axis2_options_set_soap_action(options, env, soap_act);
4463
axis2_options_set_action( options, env, soap_action);
4466
axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
4469
callback = axis2_callback_create(env);
4470
/* Set our on_complete fucntion pointer to the callback object */
4471
axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusCC_RunInstances);
4472
/* Set our on_error function pointer to the callback object */
4473
axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusCC_RunInstances);
4475
callback_data-> data = user_data;
4476
callback_data-> on_complete = on_complete;
4477
callback_data-> on_error = on_error;
4479
axis2_callback_set_data(callback, (void*)callback_data);
4482
axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
4484
if (!is_soap_act_set)
4487
axis2_options_set_soap_action(options, env, NULL);
4489
axis2_options_set_action(options, env, NULL);
4497
* function to free any soap input headers
4503
* function to free any soap output headers
added
removed
cluster/generated/axis2_stub_EucalyptusCC.c
