← Back to branch summary

~ubuntu-core-dev/ubuntu/maverick/eucalyptus/devel

« back to all changes in this revision

Viewing changes to cluster/generated/axis2_stub_EucalyptusNC.c

  • Committer: Dustin Kirkland
  • Date: 2010-07-22 08:41:57 UTC
  • mfrom: (1050.1.19 ubuntu)
  • Revision ID: kirkland@x200-20100722084157-zh2p8dkawznvxxpn
Approving Dave Walker's merge of new upstream Eucalyptus 2.0 release.

Dustin Kirkland <kirkland@canonical.com>

* New major upstream version merge, 2.0 (r1211).
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 21-eucalyptus-1.7-with-gwt-1.6.4.patch: New patch, allows 
    eucalyptus-1.7 to be built against gwt 1.6.4. Based on patch courtesy 
    of Dmitrii Zagorodnov, upstream. (LP: #597330)
* debian/eucalyptus-java-common.links: 
  - Changed symlink for groovy, point to groovy.all.jar, making compatiable 
    with groovy versions >1.7. (LP: #595421)
  - Added ant.jar & jetty-rewrite-handler.jar as they are now required.
* debian/control
  - & debian/build-jars: Added libjavassist-java and libjetty-extra-java as 
    build dependencies.
  - Added libjetty-extra-java as a dependency of eucalyptus-java-common
* The binary resulting jar's have been renamed from eucalyptus-*-1.6.2.jar
  to eucalyptus-*-main.jar:    
  - debian/eucalyptus-cc.upstart
  - debian/eucalyptus-cloud.install
  - debian/eucalyptus-common.eucalyptus.upstart
  - debian/eucalyptus-java-common.install
  - debian/eucalyptus-network.upstart
  - debian/eucalyptus-sc.install
  - debian/eucalyptus-walrus.install
* debian/eucalyptus-java-common.install: New upstream jars that have been
  installed:
  - eucalyptus-db-hsqldb-ext-main.jar
  - eucalyptus-component-main.jar
* debian/control:
  - Updated Standards Version to 3.8.4 (no change)
  - Updated the upstream Homepage to: http://open.eucalyptus.com/
  - Changed Vcs-Bzr to reflect new location of Ubuntu hosted development branch.
  - Made the Build Dependency of groovy and the binary eucalyptus-java-common
    package depend on version >=1.7.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cluster/generated/axis2_stub_EucalyptusNC.c
 
1
 
 
2
 
 
3
      /**
 
4
       * axis2_stub_EucalyptusNC.c
 
5
       *
 
6
       * This file was auto-generated from WSDL for "EucalyptusNC|http://eucalyptus.ucsb.edu/" service
 
7
       * by the Apache Axis2/Java version: 1.4  Built on : Apr 26, 2008 (06:24:30 EDT)
 
8
       */
 
9
 
 
10
      #include "axis2_stub_EucalyptusNC.h"
 
11
      #include <axis2_msg.h>
 
12
 
 
13
      /**
 
14
       * axis2_stub_EucalyptusNC C implementation
 
15
       */
 
16
 
 
17
      axis2_stub_t*
 
18
      axis2_stub_create_EucalyptusNC(const axutil_env_t *env,
 
19
                                      axis2_char_t *client_home,
 
20
                                      axis2_char_t *endpoint_uri)
 
21
      {
 
22
         axis2_stub_t *stub = NULL;
 
23
         axis2_endpoint_ref_t *endpoint_ref = NULL;
 
24
         AXIS2_FUNC_PARAM_CHECK (client_home, env, NULL)
 
25
 
 
26
         if (NULL == endpoint_uri)
 
27
         {
 
28
            endpoint_uri = axis2_stub_get_endpoint_uri_of_EucalyptusNC(env);
 
29
         }
 
30
 
 
31
         endpoint_ref = axis2_endpoint_ref_create(env, endpoint_uri);
 
32
 
 
33
         stub = axis2_stub_create_with_endpoint_ref_and_client_home (env, endpoint_ref, client_home);
 
34
 
 
35
         if (NULL == stub)
 
36
         {
 
37
            if(NULL != endpoint_ref)
 
38
            {
 
39
                axis2_endpoint_ref_free(endpoint_ref, env);
 
40
            }
 
41
            return NULL;
 
42
         }
 
43
 
 
44
 
 
45
         axis2_stub_populate_services_for_EucalyptusNC(stub, env);
 
46
         return stub;
 
47
      }
 
48
 
 
49
 
 
50
      void
 
51
      axis2_stub_populate_services_for_EucalyptusNC(axis2_stub_t *stub, const axutil_env_t *env)
 
52
      {
 
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;
 
63
 
 
64
 
 
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 );
 
68
 
 
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);
 
74
 
 
75
         svc_qname = axutil_qname_create(env,"EucalyptusNC" ,NULL, NULL);
 
76
         axis2_svc_set_qname (svc, env, svc_qname);
 
77
 
 
78
         /* creating the operations*/
 
79
 
 
80
         
 
81
           op_qname = axutil_qname_create(env,
 
82
                                         "ncRunInstance" ,
 
83
                                         "http://eucalyptus.ucsb.edu/",
 
84
                                         NULL);
 
85
           op = axis2_op_create_with_qname(env, op_qname);
 
86
           
 
87
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
88
             
 
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);
 
97
           
 
98
           axis2_svc_add_op(svc, env, op);
 
99
 
 
100
         
 
101
           op_qname = axutil_qname_create(env,
 
102
                                         "ncRebootInstance" ,
 
103
                                         "http://eucalyptus.ucsb.edu/",
 
104
                                         NULL);
 
105
           op = axis2_op_create_with_qname(env, op_qname);
 
106
           
 
107
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
108
             
 
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);
 
117
           
 
118
           axis2_svc_add_op(svc, env, op);
 
119
 
 
120
         
 
121
           op_qname = axutil_qname_create(env,
 
122
                                         "ncGetConsoleOutput" ,
 
123
                                         "http://eucalyptus.ucsb.edu/",
 
124
                                         NULL);
 
125
           op = axis2_op_create_with_qname(env, op_qname);
 
126
           
 
127
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
128
             
 
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);
 
137
           
 
138
           axis2_svc_add_op(svc, env, op);
 
139
 
 
140
         
 
141
           op_qname = axutil_qname_create(env,
 
142
                                         "ncDetachVolume" ,
 
143
                                         "http://eucalyptus.ucsb.edu/",
 
144
                                         NULL);
 
145
           op = axis2_op_create_with_qname(env, op_qname);
 
146
           
 
147
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
148
             
 
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);
 
157
           
 
158
           axis2_svc_add_op(svc, env, op);
 
159
 
 
160
         
 
161
           op_qname = axutil_qname_create(env,
 
162
                                         "ncDescribeInstances" ,
 
163
                                         "http://eucalyptus.ucsb.edu/",
 
164
                                         NULL);
 
165
           op = axis2_op_create_with_qname(env, op_qname);
 
166
           
 
167
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
168
             
 
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);
 
177
           
 
178
           axis2_svc_add_op(svc, env, op);
 
179
 
 
180
         
 
181
           op_qname = axutil_qname_create(env,
 
182
                                         "ncAttachVolume" ,
 
183
                                         "http://eucalyptus.ucsb.edu/",
 
184
                                         NULL);
 
185
           op = axis2_op_create_with_qname(env, op_qname);
 
186
           
 
187
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
188
             
 
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);
 
197
           
 
198
           axis2_svc_add_op(svc, env, op);
 
199
 
 
200
         
 
201
           op_qname = axutil_qname_create(env,
 
202
                                         "ncPowerDown" ,
 
203
                                         "http://eucalyptus.ucsb.edu/",
 
204
                                         NULL);
 
205
           op = axis2_op_create_with_qname(env, op_qname);
 
206
           
 
207
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
208
             
 
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);
 
217
           
 
218
           axis2_svc_add_op(svc, env, op);
 
219
 
 
220
         
 
221
           op_qname = axutil_qname_create(env,
 
222
                                         "ncDescribeResource" ,
 
223
                                         "http://eucalyptus.ucsb.edu/",
 
224
                                         NULL);
 
225
           op = axis2_op_create_with_qname(env, op_qname);
 
226
           
 
227
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
228
             
 
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);
 
237
           
 
238
           axis2_svc_add_op(svc, env, op);
 
239
 
 
240
         
 
241
           op_qname = axutil_qname_create(env,
 
242
                                         "ncTerminateInstance" ,
 
243
                                         "http://eucalyptus.ucsb.edu/",
 
244
                                         NULL);
 
245
           op = axis2_op_create_with_qname(env, op_qname);
 
246
           
 
247
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
248
             
 
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);
 
257
           
 
258
           axis2_svc_add_op(svc, env, op);
 
259
 
 
260
         
 
261
           op_qname = axutil_qname_create(env,
 
262
                                         "ncStartNetwork" ,
 
263
                                         "http://eucalyptus.ucsb.edu/",
 
264
                                         NULL);
 
265
           op = axis2_op_create_with_qname(env, op_qname);
 
266
           
 
267
               axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
 
268
             
 
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);
 
277
           
 
278
           axis2_svc_add_op(svc, env, op);
 
279
 
 
280
         
 
281
      }
 
282
 
 
283
      /**
 
284
       *return end point picked from wsdl
 
285
       */
 
286
      axis2_char_t*
 
287
      axis2_stub_get_endpoint_uri_of_EucalyptusNC( const axutil_env_t *env )
 
288
      {
 
289
        axis2_char_t *endpoint_uri = NULL;
 
290
        /* set the address from here */
 
291
        
 
292
              endpoint_uri = "http://spinner.cs.ucsb.edu:9090/axis2/services/EucalyptusNC";
 
293
            
 
294
        return endpoint_uri;
 
295
      }
 
296
 
 
297
 
 
298
  
 
299
         /**
 
300
          * auto generated method signature
 
301
          * for "ncRunInstance|http://eucalyptus.ucsb.edu/" operation.
 
302
          *
 
303
          * @param _ncRunInstance
 
304
          *
 
305
          * @return adb_ncRunInstanceResponse_t*
 
306
          */
 
307
         adb_ncRunInstanceResponse_t* 
 
308
         axis2_stub_op_EucalyptusNC_ncRunInstance( axis2_stub_t *stub, const axutil_env_t *env,
 
309
                                              adb_ncRunInstance_t* _ncRunInstance)
 
310
         {
 
311
            axis2_svc_client_t *svc_client = NULL;
 
312
            axis2_options_t *options = NULL;
 
313
            axiom_node_t *ret_node = NULL;
 
314
 
 
315
            const axis2_char_t *soap_action = NULL;
 
316
            axutil_qname_t *op_qname =  NULL;
 
317
            axiom_node_t *payload = NULL;
 
318
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
319
            
 
320
            axutil_string_t *soap_act = NULL;
 
321
            adb_ncRunInstanceResponse_t* ret_val = NULL;
 
322
            
 
323
                       payload = adb_ncRunInstance_serialize(_ncRunInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
324
                   
 
325
            svc_client = axis2_stub_get_svc_client(stub, env );
 
326
            
 
327
           
 
328
            
 
329
            
 
330
 
 
331
            options = axis2_stub_get_options( stub, env);
 
332
            if (NULL == options)
 
333
            {
 
334
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
335
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
336
                return NULL;
 
337
            }
 
338
            soap_action = axis2_options_get_action( options, env );
 
339
            if (NULL == soap_action)
 
340
            {
 
341
              is_soap_act_set = AXIS2_FALSE;
 
342
              soap_action = "EucalyptusNC#ncRunInstance";
 
343
              
 
344
              soap_act = axutil_string_create(env, "EucalyptusNC#ncRunInstance");
 
345
              axis2_options_set_soap_action(options, env, soap_act);    
 
346
              
 
347
              axis2_options_set_action( options, env, soap_action );
 
348
            }
 
349
            
 
350
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
351
            
 
352
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
353
 
 
354
            if (!is_soap_act_set)
 
355
            {
 
356
              
 
357
              axis2_options_set_soap_action(options, env, NULL);    
 
358
              
 
359
              axis2_options_set_action( options, env, NULL);
 
360
            }
 
361
 
 
362
            
 
363
            
 
364
                    if ( NULL == ret_node )
 
365
                    {
 
366
                        return NULL;
 
367
                    }
 
368
                    ret_val = adb_ncRunInstanceResponse_create(env);
 
369
 
 
370
                    if(adb_ncRunInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
371
                    {
 
372
                        if(ret_val != NULL)
 
373
                        {
 
374
                            adb_ncRunInstanceResponse_free(ret_val, env);
 
375
                        }
 
376
 
 
377
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncRunInstanceResponse_deserialize: "
 
378
                                                                "This should be due to an invalid XML");
 
379
                        return NULL;
 
380
                    }
 
381
                    return ret_val;
 
382
                
 
383
        }
 
384
        
 
385
         /**
 
386
          * auto generated method signature
 
387
          * for "ncRebootInstance|http://eucalyptus.ucsb.edu/" operation.
 
388
          *
 
389
          * @param _ncRebootInstance
 
390
          *
 
391
          * @return adb_ncRebootInstanceResponse_t*
 
392
          */
 
393
         adb_ncRebootInstanceResponse_t* 
 
394
         axis2_stub_op_EucalyptusNC_ncRebootInstance( axis2_stub_t *stub, const axutil_env_t *env,
 
395
                                              adb_ncRebootInstance_t* _ncRebootInstance)
 
396
         {
 
397
            axis2_svc_client_t *svc_client = NULL;
 
398
            axis2_options_t *options = NULL;
 
399
            axiom_node_t *ret_node = NULL;
 
400
 
 
401
            const axis2_char_t *soap_action = NULL;
 
402
            axutil_qname_t *op_qname =  NULL;
 
403
            axiom_node_t *payload = NULL;
 
404
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
405
            
 
406
            axutil_string_t *soap_act = NULL;
 
407
            adb_ncRebootInstanceResponse_t* ret_val = NULL;
 
408
            
 
409
                       payload = adb_ncRebootInstance_serialize(_ncRebootInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
410
                   
 
411
            svc_client = axis2_stub_get_svc_client(stub, env );
 
412
            
 
413
           
 
414
            
 
415
            
 
416
 
 
417
            options = axis2_stub_get_options( stub, env);
 
418
            if (NULL == options)
 
419
            {
 
420
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
421
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
422
                return NULL;
 
423
            }
 
424
            soap_action = axis2_options_get_action( options, env );
 
425
            if (NULL == soap_action)
 
426
            {
 
427
              is_soap_act_set = AXIS2_FALSE;
 
428
              soap_action = "EucalyptusNC#ncRebootInstance";
 
429
              
 
430
              soap_act = axutil_string_create(env, "EucalyptusNC#ncRebootInstance");
 
431
              axis2_options_set_soap_action(options, env, soap_act);    
 
432
              
 
433
              axis2_options_set_action( options, env, soap_action );
 
434
            }
 
435
            
 
436
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
437
            
 
438
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
439
 
 
440
            if (!is_soap_act_set)
 
441
            {
 
442
              
 
443
              axis2_options_set_soap_action(options, env, NULL);    
 
444
              
 
445
              axis2_options_set_action( options, env, NULL);
 
446
            }
 
447
 
 
448
            
 
449
            
 
450
                    if ( NULL == ret_node )
 
451
                    {
 
452
                        return NULL;
 
453
                    }
 
454
                    ret_val = adb_ncRebootInstanceResponse_create(env);
 
455
 
 
456
                    if(adb_ncRebootInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
457
                    {
 
458
                        if(ret_val != NULL)
 
459
                        {
 
460
                            adb_ncRebootInstanceResponse_free(ret_val, env);
 
461
                        }
 
462
 
 
463
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncRebootInstanceResponse_deserialize: "
 
464
                                                                "This should be due to an invalid XML");
 
465
                        return NULL;
 
466
                    }
 
467
                    return ret_val;
 
468
                
 
469
        }
 
470
        
 
471
         /**
 
472
          * auto generated method signature
 
473
          * for "ncGetConsoleOutput|http://eucalyptus.ucsb.edu/" operation.
 
474
          *
 
475
          * @param _ncGetConsoleOutput
 
476
          *
 
477
          * @return adb_ncGetConsoleOutputResponse_t*
 
478
          */
 
479
         adb_ncGetConsoleOutputResponse_t* 
 
480
         axis2_stub_op_EucalyptusNC_ncGetConsoleOutput( axis2_stub_t *stub, const axutil_env_t *env,
 
481
                                              adb_ncGetConsoleOutput_t* _ncGetConsoleOutput)
 
482
         {
 
483
            axis2_svc_client_t *svc_client = NULL;
 
484
            axis2_options_t *options = NULL;
 
485
            axiom_node_t *ret_node = NULL;
 
486
 
 
487
            const axis2_char_t *soap_action = NULL;
 
488
            axutil_qname_t *op_qname =  NULL;
 
489
            axiom_node_t *payload = NULL;
 
490
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
491
            
 
492
            axutil_string_t *soap_act = NULL;
 
493
            adb_ncGetConsoleOutputResponse_t* ret_val = NULL;
 
494
            
 
495
                       payload = adb_ncGetConsoleOutput_serialize(_ncGetConsoleOutput, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
496
                   
 
497
            svc_client = axis2_stub_get_svc_client(stub, env );
 
498
            
 
499
           
 
500
            
 
501
            
 
502
 
 
503
            options = axis2_stub_get_options( stub, env);
 
504
            if (NULL == options)
 
505
            {
 
506
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
507
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
508
                return NULL;
 
509
            }
 
510
            soap_action = axis2_options_get_action( options, env );
 
511
            if (NULL == soap_action)
 
512
            {
 
513
              is_soap_act_set = AXIS2_FALSE;
 
514
              soap_action = "EucalyptusNC#ncGetConsoleOutput";
 
515
              
 
516
              soap_act = axutil_string_create(env, "EucalyptusNC#ncGetConsoleOutput");
 
517
              axis2_options_set_soap_action(options, env, soap_act);    
 
518
              
 
519
              axis2_options_set_action( options, env, soap_action );
 
520
            }
 
521
            
 
522
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
523
            
 
524
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
525
 
 
526
            if (!is_soap_act_set)
 
527
            {
 
528
              
 
529
              axis2_options_set_soap_action(options, env, NULL);    
 
530
              
 
531
              axis2_options_set_action( options, env, NULL);
 
532
            }
 
533
 
 
534
            
 
535
            
 
536
                    if ( NULL == ret_node )
 
537
                    {
 
538
                        return NULL;
 
539
                    }
 
540
                    ret_val = adb_ncGetConsoleOutputResponse_create(env);
 
541
 
 
542
                    if(adb_ncGetConsoleOutputResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
543
                    {
 
544
                        if(ret_val != NULL)
 
545
                        {
 
546
                            adb_ncGetConsoleOutputResponse_free(ret_val, env);
 
547
                        }
 
548
 
 
549
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncGetConsoleOutputResponse_deserialize: "
 
550
                                                                "This should be due to an invalid XML");
 
551
                        return NULL;
 
552
                    }
 
553
                    return ret_val;
 
554
                
 
555
        }
 
556
        
 
557
         /**
 
558
          * auto generated method signature
 
559
          * for "ncDetachVolume|http://eucalyptus.ucsb.edu/" operation.
 
560
          *
 
561
          * @param _ncDetachVolume
 
562
          *
 
563
          * @return adb_ncDetachVolumeResponse_t*
 
564
          */
 
565
         adb_ncDetachVolumeResponse_t* 
 
566
         axis2_stub_op_EucalyptusNC_ncDetachVolume( axis2_stub_t *stub, const axutil_env_t *env,
 
567
                                              adb_ncDetachVolume_t* _ncDetachVolume)
 
568
         {
 
569
            axis2_svc_client_t *svc_client = NULL;
 
570
            axis2_options_t *options = NULL;
 
571
            axiom_node_t *ret_node = NULL;
 
572
 
 
573
            const axis2_char_t *soap_action = NULL;
 
574
            axutil_qname_t *op_qname =  NULL;
 
575
            axiom_node_t *payload = NULL;
 
576
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
577
            
 
578
            axutil_string_t *soap_act = NULL;
 
579
            adb_ncDetachVolumeResponse_t* ret_val = NULL;
 
580
            
 
581
                       payload = adb_ncDetachVolume_serialize(_ncDetachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
582
                   
 
583
            svc_client = axis2_stub_get_svc_client(stub, env );
 
584
            
 
585
           
 
586
            
 
587
            
 
588
 
 
589
            options = axis2_stub_get_options( stub, env);
 
590
            if (NULL == options)
 
591
            {
 
592
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
593
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
594
                return NULL;
 
595
            }
 
596
            soap_action = axis2_options_get_action( options, env );
 
597
            if (NULL == soap_action)
 
598
            {
 
599
              is_soap_act_set = AXIS2_FALSE;
 
600
              soap_action = "EucalyptusNC#ncDetachVolume";
 
601
              
 
602
              soap_act = axutil_string_create(env, "EucalyptusNC#ncDetachVolume");
 
603
              axis2_options_set_soap_action(options, env, soap_act);    
 
604
              
 
605
              axis2_options_set_action( options, env, soap_action );
 
606
            }
 
607
            
 
608
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
609
            
 
610
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
611
 
 
612
            if (!is_soap_act_set)
 
613
            {
 
614
              
 
615
              axis2_options_set_soap_action(options, env, NULL);    
 
616
              
 
617
              axis2_options_set_action( options, env, NULL);
 
618
            }
 
619
 
 
620
            
 
621
            
 
622
                    if ( NULL == ret_node )
 
623
                    {
 
624
                        return NULL;
 
625
                    }
 
626
                    ret_val = adb_ncDetachVolumeResponse_create(env);
 
627
 
 
628
                    if(adb_ncDetachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
629
                    {
 
630
                        if(ret_val != NULL)
 
631
                        {
 
632
                            adb_ncDetachVolumeResponse_free(ret_val, env);
 
633
                        }
 
634
 
 
635
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDetachVolumeResponse_deserialize: "
 
636
                                                                "This should be due to an invalid XML");
 
637
                        return NULL;
 
638
                    }
 
639
                    return ret_val;
 
640
                
 
641
        }
 
642
        
 
643
         /**
 
644
          * auto generated method signature
 
645
          * for "ncDescribeInstances|http://eucalyptus.ucsb.edu/" operation.
 
646
          *
 
647
          * @param _ncDescribeInstances
 
648
          *
 
649
          * @return adb_ncDescribeInstancesResponse_t*
 
650
          */
 
651
         adb_ncDescribeInstancesResponse_t* 
 
652
         axis2_stub_op_EucalyptusNC_ncDescribeInstances( axis2_stub_t *stub, const axutil_env_t *env,
 
653
                                              adb_ncDescribeInstances_t* _ncDescribeInstances)
 
654
         {
 
655
            axis2_svc_client_t *svc_client = NULL;
 
656
            axis2_options_t *options = NULL;
 
657
            axiom_node_t *ret_node = NULL;
 
658
 
 
659
            const axis2_char_t *soap_action = NULL;
 
660
            axutil_qname_t *op_qname =  NULL;
 
661
            axiom_node_t *payload = NULL;
 
662
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
663
            
 
664
            axutil_string_t *soap_act = NULL;
 
665
            adb_ncDescribeInstancesResponse_t* ret_val = NULL;
 
666
            
 
667
                       payload = adb_ncDescribeInstances_serialize(_ncDescribeInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
668
                   
 
669
            svc_client = axis2_stub_get_svc_client(stub, env );
 
670
            
 
671
           
 
672
            
 
673
            
 
674
 
 
675
            options = axis2_stub_get_options( stub, env);
 
676
            if (NULL == options)
 
677
            {
 
678
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
679
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
680
                return NULL;
 
681
            }
 
682
            soap_action = axis2_options_get_action( options, env );
 
683
            if (NULL == soap_action)
 
684
            {
 
685
              is_soap_act_set = AXIS2_FALSE;
 
686
              soap_action = "EucalyptusNC#ncDescribeInstances";
 
687
              
 
688
              soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeInstances");
 
689
              axis2_options_set_soap_action(options, env, soap_act);    
 
690
              
 
691
              axis2_options_set_action( options, env, soap_action );
 
692
            }
 
693
            
 
694
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
695
            
 
696
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
697
 
 
698
            if (!is_soap_act_set)
 
699
            {
 
700
              
 
701
              axis2_options_set_soap_action(options, env, NULL);    
 
702
              
 
703
              axis2_options_set_action( options, env, NULL);
 
704
            }
 
705
 
 
706
            
 
707
            
 
708
                    if ( NULL == ret_node )
 
709
                    {
 
710
                        return NULL;
 
711
                    }
 
712
                    ret_val = adb_ncDescribeInstancesResponse_create(env);
 
713
 
 
714
                    if(adb_ncDescribeInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
715
                    {
 
716
                        if(ret_val != NULL)
 
717
                        {
 
718
                            adb_ncDescribeInstancesResponse_free(ret_val, env);
 
719
                        }
 
720
 
 
721
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDescribeInstancesResponse_deserialize: "
 
722
                                                                "This should be due to an invalid XML");
 
723
                        return NULL;
 
724
                    }
 
725
                    return ret_val;
 
726
                
 
727
        }
 
728
        
 
729
         /**
 
730
          * auto generated method signature
 
731
          * for "ncAttachVolume|http://eucalyptus.ucsb.edu/" operation.
 
732
          *
 
733
          * @param _ncAttachVolume
 
734
          *
 
735
          * @return adb_ncAttachVolumeResponse_t*
 
736
          */
 
737
         adb_ncAttachVolumeResponse_t* 
 
738
         axis2_stub_op_EucalyptusNC_ncAttachVolume( axis2_stub_t *stub, const axutil_env_t *env,
 
739
                                              adb_ncAttachVolume_t* _ncAttachVolume)
 
740
         {
 
741
            axis2_svc_client_t *svc_client = NULL;
 
742
            axis2_options_t *options = NULL;
 
743
            axiom_node_t *ret_node = NULL;
 
744
 
 
745
            const axis2_char_t *soap_action = NULL;
 
746
            axutil_qname_t *op_qname =  NULL;
 
747
            axiom_node_t *payload = NULL;
 
748
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
749
            
 
750
            axutil_string_t *soap_act = NULL;
 
751
            adb_ncAttachVolumeResponse_t* ret_val = NULL;
 
752
            
 
753
                       payload = adb_ncAttachVolume_serialize(_ncAttachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
754
                   
 
755
            svc_client = axis2_stub_get_svc_client(stub, env );
 
756
            
 
757
           
 
758
            
 
759
            
 
760
 
 
761
            options = axis2_stub_get_options( stub, env);
 
762
            if (NULL == options)
 
763
            {
 
764
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
765
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
766
                return NULL;
 
767
            }
 
768
            soap_action = axis2_options_get_action( options, env );
 
769
            if (NULL == soap_action)
 
770
            {
 
771
              is_soap_act_set = AXIS2_FALSE;
 
772
              soap_action = "EucalyptusNC#ncAttachVolume";
 
773
              
 
774
              soap_act = axutil_string_create(env, "EucalyptusNC#ncAttachVolume");
 
775
              axis2_options_set_soap_action(options, env, soap_act);    
 
776
              
 
777
              axis2_options_set_action( options, env, soap_action );
 
778
            }
 
779
            
 
780
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
781
            
 
782
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
783
 
 
784
            if (!is_soap_act_set)
 
785
            {
 
786
              
 
787
              axis2_options_set_soap_action(options, env, NULL);    
 
788
              
 
789
              axis2_options_set_action( options, env, NULL);
 
790
            }
 
791
 
 
792
            
 
793
            
 
794
                    if ( NULL == ret_node )
 
795
                    {
 
796
                        return NULL;
 
797
                    }
 
798
                    ret_val = adb_ncAttachVolumeResponse_create(env);
 
799
 
 
800
                    if(adb_ncAttachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
801
                    {
 
802
                        if(ret_val != NULL)
 
803
                        {
 
804
                            adb_ncAttachVolumeResponse_free(ret_val, env);
 
805
                        }
 
806
 
 
807
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncAttachVolumeResponse_deserialize: "
 
808
                                                                "This should be due to an invalid XML");
 
809
                        return NULL;
 
810
                    }
 
811
                    return ret_val;
 
812
                
 
813
        }
 
814
        
 
815
         /**
 
816
          * auto generated method signature
 
817
          * for "ncPowerDown|http://eucalyptus.ucsb.edu/" operation.
 
818
          *
 
819
          * @param _ncPowerDown
 
820
          *
 
821
          * @return adb_ncPowerDownResponse_t*
 
822
          */
 
823
         adb_ncPowerDownResponse_t* 
 
824
         axis2_stub_op_EucalyptusNC_ncPowerDown( axis2_stub_t *stub, const axutil_env_t *env,
 
825
                                              adb_ncPowerDown_t* _ncPowerDown)
 
826
         {
 
827
            axis2_svc_client_t *svc_client = NULL;
 
828
            axis2_options_t *options = NULL;
 
829
            axiom_node_t *ret_node = NULL;
 
830
 
 
831
            const axis2_char_t *soap_action = NULL;
 
832
            axutil_qname_t *op_qname =  NULL;
 
833
            axiom_node_t *payload = NULL;
 
834
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
835
            
 
836
            axutil_string_t *soap_act = NULL;
 
837
            adb_ncPowerDownResponse_t* ret_val = NULL;
 
838
            
 
839
                       payload = adb_ncPowerDown_serialize(_ncPowerDown, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
840
                   
 
841
            svc_client = axis2_stub_get_svc_client(stub, env );
 
842
            
 
843
           
 
844
            
 
845
            
 
846
 
 
847
            options = axis2_stub_get_options( stub, env);
 
848
            if (NULL == options)
 
849
            {
 
850
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
851
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
852
                return NULL;
 
853
            }
 
854
            soap_action = axis2_options_get_action( options, env );
 
855
            if (NULL == soap_action)
 
856
            {
 
857
              is_soap_act_set = AXIS2_FALSE;
 
858
              soap_action = "EucalyptusNC#ncPowerDown";
 
859
              
 
860
              soap_act = axutil_string_create(env, "EucalyptusNC#ncPowerDown");
 
861
              axis2_options_set_soap_action(options, env, soap_act);    
 
862
              
 
863
              axis2_options_set_action( options, env, soap_action );
 
864
            }
 
865
            
 
866
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
867
            
 
868
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
869
 
 
870
            if (!is_soap_act_set)
 
871
            {
 
872
              
 
873
              axis2_options_set_soap_action(options, env, NULL);    
 
874
              
 
875
              axis2_options_set_action( options, env, NULL);
 
876
            }
 
877
 
 
878
            
 
879
            
 
880
                    if ( NULL == ret_node )
 
881
                    {
 
882
                        return NULL;
 
883
                    }
 
884
                    ret_val = adb_ncPowerDownResponse_create(env);
 
885
 
 
886
                    if(adb_ncPowerDownResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
887
                    {
 
888
                        if(ret_val != NULL)
 
889
                        {
 
890
                            adb_ncPowerDownResponse_free(ret_val, env);
 
891
                        }
 
892
 
 
893
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncPowerDownResponse_deserialize: "
 
894
                                                                "This should be due to an invalid XML");
 
895
                        return NULL;
 
896
                    }
 
897
                    return ret_val;
 
898
                
 
899
        }
 
900
        
 
901
         /**
 
902
          * auto generated method signature
 
903
          * for "ncDescribeResource|http://eucalyptus.ucsb.edu/" operation.
 
904
          *
 
905
          * @param _ncDescribeResource
 
906
          *
 
907
          * @return adb_ncDescribeResourceResponse_t*
 
908
          */
 
909
         adb_ncDescribeResourceResponse_t* 
 
910
         axis2_stub_op_EucalyptusNC_ncDescribeResource( axis2_stub_t *stub, const axutil_env_t *env,
 
911
                                              adb_ncDescribeResource_t* _ncDescribeResource)
 
912
         {
 
913
            axis2_svc_client_t *svc_client = NULL;
 
914
            axis2_options_t *options = NULL;
 
915
            axiom_node_t *ret_node = NULL;
 
916
 
 
917
            const axis2_char_t *soap_action = NULL;
 
918
            axutil_qname_t *op_qname =  NULL;
 
919
            axiom_node_t *payload = NULL;
 
920
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
921
            
 
922
            axutil_string_t *soap_act = NULL;
 
923
            adb_ncDescribeResourceResponse_t* ret_val = NULL;
 
924
            
 
925
                       payload = adb_ncDescribeResource_serialize(_ncDescribeResource, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
926
                   
 
927
            svc_client = axis2_stub_get_svc_client(stub, env );
 
928
            
 
929
           
 
930
            
 
931
            
 
932
 
 
933
            options = axis2_stub_get_options( stub, env);
 
934
            if (NULL == options)
 
935
            {
 
936
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
937
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
938
                return NULL;
 
939
            }
 
940
            soap_action = axis2_options_get_action( options, env );
 
941
            if (NULL == soap_action)
 
942
            {
 
943
              is_soap_act_set = AXIS2_FALSE;
 
944
              soap_action = "EucalyptusNC#ncDescribeResource";
 
945
              
 
946
              soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeResource");
 
947
              axis2_options_set_soap_action(options, env, soap_act);    
 
948
              
 
949
              axis2_options_set_action( options, env, soap_action );
 
950
            }
 
951
            
 
952
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
953
            
 
954
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
955
 
 
956
            if (!is_soap_act_set)
 
957
            {
 
958
              
 
959
              axis2_options_set_soap_action(options, env, NULL);    
 
960
              
 
961
              axis2_options_set_action( options, env, NULL);
 
962
            }
 
963
 
 
964
            
 
965
            
 
966
                    if ( NULL == ret_node )
 
967
                    {
 
968
                        return NULL;
 
969
                    }
 
970
                    ret_val = adb_ncDescribeResourceResponse_create(env);
 
971
 
 
972
                    if(adb_ncDescribeResourceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
973
                    {
 
974
                        if(ret_val != NULL)
 
975
                        {
 
976
                            adb_ncDescribeResourceResponse_free(ret_val, env);
 
977
                        }
 
978
 
 
979
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDescribeResourceResponse_deserialize: "
 
980
                                                                "This should be due to an invalid XML");
 
981
                        return NULL;
 
982
                    }
 
983
                    return ret_val;
 
984
                
 
985
        }
 
986
        
 
987
         /**
 
988
          * auto generated method signature
 
989
          * for "ncTerminateInstance|http://eucalyptus.ucsb.edu/" operation.
 
990
          *
 
991
          * @param _ncTerminateInstance
 
992
          *
 
993
          * @return adb_ncTerminateInstanceResponse_t*
 
994
          */
 
995
         adb_ncTerminateInstanceResponse_t* 
 
996
         axis2_stub_op_EucalyptusNC_ncTerminateInstance( axis2_stub_t *stub, const axutil_env_t *env,
 
997
                                              adb_ncTerminateInstance_t* _ncTerminateInstance)
 
998
         {
 
999
            axis2_svc_client_t *svc_client = NULL;
 
1000
            axis2_options_t *options = NULL;
 
1001
            axiom_node_t *ret_node = NULL;
 
1002
 
 
1003
            const axis2_char_t *soap_action = NULL;
 
1004
            axutil_qname_t *op_qname =  NULL;
 
1005
            axiom_node_t *payload = NULL;
 
1006
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
1007
            
 
1008
            axutil_string_t *soap_act = NULL;
 
1009
            adb_ncTerminateInstanceResponse_t* ret_val = NULL;
 
1010
            
 
1011
                       payload = adb_ncTerminateInstance_serialize(_ncTerminateInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
1012
                   
 
1013
            svc_client = axis2_stub_get_svc_client(stub, env );
 
1014
            
 
1015
           
 
1016
            
 
1017
            
 
1018
 
 
1019
            options = axis2_stub_get_options( stub, env);
 
1020
            if (NULL == options)
 
1021
            {
 
1022
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
1023
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
1024
                return NULL;
 
1025
            }
 
1026
            soap_action = axis2_options_get_action( options, env );
 
1027
            if (NULL == soap_action)
 
1028
            {
 
1029
              is_soap_act_set = AXIS2_FALSE;
 
1030
              soap_action = "EucalyptusNC#ncTerminateInstance";
 
1031
              
 
1032
              soap_act = axutil_string_create(env, "EucalyptusNC#ncTerminateInstance");
 
1033
              axis2_options_set_soap_action(options, env, soap_act);    
 
1034
              
 
1035
              axis2_options_set_action( options, env, soap_action );
 
1036
            }
 
1037
            
 
1038
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
1039
            
 
1040
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
1041
 
 
1042
            if (!is_soap_act_set)
 
1043
            {
 
1044
              
 
1045
              axis2_options_set_soap_action(options, env, NULL);    
 
1046
              
 
1047
              axis2_options_set_action( options, env, NULL);
 
1048
            }
 
1049
 
 
1050
            
 
1051
            
 
1052
                    if ( NULL == ret_node )
 
1053
                    {
 
1054
                        return NULL;
 
1055
                    }
 
1056
                    ret_val = adb_ncTerminateInstanceResponse_create(env);
 
1057
 
 
1058
                    if(adb_ncTerminateInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1059
                    {
 
1060
                        if(ret_val != NULL)
 
1061
                        {
 
1062
                            adb_ncTerminateInstanceResponse_free(ret_val, env);
 
1063
                        }
 
1064
 
 
1065
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncTerminateInstanceResponse_deserialize: "
 
1066
                                                                "This should be due to an invalid XML");
 
1067
                        return NULL;
 
1068
                    }
 
1069
                    return ret_val;
 
1070
                
 
1071
        }
 
1072
        
 
1073
         /**
 
1074
          * auto generated method signature
 
1075
          * for "ncStartNetwork|http://eucalyptus.ucsb.edu/" operation.
 
1076
          *
 
1077
          * @param _ncStartNetwork
 
1078
          *
 
1079
          * @return adb_ncStartNetworkResponse_t*
 
1080
          */
 
1081
         adb_ncStartNetworkResponse_t* 
 
1082
         axis2_stub_op_EucalyptusNC_ncStartNetwork( axis2_stub_t *stub, const axutil_env_t *env,
 
1083
                                              adb_ncStartNetwork_t* _ncStartNetwork)
 
1084
         {
 
1085
            axis2_svc_client_t *svc_client = NULL;
 
1086
            axis2_options_t *options = NULL;
 
1087
            axiom_node_t *ret_node = NULL;
 
1088
 
 
1089
            const axis2_char_t *soap_action = NULL;
 
1090
            axutil_qname_t *op_qname =  NULL;
 
1091
            axiom_node_t *payload = NULL;
 
1092
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
1093
            
 
1094
            axutil_string_t *soap_act = NULL;
 
1095
            adb_ncStartNetworkResponse_t* ret_val = NULL;
 
1096
            
 
1097
                       payload = adb_ncStartNetwork_serialize(_ncStartNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
1098
                   
 
1099
            svc_client = axis2_stub_get_svc_client(stub, env );
 
1100
            
 
1101
           
 
1102
            
 
1103
            
 
1104
 
 
1105
            options = axis2_stub_get_options( stub, env);
 
1106
            if (NULL == options)
 
1107
            {
 
1108
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
1109
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
1110
                return NULL;
 
1111
            }
 
1112
            soap_action = axis2_options_get_action( options, env );
 
1113
            if (NULL == soap_action)
 
1114
            {
 
1115
              is_soap_act_set = AXIS2_FALSE;
 
1116
              soap_action = "EucalyptusNC#ncStartNetwork";
 
1117
              
 
1118
              soap_act = axutil_string_create(env, "EucalyptusNC#ncStartNetwork");
 
1119
              axis2_options_set_soap_action(options, env, soap_act);    
 
1120
              
 
1121
              axis2_options_set_action( options, env, soap_action );
 
1122
            }
 
1123
            
 
1124
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
1125
            
 
1126
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
1127
 
 
1128
            if (!is_soap_act_set)
 
1129
            {
 
1130
              
 
1131
              axis2_options_set_soap_action(options, env, NULL);    
 
1132
              
 
1133
              axis2_options_set_action( options, env, NULL);
 
1134
            }
 
1135
 
 
1136
            
 
1137
            
 
1138
                    if ( NULL == ret_node )
 
1139
                    {
 
1140
                        return NULL;
 
1141
                    }
 
1142
                    ret_val = adb_ncStartNetworkResponse_create(env);
 
1143
 
 
1144
                    if(adb_ncStartNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1145
                    {
 
1146
                        if(ret_val != NULL)
 
1147
                        {
 
1148
                            adb_ncStartNetworkResponse_free(ret_val, env);
 
1149
                        }
 
1150
 
 
1151
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncStartNetworkResponse_deserialize: "
 
1152
                                                                "This should be due to an invalid XML");
 
1153
                        return NULL;
 
1154
                    }
 
1155
                    return ret_val;
 
1156
                
 
1157
        }
 
1158
        
 
1159
 
 
1160
        struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data
 
1161
        {   
 
1162
            void *data;
 
1163
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRunInstanceResponse_t* _ncRunInstanceResponse, void *data);
 
1164
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
1165
        };
 
1166
 
 
1167
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncRunInstance(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
1168
        {
 
1169
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
1170
            struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data* callback_data = NULL;
 
1171
            void *user_data = NULL;
 
1172
 
 
1173
            axis2_status_t status;
 
1174
        
 
1175
            callback_data = (struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data*)axis2_callback_get_data(callback);
 
1176
        
 
1177
            user_data = callback_data->data;
 
1178
            on_error = callback_data->on_error;
 
1179
        
 
1180
            status = on_error(env, exception, user_data);
 
1181
 
 
1182
            if(callback_data)
 
1183
            {
 
1184
                AXIS2_FREE(env->allocator, callback_data);
 
1185
            }
 
1186
            return status;
 
1187
        } 
 
1188
 
 
1189
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncRunInstance(axis2_callback_t *callback, const axutil_env_t *env)
 
1190
        {
 
1191
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRunInstanceResponse_t* _ncRunInstanceResponse, void *data);
 
1192
            struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data* callback_data = NULL;
 
1193
            void *user_data = NULL;
 
1194
            axis2_status_t status = AXIS2_SUCCESS;
 
1195
 
 
1196
            adb_ncRunInstanceResponse_t* ret_val = NULL;
 
1197
            
 
1198
 
 
1199
            axiom_node_t *ret_node = NULL;
 
1200
            axiom_soap_envelope_t *soap_envelope = NULL;
 
1201
 
 
1202
            
 
1203
 
 
1204
            callback_data = (struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data*)axis2_callback_get_data(callback);
 
1205
 
 
1206
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
1207
            if(soap_envelope)
 
1208
            {
 
1209
                axiom_soap_body_t *soap_body;
 
1210
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
1211
                if(soap_body)
 
1212
                {
 
1213
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
1214
                    if(body_node)
 
1215
                    {
 
1216
                        ret_node = axiom_node_get_first_child(body_node, env);
 
1217
                    }
 
1218
                }
 
1219
                
 
1220
                
 
1221
            }
 
1222
 
 
1223
            user_data = callback_data->data;
 
1224
            on_complete = callback_data->on_complete;
 
1225
 
 
1226
            
 
1227
                    if(ret_node != NULL)
 
1228
                    {
 
1229
                        ret_val = adb_ncRunInstanceResponse_create(env);
 
1230
     
 
1231
                        if(adb_ncRunInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1232
                        {
 
1233
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
1234
                                                                    "This should be due to an invalid XML");
 
1235
                            adb_ncRunInstanceResponse_free(ret_val, env);
 
1236
                            ret_val = NULL;
 
1237
                        }
 
1238
                     }
 
1239
                     else
 
1240
                     {
 
1241
                         ret_val = NULL; 
 
1242
                     }
 
1243
                     status = on_complete(env, ret_val, user_data);
 
1244
                
 
1245
 
 
1246
            if(callback_data)
 
1247
            {
 
1248
                AXIS2_FREE(env->allocator, callback_data);
 
1249
            }
 
1250
            return status;
 
1251
        }
 
1252
 
 
1253
        /**
 
1254
          * auto generated method signature for asynchronous invocations
 
1255
          * for "ncRunInstance|http://eucalyptus.ucsb.edu/" operation.
 
1256
          
 
1257
          *
 
1258
          * @param _ncRunInstance
 
1259
          * @param on_complete callback to handle on complete
 
1260
          * @param on_error callback to handle on error
 
1261
          */
 
1262
         void axis2_stub_start_op_EucalyptusNC_ncRunInstance( axis2_stub_t *stub, const axutil_env_t *env,
 
1263
                                                    adb_ncRunInstance_t* _ncRunInstance,
 
1264
                                                  void *user_data,
 
1265
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRunInstanceResponse_t* _ncRunInstanceResponse, void *data) ,
 
1266
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
1267
         {
 
1268
 
 
1269
            axis2_callback_t *callback = NULL;
 
1270
 
 
1271
            axis2_svc_client_t *svc_client = NULL;
 
1272
            axis2_options_t *options = NULL;
 
1273
 
 
1274
            const axis2_char_t *soap_action = NULL;
 
1275
            axiom_node_t *payload = NULL;
 
1276
 
 
1277
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
1278
            
 
1279
            axutil_string_t *soap_act = NULL;
 
1280
            
 
1281
            
 
1282
            struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data *callback_data;
 
1283
 
 
1284
            callback_data = (struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data*) AXIS2_MALLOC(env->allocator, 
 
1285
                                    sizeof(struct axis2_stub_EucalyptusNC_ncRunInstance_callback_data));
 
1286
            if(NULL == callback_data)
 
1287
            {
 
1288
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
1289
                return;
 
1290
            }
 
1291
            
 
1292
            
 
1293
                       payload = adb_ncRunInstance_serialize(_ncRunInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
1294
                   
 
1295
 
 
1296
 
 
1297
 
 
1298
            options = axis2_stub_get_options( stub, env);
 
1299
            if (NULL == options)
 
1300
            {
 
1301
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
1302
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
1303
              return;
 
1304
            }
 
1305
            svc_client = axis2_stub_get_svc_client (stub, env);
 
1306
            soap_action =axis2_options_get_action (options, env);
 
1307
            if (NULL == soap_action)
 
1308
            {
 
1309
              is_soap_act_set = AXIS2_FALSE;
 
1310
              soap_action = "EucalyptusNC#ncRunInstance";
 
1311
              
 
1312
              soap_act = axutil_string_create(env, "EucalyptusNC#ncRunInstance");
 
1313
              axis2_options_set_soap_action(options, env, soap_act);
 
1314
              
 
1315
              axis2_options_set_action( options, env, soap_action);
 
1316
            }
 
1317
            
 
1318
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
1319
             
 
1320
 
 
1321
            callback = axis2_callback_create(env);
 
1322
            /* Set our on_complete fucntion pointer to the callback object */
 
1323
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncRunInstance);
 
1324
            /* Set our on_error function pointer to the callback object */
 
1325
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncRunInstance);
 
1326
 
 
1327
            callback_data-> data = user_data;
 
1328
            callback_data-> on_complete = on_complete;
 
1329
            callback_data-> on_error = on_error;
 
1330
 
 
1331
            axis2_callback_set_data(callback, (void*)callback_data);
 
1332
 
 
1333
            /* Send request */
 
1334
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
1335
            
 
1336
            if (!is_soap_act_set)
 
1337
            {
 
1338
              
 
1339
              axis2_options_set_soap_action(options, env, NULL);
 
1340
              
 
1341
              axis2_options_set_action(options, env, NULL);
 
1342
            }
 
1343
         }
 
1344
 
 
1345
         
 
1346
 
 
1347
        struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data
 
1348
        {   
 
1349
            void *data;
 
1350
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRebootInstanceResponse_t* _ncRebootInstanceResponse, void *data);
 
1351
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
1352
        };
 
1353
 
 
1354
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncRebootInstance(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
1355
        {
 
1356
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
1357
            struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data* callback_data = NULL;
 
1358
            void *user_data = NULL;
 
1359
 
 
1360
            axis2_status_t status;
 
1361
        
 
1362
            callback_data = (struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data*)axis2_callback_get_data(callback);
 
1363
        
 
1364
            user_data = callback_data->data;
 
1365
            on_error = callback_data->on_error;
 
1366
        
 
1367
            status = on_error(env, exception, user_data);
 
1368
 
 
1369
            if(callback_data)
 
1370
            {
 
1371
                AXIS2_FREE(env->allocator, callback_data);
 
1372
            }
 
1373
            return status;
 
1374
        } 
 
1375
 
 
1376
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncRebootInstance(axis2_callback_t *callback, const axutil_env_t *env)
 
1377
        {
 
1378
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRebootInstanceResponse_t* _ncRebootInstanceResponse, void *data);
 
1379
            struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data* callback_data = NULL;
 
1380
            void *user_data = NULL;
 
1381
            axis2_status_t status = AXIS2_SUCCESS;
 
1382
 
 
1383
            adb_ncRebootInstanceResponse_t* ret_val = NULL;
 
1384
            
 
1385
 
 
1386
            axiom_node_t *ret_node = NULL;
 
1387
            axiom_soap_envelope_t *soap_envelope = NULL;
 
1388
 
 
1389
            
 
1390
 
 
1391
            callback_data = (struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data*)axis2_callback_get_data(callback);
 
1392
 
 
1393
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
1394
            if(soap_envelope)
 
1395
            {
 
1396
                axiom_soap_body_t *soap_body;
 
1397
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
1398
                if(soap_body)
 
1399
                {
 
1400
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
1401
                    if(body_node)
 
1402
                    {
 
1403
                        ret_node = axiom_node_get_first_child(body_node, env);
 
1404
                    }
 
1405
                }
 
1406
                
 
1407
                
 
1408
            }
 
1409
 
 
1410
            user_data = callback_data->data;
 
1411
            on_complete = callback_data->on_complete;
 
1412
 
 
1413
            
 
1414
                    if(ret_node != NULL)
 
1415
                    {
 
1416
                        ret_val = adb_ncRebootInstanceResponse_create(env);
 
1417
     
 
1418
                        if(adb_ncRebootInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1419
                        {
 
1420
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
1421
                                                                    "This should be due to an invalid XML");
 
1422
                            adb_ncRebootInstanceResponse_free(ret_val, env);
 
1423
                            ret_val = NULL;
 
1424
                        }
 
1425
                     }
 
1426
                     else
 
1427
                     {
 
1428
                         ret_val = NULL; 
 
1429
                     }
 
1430
                     status = on_complete(env, ret_val, user_data);
 
1431
                
 
1432
 
 
1433
            if(callback_data)
 
1434
            {
 
1435
                AXIS2_FREE(env->allocator, callback_data);
 
1436
            }
 
1437
            return status;
 
1438
        }
 
1439
 
 
1440
        /**
 
1441
          * auto generated method signature for asynchronous invocations
 
1442
          * for "ncRebootInstance|http://eucalyptus.ucsb.edu/" operation.
 
1443
          
 
1444
          *
 
1445
          * @param _ncRebootInstance
 
1446
          * @param on_complete callback to handle on complete
 
1447
          * @param on_error callback to handle on error
 
1448
          */
 
1449
         void axis2_stub_start_op_EucalyptusNC_ncRebootInstance( axis2_stub_t *stub, const axutil_env_t *env,
 
1450
                                                    adb_ncRebootInstance_t* _ncRebootInstance,
 
1451
                                                  void *user_data,
 
1452
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncRebootInstanceResponse_t* _ncRebootInstanceResponse, void *data) ,
 
1453
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
1454
         {
 
1455
 
 
1456
            axis2_callback_t *callback = NULL;
 
1457
 
 
1458
            axis2_svc_client_t *svc_client = NULL;
 
1459
            axis2_options_t *options = NULL;
 
1460
 
 
1461
            const axis2_char_t *soap_action = NULL;
 
1462
            axiom_node_t *payload = NULL;
 
1463
 
 
1464
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
1465
            
 
1466
            axutil_string_t *soap_act = NULL;
 
1467
            
 
1468
            
 
1469
            struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data *callback_data;
 
1470
 
 
1471
            callback_data = (struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data*) AXIS2_MALLOC(env->allocator, 
 
1472
                                    sizeof(struct axis2_stub_EucalyptusNC_ncRebootInstance_callback_data));
 
1473
            if(NULL == callback_data)
 
1474
            {
 
1475
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
1476
                return;
 
1477
            }
 
1478
            
 
1479
            
 
1480
                       payload = adb_ncRebootInstance_serialize(_ncRebootInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
1481
                   
 
1482
 
 
1483
 
 
1484
 
 
1485
            options = axis2_stub_get_options( stub, env);
 
1486
            if (NULL == options)
 
1487
            {
 
1488
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
1489
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
1490
              return;
 
1491
            }
 
1492
            svc_client = axis2_stub_get_svc_client (stub, env);
 
1493
            soap_action =axis2_options_get_action (options, env);
 
1494
            if (NULL == soap_action)
 
1495
            {
 
1496
              is_soap_act_set = AXIS2_FALSE;
 
1497
              soap_action = "EucalyptusNC#ncRebootInstance";
 
1498
              
 
1499
              soap_act = axutil_string_create(env, "EucalyptusNC#ncRebootInstance");
 
1500
              axis2_options_set_soap_action(options, env, soap_act);
 
1501
              
 
1502
              axis2_options_set_action( options, env, soap_action);
 
1503
            }
 
1504
            
 
1505
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
1506
             
 
1507
 
 
1508
            callback = axis2_callback_create(env);
 
1509
            /* Set our on_complete fucntion pointer to the callback object */
 
1510
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncRebootInstance);
 
1511
            /* Set our on_error function pointer to the callback object */
 
1512
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncRebootInstance);
 
1513
 
 
1514
            callback_data-> data = user_data;
 
1515
            callback_data-> on_complete = on_complete;
 
1516
            callback_data-> on_error = on_error;
 
1517
 
 
1518
            axis2_callback_set_data(callback, (void*)callback_data);
 
1519
 
 
1520
            /* Send request */
 
1521
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
1522
            
 
1523
            if (!is_soap_act_set)
 
1524
            {
 
1525
              
 
1526
              axis2_options_set_soap_action(options, env, NULL);
 
1527
              
 
1528
              axis2_options_set_action(options, env, NULL);
 
1529
            }
 
1530
         }
 
1531
 
 
1532
         
 
1533
 
 
1534
        struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data
 
1535
        {   
 
1536
            void *data;
 
1537
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncGetConsoleOutputResponse_t* _ncGetConsoleOutputResponse, void *data);
 
1538
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
1539
        };
 
1540
 
 
1541
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncGetConsoleOutput(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
1542
        {
 
1543
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
1544
            struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data* callback_data = NULL;
 
1545
            void *user_data = NULL;
 
1546
 
 
1547
            axis2_status_t status;
 
1548
        
 
1549
            callback_data = (struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data*)axis2_callback_get_data(callback);
 
1550
        
 
1551
            user_data = callback_data->data;
 
1552
            on_error = callback_data->on_error;
 
1553
        
 
1554
            status = on_error(env, exception, user_data);
 
1555
 
 
1556
            if(callback_data)
 
1557
            {
 
1558
                AXIS2_FREE(env->allocator, callback_data);
 
1559
            }
 
1560
            return status;
 
1561
        } 
 
1562
 
 
1563
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncGetConsoleOutput(axis2_callback_t *callback, const axutil_env_t *env)
 
1564
        {
 
1565
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncGetConsoleOutputResponse_t* _ncGetConsoleOutputResponse, void *data);
 
1566
            struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data* callback_data = NULL;
 
1567
            void *user_data = NULL;
 
1568
            axis2_status_t status = AXIS2_SUCCESS;
 
1569
 
 
1570
            adb_ncGetConsoleOutputResponse_t* ret_val = NULL;
 
1571
            
 
1572
 
 
1573
            axiom_node_t *ret_node = NULL;
 
1574
            axiom_soap_envelope_t *soap_envelope = NULL;
 
1575
 
 
1576
            
 
1577
 
 
1578
            callback_data = (struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data*)axis2_callback_get_data(callback);
 
1579
 
 
1580
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
1581
            if(soap_envelope)
 
1582
            {
 
1583
                axiom_soap_body_t *soap_body;
 
1584
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
1585
                if(soap_body)
 
1586
                {
 
1587
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
1588
                    if(body_node)
 
1589
                    {
 
1590
                        ret_node = axiom_node_get_first_child(body_node, env);
 
1591
                    }
 
1592
                }
 
1593
                
 
1594
                
 
1595
            }
 
1596
 
 
1597
            user_data = callback_data->data;
 
1598
            on_complete = callback_data->on_complete;
 
1599
 
 
1600
            
 
1601
                    if(ret_node != NULL)
 
1602
                    {
 
1603
                        ret_val = adb_ncGetConsoleOutputResponse_create(env);
 
1604
     
 
1605
                        if(adb_ncGetConsoleOutputResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1606
                        {
 
1607
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
1608
                                                                    "This should be due to an invalid XML");
 
1609
                            adb_ncGetConsoleOutputResponse_free(ret_val, env);
 
1610
                            ret_val = NULL;
 
1611
                        }
 
1612
                     }
 
1613
                     else
 
1614
                     {
 
1615
                         ret_val = NULL; 
 
1616
                     }
 
1617
                     status = on_complete(env, ret_val, user_data);
 
1618
                
 
1619
 
 
1620
            if(callback_data)
 
1621
            {
 
1622
                AXIS2_FREE(env->allocator, callback_data);
 
1623
            }
 
1624
            return status;
 
1625
        }
 
1626
 
 
1627
        /**
 
1628
          * auto generated method signature for asynchronous invocations
 
1629
          * for "ncGetConsoleOutput|http://eucalyptus.ucsb.edu/" operation.
 
1630
          
 
1631
          *
 
1632
          * @param _ncGetConsoleOutput
 
1633
          * @param on_complete callback to handle on complete
 
1634
          * @param on_error callback to handle on error
 
1635
          */
 
1636
         void axis2_stub_start_op_EucalyptusNC_ncGetConsoleOutput( axis2_stub_t *stub, const axutil_env_t *env,
 
1637
                                                    adb_ncGetConsoleOutput_t* _ncGetConsoleOutput,
 
1638
                                                  void *user_data,
 
1639
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncGetConsoleOutputResponse_t* _ncGetConsoleOutputResponse, void *data) ,
 
1640
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
1641
         {
 
1642
 
 
1643
            axis2_callback_t *callback = NULL;
 
1644
 
 
1645
            axis2_svc_client_t *svc_client = NULL;
 
1646
            axis2_options_t *options = NULL;
 
1647
 
 
1648
            const axis2_char_t *soap_action = NULL;
 
1649
            axiom_node_t *payload = NULL;
 
1650
 
 
1651
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
1652
            
 
1653
            axutil_string_t *soap_act = NULL;
 
1654
            
 
1655
            
 
1656
            struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data *callback_data;
 
1657
 
 
1658
            callback_data = (struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data*) AXIS2_MALLOC(env->allocator, 
 
1659
                                    sizeof(struct axis2_stub_EucalyptusNC_ncGetConsoleOutput_callback_data));
 
1660
            if(NULL == callback_data)
 
1661
            {
 
1662
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
1663
                return;
 
1664
            }
 
1665
            
 
1666
            
 
1667
                       payload = adb_ncGetConsoleOutput_serialize(_ncGetConsoleOutput, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
1668
                   
 
1669
 
 
1670
 
 
1671
 
 
1672
            options = axis2_stub_get_options( stub, env);
 
1673
            if (NULL == options)
 
1674
            {
 
1675
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
1676
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
1677
              return;
 
1678
            }
 
1679
            svc_client = axis2_stub_get_svc_client (stub, env);
 
1680
            soap_action =axis2_options_get_action (options, env);
 
1681
            if (NULL == soap_action)
 
1682
            {
 
1683
              is_soap_act_set = AXIS2_FALSE;
 
1684
              soap_action = "EucalyptusNC#ncGetConsoleOutput";
 
1685
              
 
1686
              soap_act = axutil_string_create(env, "EucalyptusNC#ncGetConsoleOutput");
 
1687
              axis2_options_set_soap_action(options, env, soap_act);
 
1688
              
 
1689
              axis2_options_set_action( options, env, soap_action);
 
1690
            }
 
1691
            
 
1692
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
1693
             
 
1694
 
 
1695
            callback = axis2_callback_create(env);
 
1696
            /* Set our on_complete fucntion pointer to the callback object */
 
1697
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncGetConsoleOutput);
 
1698
            /* Set our on_error function pointer to the callback object */
 
1699
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncGetConsoleOutput);
 
1700
 
 
1701
            callback_data-> data = user_data;
 
1702
            callback_data-> on_complete = on_complete;
 
1703
            callback_data-> on_error = on_error;
 
1704
 
 
1705
            axis2_callback_set_data(callback, (void*)callback_data);
 
1706
 
 
1707
            /* Send request */
 
1708
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
1709
            
 
1710
            if (!is_soap_act_set)
 
1711
            {
 
1712
              
 
1713
              axis2_options_set_soap_action(options, env, NULL);
 
1714
              
 
1715
              axis2_options_set_action(options, env, NULL);
 
1716
            }
 
1717
         }
 
1718
 
 
1719
         
 
1720
 
 
1721
        struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data
 
1722
        {   
 
1723
            void *data;
 
1724
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDetachVolumeResponse_t* _ncDetachVolumeResponse, void *data);
 
1725
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
1726
        };
 
1727
 
 
1728
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncDetachVolume(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
1729
        {
 
1730
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
1731
            struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data* callback_data = NULL;
 
1732
            void *user_data = NULL;
 
1733
 
 
1734
            axis2_status_t status;
 
1735
        
 
1736
            callback_data = (struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data*)axis2_callback_get_data(callback);
 
1737
        
 
1738
            user_data = callback_data->data;
 
1739
            on_error = callback_data->on_error;
 
1740
        
 
1741
            status = on_error(env, exception, user_data);
 
1742
 
 
1743
            if(callback_data)
 
1744
            {
 
1745
                AXIS2_FREE(env->allocator, callback_data);
 
1746
            }
 
1747
            return status;
 
1748
        } 
 
1749
 
 
1750
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncDetachVolume(axis2_callback_t *callback, const axutil_env_t *env)
 
1751
        {
 
1752
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDetachVolumeResponse_t* _ncDetachVolumeResponse, void *data);
 
1753
            struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data* callback_data = NULL;
 
1754
            void *user_data = NULL;
 
1755
            axis2_status_t status = AXIS2_SUCCESS;
 
1756
 
 
1757
            adb_ncDetachVolumeResponse_t* ret_val = NULL;
 
1758
            
 
1759
 
 
1760
            axiom_node_t *ret_node = NULL;
 
1761
            axiom_soap_envelope_t *soap_envelope = NULL;
 
1762
 
 
1763
            
 
1764
 
 
1765
            callback_data = (struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data*)axis2_callback_get_data(callback);
 
1766
 
 
1767
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
1768
            if(soap_envelope)
 
1769
            {
 
1770
                axiom_soap_body_t *soap_body;
 
1771
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
1772
                if(soap_body)
 
1773
                {
 
1774
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
1775
                    if(body_node)
 
1776
                    {
 
1777
                        ret_node = axiom_node_get_first_child(body_node, env);
 
1778
                    }
 
1779
                }
 
1780
                
 
1781
                
 
1782
            }
 
1783
 
 
1784
            user_data = callback_data->data;
 
1785
            on_complete = callback_data->on_complete;
 
1786
 
 
1787
            
 
1788
                    if(ret_node != NULL)
 
1789
                    {
 
1790
                        ret_val = adb_ncDetachVolumeResponse_create(env);
 
1791
     
 
1792
                        if(adb_ncDetachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1793
                        {
 
1794
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
1795
                                                                    "This should be due to an invalid XML");
 
1796
                            adb_ncDetachVolumeResponse_free(ret_val, env);
 
1797
                            ret_val = NULL;
 
1798
                        }
 
1799
                     }
 
1800
                     else
 
1801
                     {
 
1802
                         ret_val = NULL; 
 
1803
                     }
 
1804
                     status = on_complete(env, ret_val, user_data);
 
1805
                
 
1806
 
 
1807
            if(callback_data)
 
1808
            {
 
1809
                AXIS2_FREE(env->allocator, callback_data);
 
1810
            }
 
1811
            return status;
 
1812
        }
 
1813
 
 
1814
        /**
 
1815
          * auto generated method signature for asynchronous invocations
 
1816
          * for "ncDetachVolume|http://eucalyptus.ucsb.edu/" operation.
 
1817
          
 
1818
          *
 
1819
          * @param _ncDetachVolume
 
1820
          * @param on_complete callback to handle on complete
 
1821
          * @param on_error callback to handle on error
 
1822
          */
 
1823
         void axis2_stub_start_op_EucalyptusNC_ncDetachVolume( axis2_stub_t *stub, const axutil_env_t *env,
 
1824
                                                    adb_ncDetachVolume_t* _ncDetachVolume,
 
1825
                                                  void *user_data,
 
1826
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDetachVolumeResponse_t* _ncDetachVolumeResponse, void *data) ,
 
1827
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
1828
         {
 
1829
 
 
1830
            axis2_callback_t *callback = NULL;
 
1831
 
 
1832
            axis2_svc_client_t *svc_client = NULL;
 
1833
            axis2_options_t *options = NULL;
 
1834
 
 
1835
            const axis2_char_t *soap_action = NULL;
 
1836
            axiom_node_t *payload = NULL;
 
1837
 
 
1838
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
1839
            
 
1840
            axutil_string_t *soap_act = NULL;
 
1841
            
 
1842
            
 
1843
            struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data *callback_data;
 
1844
 
 
1845
            callback_data = (struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data*) AXIS2_MALLOC(env->allocator, 
 
1846
                                    sizeof(struct axis2_stub_EucalyptusNC_ncDetachVolume_callback_data));
 
1847
            if(NULL == callback_data)
 
1848
            {
 
1849
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
1850
                return;
 
1851
            }
 
1852
            
 
1853
            
 
1854
                       payload = adb_ncDetachVolume_serialize(_ncDetachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
1855
                   
 
1856
 
 
1857
 
 
1858
 
 
1859
            options = axis2_stub_get_options( stub, env);
 
1860
            if (NULL == options)
 
1861
            {
 
1862
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
1863
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
1864
              return;
 
1865
            }
 
1866
            svc_client = axis2_stub_get_svc_client (stub, env);
 
1867
            soap_action =axis2_options_get_action (options, env);
 
1868
            if (NULL == soap_action)
 
1869
            {
 
1870
              is_soap_act_set = AXIS2_FALSE;
 
1871
              soap_action = "EucalyptusNC#ncDetachVolume";
 
1872
              
 
1873
              soap_act = axutil_string_create(env, "EucalyptusNC#ncDetachVolume");
 
1874
              axis2_options_set_soap_action(options, env, soap_act);
 
1875
              
 
1876
              axis2_options_set_action( options, env, soap_action);
 
1877
            }
 
1878
            
 
1879
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
1880
             
 
1881
 
 
1882
            callback = axis2_callback_create(env);
 
1883
            /* Set our on_complete fucntion pointer to the callback object */
 
1884
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncDetachVolume);
 
1885
            /* Set our on_error function pointer to the callback object */
 
1886
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncDetachVolume);
 
1887
 
 
1888
            callback_data-> data = user_data;
 
1889
            callback_data-> on_complete = on_complete;
 
1890
            callback_data-> on_error = on_error;
 
1891
 
 
1892
            axis2_callback_set_data(callback, (void*)callback_data);
 
1893
 
 
1894
            /* Send request */
 
1895
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
1896
            
 
1897
            if (!is_soap_act_set)
 
1898
            {
 
1899
              
 
1900
              axis2_options_set_soap_action(options, env, NULL);
 
1901
              
 
1902
              axis2_options_set_action(options, env, NULL);
 
1903
            }
 
1904
         }
 
1905
 
 
1906
         
 
1907
 
 
1908
        struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data
 
1909
        {   
 
1910
            void *data;
 
1911
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeInstancesResponse_t* _ncDescribeInstancesResponse, void *data);
 
1912
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
1913
        };
 
1914
 
 
1915
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncDescribeInstances(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
1916
        {
 
1917
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
1918
            struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data* callback_data = NULL;
 
1919
            void *user_data = NULL;
 
1920
 
 
1921
            axis2_status_t status;
 
1922
        
 
1923
            callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data*)axis2_callback_get_data(callback);
 
1924
        
 
1925
            user_data = callback_data->data;
 
1926
            on_error = callback_data->on_error;
 
1927
        
 
1928
            status = on_error(env, exception, user_data);
 
1929
 
 
1930
            if(callback_data)
 
1931
            {
 
1932
                AXIS2_FREE(env->allocator, callback_data);
 
1933
            }
 
1934
            return status;
 
1935
        } 
 
1936
 
 
1937
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncDescribeInstances(axis2_callback_t *callback, const axutil_env_t *env)
 
1938
        {
 
1939
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeInstancesResponse_t* _ncDescribeInstancesResponse, void *data);
 
1940
            struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data* callback_data = NULL;
 
1941
            void *user_data = NULL;
 
1942
            axis2_status_t status = AXIS2_SUCCESS;
 
1943
 
 
1944
            adb_ncDescribeInstancesResponse_t* ret_val = NULL;
 
1945
            
 
1946
 
 
1947
            axiom_node_t *ret_node = NULL;
 
1948
            axiom_soap_envelope_t *soap_envelope = NULL;
 
1949
 
 
1950
            
 
1951
 
 
1952
            callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data*)axis2_callback_get_data(callback);
 
1953
 
 
1954
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
1955
            if(soap_envelope)
 
1956
            {
 
1957
                axiom_soap_body_t *soap_body;
 
1958
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
1959
                if(soap_body)
 
1960
                {
 
1961
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
1962
                    if(body_node)
 
1963
                    {
 
1964
                        ret_node = axiom_node_get_first_child(body_node, env);
 
1965
                    }
 
1966
                }
 
1967
                
 
1968
                
 
1969
            }
 
1970
 
 
1971
            user_data = callback_data->data;
 
1972
            on_complete = callback_data->on_complete;
 
1973
 
 
1974
            
 
1975
                    if(ret_node != NULL)
 
1976
                    {
 
1977
                        ret_val = adb_ncDescribeInstancesResponse_create(env);
 
1978
     
 
1979
                        if(adb_ncDescribeInstancesResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
1980
                        {
 
1981
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
1982
                                                                    "This should be due to an invalid XML");
 
1983
                            adb_ncDescribeInstancesResponse_free(ret_val, env);
 
1984
                            ret_val = NULL;
 
1985
                        }
 
1986
                     }
 
1987
                     else
 
1988
                     {
 
1989
                         ret_val = NULL; 
 
1990
                     }
 
1991
                     status = on_complete(env, ret_val, user_data);
 
1992
                
 
1993
 
 
1994
            if(callback_data)
 
1995
            {
 
1996
                AXIS2_FREE(env->allocator, callback_data);
 
1997
            }
 
1998
            return status;
 
1999
        }
 
2000
 
 
2001
        /**
 
2002
          * auto generated method signature for asynchronous invocations
 
2003
          * for "ncDescribeInstances|http://eucalyptus.ucsb.edu/" operation.
 
2004
          
 
2005
          *
 
2006
          * @param _ncDescribeInstances
 
2007
          * @param on_complete callback to handle on complete
 
2008
          * @param on_error callback to handle on error
 
2009
          */
 
2010
         void axis2_stub_start_op_EucalyptusNC_ncDescribeInstances( axis2_stub_t *stub, const axutil_env_t *env,
 
2011
                                                    adb_ncDescribeInstances_t* _ncDescribeInstances,
 
2012
                                                  void *user_data,
 
2013
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeInstancesResponse_t* _ncDescribeInstancesResponse, void *data) ,
 
2014
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
2015
         {
 
2016
 
 
2017
            axis2_callback_t *callback = NULL;
 
2018
 
 
2019
            axis2_svc_client_t *svc_client = NULL;
 
2020
            axis2_options_t *options = NULL;
 
2021
 
 
2022
            const axis2_char_t *soap_action = NULL;
 
2023
            axiom_node_t *payload = NULL;
 
2024
 
 
2025
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
2026
            
 
2027
            axutil_string_t *soap_act = NULL;
 
2028
            
 
2029
            
 
2030
            struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data *callback_data;
 
2031
 
 
2032
            callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data*) AXIS2_MALLOC(env->allocator, 
 
2033
                                    sizeof(struct axis2_stub_EucalyptusNC_ncDescribeInstances_callback_data));
 
2034
            if(NULL == callback_data)
 
2035
            {
 
2036
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
2037
                return;
 
2038
            }
 
2039
            
 
2040
            
 
2041
                       payload = adb_ncDescribeInstances_serialize(_ncDescribeInstances, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
2042
                   
 
2043
 
 
2044
 
 
2045
 
 
2046
            options = axis2_stub_get_options( stub, env);
 
2047
            if (NULL == options)
 
2048
            {
 
2049
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
2050
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
2051
              return;
 
2052
            }
 
2053
            svc_client = axis2_stub_get_svc_client (stub, env);
 
2054
            soap_action =axis2_options_get_action (options, env);
 
2055
            if (NULL == soap_action)
 
2056
            {
 
2057
              is_soap_act_set = AXIS2_FALSE;
 
2058
              soap_action = "EucalyptusNC#ncDescribeInstances";
 
2059
              
 
2060
              soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeInstances");
 
2061
              axis2_options_set_soap_action(options, env, soap_act);
 
2062
              
 
2063
              axis2_options_set_action( options, env, soap_action);
 
2064
            }
 
2065
            
 
2066
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
2067
             
 
2068
 
 
2069
            callback = axis2_callback_create(env);
 
2070
            /* Set our on_complete fucntion pointer to the callback object */
 
2071
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncDescribeInstances);
 
2072
            /* Set our on_error function pointer to the callback object */
 
2073
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncDescribeInstances);
 
2074
 
 
2075
            callback_data-> data = user_data;
 
2076
            callback_data-> on_complete = on_complete;
 
2077
            callback_data-> on_error = on_error;
 
2078
 
 
2079
            axis2_callback_set_data(callback, (void*)callback_data);
 
2080
 
 
2081
            /* Send request */
 
2082
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
2083
            
 
2084
            if (!is_soap_act_set)
 
2085
            {
 
2086
              
 
2087
              axis2_options_set_soap_action(options, env, NULL);
 
2088
              
 
2089
              axis2_options_set_action(options, env, NULL);
 
2090
            }
 
2091
         }
 
2092
 
 
2093
         
 
2094
 
 
2095
        struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data
 
2096
        {   
 
2097
            void *data;
 
2098
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncAttachVolumeResponse_t* _ncAttachVolumeResponse, void *data);
 
2099
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
2100
        };
 
2101
 
 
2102
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncAttachVolume(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
2103
        {
 
2104
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
2105
            struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data* callback_data = NULL;
 
2106
            void *user_data = NULL;
 
2107
 
 
2108
            axis2_status_t status;
 
2109
        
 
2110
            callback_data = (struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data*)axis2_callback_get_data(callback);
 
2111
        
 
2112
            user_data = callback_data->data;
 
2113
            on_error = callback_data->on_error;
 
2114
        
 
2115
            status = on_error(env, exception, user_data);
 
2116
 
 
2117
            if(callback_data)
 
2118
            {
 
2119
                AXIS2_FREE(env->allocator, callback_data);
 
2120
            }
 
2121
            return status;
 
2122
        } 
 
2123
 
 
2124
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncAttachVolume(axis2_callback_t *callback, const axutil_env_t *env)
 
2125
        {
 
2126
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncAttachVolumeResponse_t* _ncAttachVolumeResponse, void *data);
 
2127
            struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data* callback_data = NULL;
 
2128
            void *user_data = NULL;
 
2129
            axis2_status_t status = AXIS2_SUCCESS;
 
2130
 
 
2131
            adb_ncAttachVolumeResponse_t* ret_val = NULL;
 
2132
            
 
2133
 
 
2134
            axiom_node_t *ret_node = NULL;
 
2135
            axiom_soap_envelope_t *soap_envelope = NULL;
 
2136
 
 
2137
            
 
2138
 
 
2139
            callback_data = (struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data*)axis2_callback_get_data(callback);
 
2140
 
 
2141
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
2142
            if(soap_envelope)
 
2143
            {
 
2144
                axiom_soap_body_t *soap_body;
 
2145
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
2146
                if(soap_body)
 
2147
                {
 
2148
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
2149
                    if(body_node)
 
2150
                    {
 
2151
                        ret_node = axiom_node_get_first_child(body_node, env);
 
2152
                    }
 
2153
                }
 
2154
                
 
2155
                
 
2156
            }
 
2157
 
 
2158
            user_data = callback_data->data;
 
2159
            on_complete = callback_data->on_complete;
 
2160
 
 
2161
            
 
2162
                    if(ret_node != NULL)
 
2163
                    {
 
2164
                        ret_val = adb_ncAttachVolumeResponse_create(env);
 
2165
     
 
2166
                        if(adb_ncAttachVolumeResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
2167
                        {
 
2168
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
2169
                                                                    "This should be due to an invalid XML");
 
2170
                            adb_ncAttachVolumeResponse_free(ret_val, env);
 
2171
                            ret_val = NULL;
 
2172
                        }
 
2173
                     }
 
2174
                     else
 
2175
                     {
 
2176
                         ret_val = NULL; 
 
2177
                     }
 
2178
                     status = on_complete(env, ret_val, user_data);
 
2179
                
 
2180
 
 
2181
            if(callback_data)
 
2182
            {
 
2183
                AXIS2_FREE(env->allocator, callback_data);
 
2184
            }
 
2185
            return status;
 
2186
        }
 
2187
 
 
2188
        /**
 
2189
          * auto generated method signature for asynchronous invocations
 
2190
          * for "ncAttachVolume|http://eucalyptus.ucsb.edu/" operation.
 
2191
          
 
2192
          *
 
2193
          * @param _ncAttachVolume
 
2194
          * @param on_complete callback to handle on complete
 
2195
          * @param on_error callback to handle on error
 
2196
          */
 
2197
         void axis2_stub_start_op_EucalyptusNC_ncAttachVolume( axis2_stub_t *stub, const axutil_env_t *env,
 
2198
                                                    adb_ncAttachVolume_t* _ncAttachVolume,
 
2199
                                                  void *user_data,
 
2200
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncAttachVolumeResponse_t* _ncAttachVolumeResponse, void *data) ,
 
2201
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
2202
         {
 
2203
 
 
2204
            axis2_callback_t *callback = NULL;
 
2205
 
 
2206
            axis2_svc_client_t *svc_client = NULL;
 
2207
            axis2_options_t *options = NULL;
 
2208
 
 
2209
            const axis2_char_t *soap_action = NULL;
 
2210
            axiom_node_t *payload = NULL;
 
2211
 
 
2212
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
2213
            
 
2214
            axutil_string_t *soap_act = NULL;
 
2215
            
 
2216
            
 
2217
            struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data *callback_data;
 
2218
 
 
2219
            callback_data = (struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data*) AXIS2_MALLOC(env->allocator, 
 
2220
                                    sizeof(struct axis2_stub_EucalyptusNC_ncAttachVolume_callback_data));
 
2221
            if(NULL == callback_data)
 
2222
            {
 
2223
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
2224
                return;
 
2225
            }
 
2226
            
 
2227
            
 
2228
                       payload = adb_ncAttachVolume_serialize(_ncAttachVolume, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
2229
                   
 
2230
 
 
2231
 
 
2232
 
 
2233
            options = axis2_stub_get_options( stub, env);
 
2234
            if (NULL == options)
 
2235
            {
 
2236
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
2237
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
2238
              return;
 
2239
            }
 
2240
            svc_client = axis2_stub_get_svc_client (stub, env);
 
2241
            soap_action =axis2_options_get_action (options, env);
 
2242
            if (NULL == soap_action)
 
2243
            {
 
2244
              is_soap_act_set = AXIS2_FALSE;
 
2245
              soap_action = "EucalyptusNC#ncAttachVolume";
 
2246
              
 
2247
              soap_act = axutil_string_create(env, "EucalyptusNC#ncAttachVolume");
 
2248
              axis2_options_set_soap_action(options, env, soap_act);
 
2249
              
 
2250
              axis2_options_set_action( options, env, soap_action);
 
2251
            }
 
2252
            
 
2253
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
2254
             
 
2255
 
 
2256
            callback = axis2_callback_create(env);
 
2257
            /* Set our on_complete fucntion pointer to the callback object */
 
2258
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncAttachVolume);
 
2259
            /* Set our on_error function pointer to the callback object */
 
2260
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncAttachVolume);
 
2261
 
 
2262
            callback_data-> data = user_data;
 
2263
            callback_data-> on_complete = on_complete;
 
2264
            callback_data-> on_error = on_error;
 
2265
 
 
2266
            axis2_callback_set_data(callback, (void*)callback_data);
 
2267
 
 
2268
            /* Send request */
 
2269
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
2270
            
 
2271
            if (!is_soap_act_set)
 
2272
            {
 
2273
              
 
2274
              axis2_options_set_soap_action(options, env, NULL);
 
2275
              
 
2276
              axis2_options_set_action(options, env, NULL);
 
2277
            }
 
2278
         }
 
2279
 
 
2280
         
 
2281
 
 
2282
        struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data
 
2283
        {   
 
2284
            void *data;
 
2285
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncPowerDownResponse_t* _ncPowerDownResponse, void *data);
 
2286
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
2287
        };
 
2288
 
 
2289
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncPowerDown(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
2290
        {
 
2291
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
2292
            struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data* callback_data = NULL;
 
2293
            void *user_data = NULL;
 
2294
 
 
2295
            axis2_status_t status;
 
2296
        
 
2297
            callback_data = (struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data*)axis2_callback_get_data(callback);
 
2298
        
 
2299
            user_data = callback_data->data;
 
2300
            on_error = callback_data->on_error;
 
2301
        
 
2302
            status = on_error(env, exception, user_data);
 
2303
 
 
2304
            if(callback_data)
 
2305
            {
 
2306
                AXIS2_FREE(env->allocator, callback_data);
 
2307
            }
 
2308
            return status;
 
2309
        } 
 
2310
 
 
2311
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncPowerDown(axis2_callback_t *callback, const axutil_env_t *env)
 
2312
        {
 
2313
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncPowerDownResponse_t* _ncPowerDownResponse, void *data);
 
2314
            struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data* callback_data = NULL;
 
2315
            void *user_data = NULL;
 
2316
            axis2_status_t status = AXIS2_SUCCESS;
 
2317
 
 
2318
            adb_ncPowerDownResponse_t* ret_val = NULL;
 
2319
            
 
2320
 
 
2321
            axiom_node_t *ret_node = NULL;
 
2322
            axiom_soap_envelope_t *soap_envelope = NULL;
 
2323
 
 
2324
            
 
2325
 
 
2326
            callback_data = (struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data*)axis2_callback_get_data(callback);
 
2327
 
 
2328
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
2329
            if(soap_envelope)
 
2330
            {
 
2331
                axiom_soap_body_t *soap_body;
 
2332
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
2333
                if(soap_body)
 
2334
                {
 
2335
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
2336
                    if(body_node)
 
2337
                    {
 
2338
                        ret_node = axiom_node_get_first_child(body_node, env);
 
2339
                    }
 
2340
                }
 
2341
                
 
2342
                
 
2343
            }
 
2344
 
 
2345
            user_data = callback_data->data;
 
2346
            on_complete = callback_data->on_complete;
 
2347
 
 
2348
            
 
2349
                    if(ret_node != NULL)
 
2350
                    {
 
2351
                        ret_val = adb_ncPowerDownResponse_create(env);
 
2352
     
 
2353
                        if(adb_ncPowerDownResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
2354
                        {
 
2355
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
2356
                                                                    "This should be due to an invalid XML");
 
2357
                            adb_ncPowerDownResponse_free(ret_val, env);
 
2358
                            ret_val = NULL;
 
2359
                        }
 
2360
                     }
 
2361
                     else
 
2362
                     {
 
2363
                         ret_val = NULL; 
 
2364
                     }
 
2365
                     status = on_complete(env, ret_val, user_data);
 
2366
                
 
2367
 
 
2368
            if(callback_data)
 
2369
            {
 
2370
                AXIS2_FREE(env->allocator, callback_data);
 
2371
            }
 
2372
            return status;
 
2373
        }
 
2374
 
 
2375
        /**
 
2376
          * auto generated method signature for asynchronous invocations
 
2377
          * for "ncPowerDown|http://eucalyptus.ucsb.edu/" operation.
 
2378
          
 
2379
          *
 
2380
          * @param _ncPowerDown
 
2381
          * @param on_complete callback to handle on complete
 
2382
          * @param on_error callback to handle on error
 
2383
          */
 
2384
         void axis2_stub_start_op_EucalyptusNC_ncPowerDown( axis2_stub_t *stub, const axutil_env_t *env,
 
2385
                                                    adb_ncPowerDown_t* _ncPowerDown,
 
2386
                                                  void *user_data,
 
2387
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncPowerDownResponse_t* _ncPowerDownResponse, void *data) ,
 
2388
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
2389
         {
 
2390
 
 
2391
            axis2_callback_t *callback = NULL;
 
2392
 
 
2393
            axis2_svc_client_t *svc_client = NULL;
 
2394
            axis2_options_t *options = NULL;
 
2395
 
 
2396
            const axis2_char_t *soap_action = NULL;
 
2397
            axiom_node_t *payload = NULL;
 
2398
 
 
2399
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
2400
            
 
2401
            axutil_string_t *soap_act = NULL;
 
2402
            
 
2403
            
 
2404
            struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data *callback_data;
 
2405
 
 
2406
            callback_data = (struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data*) AXIS2_MALLOC(env->allocator, 
 
2407
                                    sizeof(struct axis2_stub_EucalyptusNC_ncPowerDown_callback_data));
 
2408
            if(NULL == callback_data)
 
2409
            {
 
2410
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
2411
                return;
 
2412
            }
 
2413
            
 
2414
            
 
2415
                       payload = adb_ncPowerDown_serialize(_ncPowerDown, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
2416
                   
 
2417
 
 
2418
 
 
2419
 
 
2420
            options = axis2_stub_get_options( stub, env);
 
2421
            if (NULL == options)
 
2422
            {
 
2423
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
2424
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
2425
              return;
 
2426
            }
 
2427
            svc_client = axis2_stub_get_svc_client (stub, env);
 
2428
            soap_action =axis2_options_get_action (options, env);
 
2429
            if (NULL == soap_action)
 
2430
            {
 
2431
              is_soap_act_set = AXIS2_FALSE;
 
2432
              soap_action = "EucalyptusNC#ncPowerDown";
 
2433
              
 
2434
              soap_act = axutil_string_create(env, "EucalyptusNC#ncPowerDown");
 
2435
              axis2_options_set_soap_action(options, env, soap_act);
 
2436
              
 
2437
              axis2_options_set_action( options, env, soap_action);
 
2438
            }
 
2439
            
 
2440
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
2441
             
 
2442
 
 
2443
            callback = axis2_callback_create(env);
 
2444
            /* Set our on_complete fucntion pointer to the callback object */
 
2445
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncPowerDown);
 
2446
            /* Set our on_error function pointer to the callback object */
 
2447
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncPowerDown);
 
2448
 
 
2449
            callback_data-> data = user_data;
 
2450
            callback_data-> on_complete = on_complete;
 
2451
            callback_data-> on_error = on_error;
 
2452
 
 
2453
            axis2_callback_set_data(callback, (void*)callback_data);
 
2454
 
 
2455
            /* Send request */
 
2456
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
2457
            
 
2458
            if (!is_soap_act_set)
 
2459
            {
 
2460
              
 
2461
              axis2_options_set_soap_action(options, env, NULL);
 
2462
              
 
2463
              axis2_options_set_action(options, env, NULL);
 
2464
            }
 
2465
         }
 
2466
 
 
2467
         
 
2468
 
 
2469
        struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data
 
2470
        {   
 
2471
            void *data;
 
2472
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeResourceResponse_t* _ncDescribeResourceResponse, void *data);
 
2473
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
2474
        };
 
2475
 
 
2476
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncDescribeResource(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
2477
        {
 
2478
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
2479
            struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data* callback_data = NULL;
 
2480
            void *user_data = NULL;
 
2481
 
 
2482
            axis2_status_t status;
 
2483
        
 
2484
            callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data*)axis2_callback_get_data(callback);
 
2485
        
 
2486
            user_data = callback_data->data;
 
2487
            on_error = callback_data->on_error;
 
2488
        
 
2489
            status = on_error(env, exception, user_data);
 
2490
 
 
2491
            if(callback_data)
 
2492
            {
 
2493
                AXIS2_FREE(env->allocator, callback_data);
 
2494
            }
 
2495
            return status;
 
2496
        } 
 
2497
 
 
2498
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncDescribeResource(axis2_callback_t *callback, const axutil_env_t *env)
 
2499
        {
 
2500
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeResourceResponse_t* _ncDescribeResourceResponse, void *data);
 
2501
            struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data* callback_data = NULL;
 
2502
            void *user_data = NULL;
 
2503
            axis2_status_t status = AXIS2_SUCCESS;
 
2504
 
 
2505
            adb_ncDescribeResourceResponse_t* ret_val = NULL;
 
2506
            
 
2507
 
 
2508
            axiom_node_t *ret_node = NULL;
 
2509
            axiom_soap_envelope_t *soap_envelope = NULL;
 
2510
 
 
2511
            
 
2512
 
 
2513
            callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data*)axis2_callback_get_data(callback);
 
2514
 
 
2515
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
2516
            if(soap_envelope)
 
2517
            {
 
2518
                axiom_soap_body_t *soap_body;
 
2519
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
2520
                if(soap_body)
 
2521
                {
 
2522
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
2523
                    if(body_node)
 
2524
                    {
 
2525
                        ret_node = axiom_node_get_first_child(body_node, env);
 
2526
                    }
 
2527
                }
 
2528
                
 
2529
                
 
2530
            }
 
2531
 
 
2532
            user_data = callback_data->data;
 
2533
            on_complete = callback_data->on_complete;
 
2534
 
 
2535
            
 
2536
                    if(ret_node != NULL)
 
2537
                    {
 
2538
                        ret_val = adb_ncDescribeResourceResponse_create(env);
 
2539
     
 
2540
                        if(adb_ncDescribeResourceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
2541
                        {
 
2542
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
2543
                                                                    "This should be due to an invalid XML");
 
2544
                            adb_ncDescribeResourceResponse_free(ret_val, env);
 
2545
                            ret_val = NULL;
 
2546
                        }
 
2547
                     }
 
2548
                     else
 
2549
                     {
 
2550
                         ret_val = NULL; 
 
2551
                     }
 
2552
                     status = on_complete(env, ret_val, user_data);
 
2553
                
 
2554
 
 
2555
            if(callback_data)
 
2556
            {
 
2557
                AXIS2_FREE(env->allocator, callback_data);
 
2558
            }
 
2559
            return status;
 
2560
        }
 
2561
 
 
2562
        /**
 
2563
          * auto generated method signature for asynchronous invocations
 
2564
          * for "ncDescribeResource|http://eucalyptus.ucsb.edu/" operation.
 
2565
          
 
2566
          *
 
2567
          * @param _ncDescribeResource
 
2568
          * @param on_complete callback to handle on complete
 
2569
          * @param on_error callback to handle on error
 
2570
          */
 
2571
         void axis2_stub_start_op_EucalyptusNC_ncDescribeResource( axis2_stub_t *stub, const axutil_env_t *env,
 
2572
                                                    adb_ncDescribeResource_t* _ncDescribeResource,
 
2573
                                                  void *user_data,
 
2574
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncDescribeResourceResponse_t* _ncDescribeResourceResponse, void *data) ,
 
2575
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
2576
         {
 
2577
 
 
2578
            axis2_callback_t *callback = NULL;
 
2579
 
 
2580
            axis2_svc_client_t *svc_client = NULL;
 
2581
            axis2_options_t *options = NULL;
 
2582
 
 
2583
            const axis2_char_t *soap_action = NULL;
 
2584
            axiom_node_t *payload = NULL;
 
2585
 
 
2586
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
2587
            
 
2588
            axutil_string_t *soap_act = NULL;
 
2589
            
 
2590
            
 
2591
            struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data *callback_data;
 
2592
 
 
2593
            callback_data = (struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data*) AXIS2_MALLOC(env->allocator, 
 
2594
                                    sizeof(struct axis2_stub_EucalyptusNC_ncDescribeResource_callback_data));
 
2595
            if(NULL == callback_data)
 
2596
            {
 
2597
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
2598
                return;
 
2599
            }
 
2600
            
 
2601
            
 
2602
                       payload = adb_ncDescribeResource_serialize(_ncDescribeResource, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
2603
                   
 
2604
 
 
2605
 
 
2606
 
 
2607
            options = axis2_stub_get_options( stub, env);
 
2608
            if (NULL == options)
 
2609
            {
 
2610
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
2611
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
2612
              return;
 
2613
            }
 
2614
            svc_client = axis2_stub_get_svc_client (stub, env);
 
2615
            soap_action =axis2_options_get_action (options, env);
 
2616
            if (NULL == soap_action)
 
2617
            {
 
2618
              is_soap_act_set = AXIS2_FALSE;
 
2619
              soap_action = "EucalyptusNC#ncDescribeResource";
 
2620
              
 
2621
              soap_act = axutil_string_create(env, "EucalyptusNC#ncDescribeResource");
 
2622
              axis2_options_set_soap_action(options, env, soap_act);
 
2623
              
 
2624
              axis2_options_set_action( options, env, soap_action);
 
2625
            }
 
2626
            
 
2627
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
2628
             
 
2629
 
 
2630
            callback = axis2_callback_create(env);
 
2631
            /* Set our on_complete fucntion pointer to the callback object */
 
2632
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncDescribeResource);
 
2633
            /* Set our on_error function pointer to the callback object */
 
2634
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncDescribeResource);
 
2635
 
 
2636
            callback_data-> data = user_data;
 
2637
            callback_data-> on_complete = on_complete;
 
2638
            callback_data-> on_error = on_error;
 
2639
 
 
2640
            axis2_callback_set_data(callback, (void*)callback_data);
 
2641
 
 
2642
            /* Send request */
 
2643
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
2644
            
 
2645
            if (!is_soap_act_set)
 
2646
            {
 
2647
              
 
2648
              axis2_options_set_soap_action(options, env, NULL);
 
2649
              
 
2650
              axis2_options_set_action(options, env, NULL);
 
2651
            }
 
2652
         }
 
2653
 
 
2654
         
 
2655
 
 
2656
        struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data
 
2657
        {   
 
2658
            void *data;
 
2659
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncTerminateInstanceResponse_t* _ncTerminateInstanceResponse, void *data);
 
2660
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
2661
        };
 
2662
 
 
2663
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncTerminateInstance(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
2664
        {
 
2665
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
2666
            struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data* callback_data = NULL;
 
2667
            void *user_data = NULL;
 
2668
 
 
2669
            axis2_status_t status;
 
2670
        
 
2671
            callback_data = (struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data*)axis2_callback_get_data(callback);
 
2672
        
 
2673
            user_data = callback_data->data;
 
2674
            on_error = callback_data->on_error;
 
2675
        
 
2676
            status = on_error(env, exception, user_data);
 
2677
 
 
2678
            if(callback_data)
 
2679
            {
 
2680
                AXIS2_FREE(env->allocator, callback_data);
 
2681
            }
 
2682
            return status;
 
2683
        } 
 
2684
 
 
2685
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncTerminateInstance(axis2_callback_t *callback, const axutil_env_t *env)
 
2686
        {
 
2687
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncTerminateInstanceResponse_t* _ncTerminateInstanceResponse, void *data);
 
2688
            struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data* callback_data = NULL;
 
2689
            void *user_data = NULL;
 
2690
            axis2_status_t status = AXIS2_SUCCESS;
 
2691
 
 
2692
            adb_ncTerminateInstanceResponse_t* ret_val = NULL;
 
2693
            
 
2694
 
 
2695
            axiom_node_t *ret_node = NULL;
 
2696
            axiom_soap_envelope_t *soap_envelope = NULL;
 
2697
 
 
2698
            
 
2699
 
 
2700
            callback_data = (struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data*)axis2_callback_get_data(callback);
 
2701
 
 
2702
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
2703
            if(soap_envelope)
 
2704
            {
 
2705
                axiom_soap_body_t *soap_body;
 
2706
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
2707
                if(soap_body)
 
2708
                {
 
2709
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
2710
                    if(body_node)
 
2711
                    {
 
2712
                        ret_node = axiom_node_get_first_child(body_node, env);
 
2713
                    }
 
2714
                }
 
2715
                
 
2716
                
 
2717
            }
 
2718
 
 
2719
            user_data = callback_data->data;
 
2720
            on_complete = callback_data->on_complete;
 
2721
 
 
2722
            
 
2723
                    if(ret_node != NULL)
 
2724
                    {
 
2725
                        ret_val = adb_ncTerminateInstanceResponse_create(env);
 
2726
     
 
2727
                        if(adb_ncTerminateInstanceResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
2728
                        {
 
2729
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
2730
                                                                    "This should be due to an invalid XML");
 
2731
                            adb_ncTerminateInstanceResponse_free(ret_val, env);
 
2732
                            ret_val = NULL;
 
2733
                        }
 
2734
                     }
 
2735
                     else
 
2736
                     {
 
2737
                         ret_val = NULL; 
 
2738
                     }
 
2739
                     status = on_complete(env, ret_val, user_data);
 
2740
                
 
2741
 
 
2742
            if(callback_data)
 
2743
            {
 
2744
                AXIS2_FREE(env->allocator, callback_data);
 
2745
            }
 
2746
            return status;
 
2747
        }
 
2748
 
 
2749
        /**
 
2750
          * auto generated method signature for asynchronous invocations
 
2751
          * for "ncTerminateInstance|http://eucalyptus.ucsb.edu/" operation.
 
2752
          
 
2753
          *
 
2754
          * @param _ncTerminateInstance
 
2755
          * @param on_complete callback to handle on complete
 
2756
          * @param on_error callback to handle on error
 
2757
          */
 
2758
         void axis2_stub_start_op_EucalyptusNC_ncTerminateInstance( axis2_stub_t *stub, const axutil_env_t *env,
 
2759
                                                    adb_ncTerminateInstance_t* _ncTerminateInstance,
 
2760
                                                  void *user_data,
 
2761
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncTerminateInstanceResponse_t* _ncTerminateInstanceResponse, void *data) ,
 
2762
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
2763
         {
 
2764
 
 
2765
            axis2_callback_t *callback = NULL;
 
2766
 
 
2767
            axis2_svc_client_t *svc_client = NULL;
 
2768
            axis2_options_t *options = NULL;
 
2769
 
 
2770
            const axis2_char_t *soap_action = NULL;
 
2771
            axiom_node_t *payload = NULL;
 
2772
 
 
2773
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
2774
            
 
2775
            axutil_string_t *soap_act = NULL;
 
2776
            
 
2777
            
 
2778
            struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data *callback_data;
 
2779
 
 
2780
            callback_data = (struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data*) AXIS2_MALLOC(env->allocator, 
 
2781
                                    sizeof(struct axis2_stub_EucalyptusNC_ncTerminateInstance_callback_data));
 
2782
            if(NULL == callback_data)
 
2783
            {
 
2784
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
2785
                return;
 
2786
            }
 
2787
            
 
2788
            
 
2789
                       payload = adb_ncTerminateInstance_serialize(_ncTerminateInstance, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
2790
                   
 
2791
 
 
2792
 
 
2793
 
 
2794
            options = axis2_stub_get_options( stub, env);
 
2795
            if (NULL == options)
 
2796
            {
 
2797
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
2798
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
2799
              return;
 
2800
            }
 
2801
            svc_client = axis2_stub_get_svc_client (stub, env);
 
2802
            soap_action =axis2_options_get_action (options, env);
 
2803
            if (NULL == soap_action)
 
2804
            {
 
2805
              is_soap_act_set = AXIS2_FALSE;
 
2806
              soap_action = "EucalyptusNC#ncTerminateInstance";
 
2807
              
 
2808
              soap_act = axutil_string_create(env, "EucalyptusNC#ncTerminateInstance");
 
2809
              axis2_options_set_soap_action(options, env, soap_act);
 
2810
              
 
2811
              axis2_options_set_action( options, env, soap_action);
 
2812
            }
 
2813
            
 
2814
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
2815
             
 
2816
 
 
2817
            callback = axis2_callback_create(env);
 
2818
            /* Set our on_complete fucntion pointer to the callback object */
 
2819
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncTerminateInstance);
 
2820
            /* Set our on_error function pointer to the callback object */
 
2821
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncTerminateInstance);
 
2822
 
 
2823
            callback_data-> data = user_data;
 
2824
            callback_data-> on_complete = on_complete;
 
2825
            callback_data-> on_error = on_error;
 
2826
 
 
2827
            axis2_callback_set_data(callback, (void*)callback_data);
 
2828
 
 
2829
            /* Send request */
 
2830
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
2831
            
 
2832
            if (!is_soap_act_set)
 
2833
            {
 
2834
              
 
2835
              axis2_options_set_soap_action(options, env, NULL);
 
2836
              
 
2837
              axis2_options_set_action(options, env, NULL);
 
2838
            }
 
2839
         }
 
2840
 
 
2841
         
 
2842
 
 
2843
        struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data
 
2844
        {   
 
2845
            void *data;
 
2846
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncStartNetworkResponse_t* _ncStartNetworkResponse, void *data);
 
2847
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
2848
        };
 
2849
 
 
2850
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusNC_ncStartNetwork(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
2851
        {
 
2852
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
2853
            struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data* callback_data = NULL;
 
2854
            void *user_data = NULL;
 
2855
 
 
2856
            axis2_status_t status;
 
2857
        
 
2858
            callback_data = (struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data*)axis2_callback_get_data(callback);
 
2859
        
 
2860
            user_data = callback_data->data;
 
2861
            on_error = callback_data->on_error;
 
2862
        
 
2863
            status = on_error(env, exception, user_data);
 
2864
 
 
2865
            if(callback_data)
 
2866
            {
 
2867
                AXIS2_FREE(env->allocator, callback_data);
 
2868
            }
 
2869
            return status;
 
2870
        } 
 
2871
 
 
2872
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusNC_ncStartNetwork(axis2_callback_t *callback, const axutil_env_t *env)
 
2873
        {
 
2874
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncStartNetworkResponse_t* _ncStartNetworkResponse, void *data);
 
2875
            struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data* callback_data = NULL;
 
2876
            void *user_data = NULL;
 
2877
            axis2_status_t status = AXIS2_SUCCESS;
 
2878
 
 
2879
            adb_ncStartNetworkResponse_t* ret_val = NULL;
 
2880
            
 
2881
 
 
2882
            axiom_node_t *ret_node = NULL;
 
2883
            axiom_soap_envelope_t *soap_envelope = NULL;
 
2884
 
 
2885
            
 
2886
 
 
2887
            callback_data = (struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data*)axis2_callback_get_data(callback);
 
2888
 
 
2889
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
2890
            if(soap_envelope)
 
2891
            {
 
2892
                axiom_soap_body_t *soap_body;
 
2893
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
2894
                if(soap_body)
 
2895
                {
 
2896
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
2897
                    if(body_node)
 
2898
                    {
 
2899
                        ret_node = axiom_node_get_first_child(body_node, env);
 
2900
                    }
 
2901
                }
 
2902
                
 
2903
                
 
2904
            }
 
2905
 
 
2906
            user_data = callback_data->data;
 
2907
            on_complete = callback_data->on_complete;
 
2908
 
 
2909
            
 
2910
                    if(ret_node != NULL)
 
2911
                    {
 
2912
                        ret_val = adb_ncStartNetworkResponse_create(env);
 
2913
     
 
2914
                        if(adb_ncStartNetworkResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
2915
                        {
 
2916
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
2917
                                                                    "This should be due to an invalid XML");
 
2918
                            adb_ncStartNetworkResponse_free(ret_val, env);
 
2919
                            ret_val = NULL;
 
2920
                        }
 
2921
                     }
 
2922
                     else
 
2923
                     {
 
2924
                         ret_val = NULL; 
 
2925
                     }
 
2926
                     status = on_complete(env, ret_val, user_data);
 
2927
                
 
2928
 
 
2929
            if(callback_data)
 
2930
            {
 
2931
                AXIS2_FREE(env->allocator, callback_data);
 
2932
            }
 
2933
            return status;
 
2934
        }
 
2935
 
 
2936
        /**
 
2937
          * auto generated method signature for asynchronous invocations
 
2938
          * for "ncStartNetwork|http://eucalyptus.ucsb.edu/" operation.
 
2939
          
 
2940
          *
 
2941
          * @param _ncStartNetwork
 
2942
          * @param on_complete callback to handle on complete
 
2943
          * @param on_error callback to handle on error
 
2944
          */
 
2945
         void axis2_stub_start_op_EucalyptusNC_ncStartNetwork( axis2_stub_t *stub, const axutil_env_t *env,
 
2946
                                                    adb_ncStartNetwork_t* _ncStartNetwork,
 
2947
                                                  void *user_data,
 
2948
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_ncStartNetworkResponse_t* _ncStartNetworkResponse, void *data) ,
 
2949
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
2950
         {
 
2951
 
 
2952
            axis2_callback_t *callback = NULL;
 
2953
 
 
2954
            axis2_svc_client_t *svc_client = NULL;
 
2955
            axis2_options_t *options = NULL;
 
2956
 
 
2957
            const axis2_char_t *soap_action = NULL;
 
2958
            axiom_node_t *payload = NULL;
 
2959
 
 
2960
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
2961
            
 
2962
            axutil_string_t *soap_act = NULL;
 
2963
            
 
2964
            
 
2965
            struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data *callback_data;
 
2966
 
 
2967
            callback_data = (struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data*) AXIS2_MALLOC(env->allocator, 
 
2968
                                    sizeof(struct axis2_stub_EucalyptusNC_ncStartNetwork_callback_data));
 
2969
            if(NULL == callback_data)
 
2970
            {
 
2971
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
2972
                return;
 
2973
            }
 
2974
            
 
2975
            
 
2976
                       payload = adb_ncStartNetwork_serialize(_ncStartNetwork, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
2977
                   
 
2978
 
 
2979
 
 
2980
 
 
2981
            options = axis2_stub_get_options( stub, env);
 
2982
            if (NULL == options)
 
2983
            {
 
2984
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
2985
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
2986
              return;
 
2987
            }
 
2988
            svc_client = axis2_stub_get_svc_client (stub, env);
 
2989
            soap_action =axis2_options_get_action (options, env);
 
2990
            if (NULL == soap_action)
 
2991
            {
 
2992
              is_soap_act_set = AXIS2_FALSE;
 
2993
              soap_action = "EucalyptusNC#ncStartNetwork";
 
2994
              
 
2995
              soap_act = axutil_string_create(env, "EucalyptusNC#ncStartNetwork");
 
2996
              axis2_options_set_soap_action(options, env, soap_act);
 
2997
              
 
2998
              axis2_options_set_action( options, env, soap_action);
 
2999
            }
 
3000
            
 
3001
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
3002
             
 
3003
 
 
3004
            callback = axis2_callback_create(env);
 
3005
            /* Set our on_complete fucntion pointer to the callback object */
 
3006
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusNC_ncStartNetwork);
 
3007
            /* Set our on_error function pointer to the callback object */
 
3008
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusNC_ncStartNetwork);
 
3009
 
 
3010
            callback_data-> data = user_data;
 
3011
            callback_data-> on_complete = on_complete;
 
3012
            callback_data-> on_error = on_error;
 
3013
 
 
3014
            axis2_callback_set_data(callback, (void*)callback_data);
 
3015
 
 
3016
            /* Send request */
 
3017
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
3018
            
 
3019
            if (!is_soap_act_set)
 
3020
            {
 
3021
              
 
3022
              axis2_options_set_soap_action(options, env, NULL);
 
3023
              
 
3024
              axis2_options_set_action(options, env, NULL);
 
3025
            }
 
3026
         }
 
3027
 
 
3028
            
 
3029
 
 
3030
 
 
3031
     /**
 
3032
      * function to free any soap input headers 
 
3033
      */
 
3034
     
 
3035
 
 
3036
 
 
3037
     /**
 
3038
      * function to free any soap output headers 
 
3039
      */
 
3040
     
 
3041