← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gatherlog/generated/axis2_stub_EucalyptusGL.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:
gatherlog/generated/axis2_stub_EucalyptusGL.c
 
1
 
 
2
 
 
3
      /**
 
4
       * axis2_stub_EucalyptusGL.c
 
5
       *
 
6
       * This file was auto-generated from WSDL for "EucalyptusGL|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_EucalyptusGL.h"
 
11
      #include <axis2_msg.h>
 
12
 
 
13
      /**
 
14
       * axis2_stub_EucalyptusGL C implementation
 
15
       */
 
16
 
 
17
      axis2_stub_t*
 
18
      axis2_stub_create_EucalyptusGL(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_EucalyptusGL(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_EucalyptusGL(stub, env);
 
46
         return stub;
 
47
      }
 
48
 
 
49
 
 
50
      void
 
51
      axis2_stub_populate_services_for_EucalyptusGL(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,"EucalyptusGL" ,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
                                         "GetLogs" ,
 
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
                                         "GetKeys" ,
 
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
      }
 
122
 
 
123
      /**
 
124
       *return end point picked from wsdl
 
125
       */
 
126
      axis2_char_t*
 
127
      axis2_stub_get_endpoint_uri_of_EucalyptusGL( const axutil_env_t *env )
 
128
      {
 
129
        axis2_char_t *endpoint_uri = NULL;
 
130
        /* set the address from here */
 
131
        
 
132
              endpoint_uri = "http://cc:9090/axis2/services/EucalyptusGL";
 
133
            
 
134
        return endpoint_uri;
 
135
      }
 
136
 
 
137
 
 
138
  
 
139
         /**
 
140
          * auto generated method signature
 
141
          * for "GetLogs|http://eucalyptus.ucsb.edu/" operation.
 
142
          *
 
143
          * @param _getLogs
 
144
          *
 
145
          * @return adb_GetLogsResponse_t*
 
146
          */
 
147
         adb_GetLogsResponse_t* 
 
148
         axis2_stub_op_EucalyptusGL_GetLogs( axis2_stub_t *stub, const axutil_env_t *env,
 
149
                                              adb_GetLogs_t* _getLogs)
 
150
         {
 
151
            axis2_svc_client_t *svc_client = NULL;
 
152
            axis2_options_t *options = NULL;
 
153
            axiom_node_t *ret_node = NULL;
 
154
 
 
155
            const axis2_char_t *soap_action = NULL;
 
156
            axutil_qname_t *op_qname =  NULL;
 
157
            axiom_node_t *payload = NULL;
 
158
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
159
            
 
160
            axutil_string_t *soap_act = NULL;
 
161
            adb_GetLogsResponse_t* ret_val = NULL;
 
162
            
 
163
                       payload = adb_GetLogs_serialize(_getLogs, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
164
                   
 
165
            svc_client = axis2_stub_get_svc_client(stub, env );
 
166
            
 
167
           
 
168
            
 
169
            
 
170
 
 
171
            options = axis2_stub_get_options( stub, env);
 
172
            if (NULL == options)
 
173
            {
 
174
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
175
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
176
                return NULL;
 
177
            }
 
178
            soap_action = axis2_options_get_action( options, env );
 
179
            if (NULL == soap_action)
 
180
            {
 
181
              is_soap_act_set = AXIS2_FALSE;
 
182
              soap_action = "EucalyptusGL#GetLogs";
 
183
              
 
184
              soap_act = axutil_string_create(env, "EucalyptusGL#GetLogs");
 
185
              axis2_options_set_soap_action(options, env, soap_act);    
 
186
              
 
187
              axis2_options_set_action( options, env, soap_action );
 
188
            }
 
189
            
 
190
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
191
            
 
192
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
193
 
 
194
            if (!is_soap_act_set)
 
195
            {
 
196
              
 
197
              axis2_options_set_soap_action(options, env, NULL);    
 
198
              
 
199
              axis2_options_set_action( options, env, NULL);
 
200
            }
 
201
 
 
202
            
 
203
            
 
204
                    if ( NULL == ret_node )
 
205
                    {
 
206
                        return NULL;
 
207
                    }
 
208
                    ret_val = adb_GetLogsResponse_create(env);
 
209
 
 
210
                    if(adb_GetLogsResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
211
                    {
 
212
                        if(ret_val != NULL)
 
213
                        {
 
214
                            adb_GetLogsResponse_free(ret_val, env);
 
215
                        }
 
216
 
 
217
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the GetLogsResponse_deserialize: "
 
218
                                                                "This should be due to an invalid XML");
 
219
                        return NULL;
 
220
                    }
 
221
                    return ret_val;
 
222
                
 
223
        }
 
224
        
 
225
         /**
 
226
          * auto generated method signature
 
227
          * for "GetKeys|http://eucalyptus.ucsb.edu/" operation.
 
228
          *
 
229
          * @param _getKeys
 
230
          *
 
231
          * @return adb_GetKeysResponse_t*
 
232
          */
 
233
         adb_GetKeysResponse_t* 
 
234
         axis2_stub_op_EucalyptusGL_GetKeys( axis2_stub_t *stub, const axutil_env_t *env,
 
235
                                              adb_GetKeys_t* _getKeys)
 
236
         {
 
237
            axis2_svc_client_t *svc_client = NULL;
 
238
            axis2_options_t *options = NULL;
 
239
            axiom_node_t *ret_node = NULL;
 
240
 
 
241
            const axis2_char_t *soap_action = NULL;
 
242
            axutil_qname_t *op_qname =  NULL;
 
243
            axiom_node_t *payload = NULL;
 
244
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
245
            
 
246
            axutil_string_t *soap_act = NULL;
 
247
            adb_GetKeysResponse_t* ret_val = NULL;
 
248
            
 
249
                       payload = adb_GetKeys_serialize(_getKeys, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
250
                   
 
251
            svc_client = axis2_stub_get_svc_client(stub, env );
 
252
            
 
253
           
 
254
            
 
255
            
 
256
 
 
257
            options = axis2_stub_get_options( stub, env);
 
258
            if (NULL == options)
 
259
            {
 
260
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
261
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub");
 
262
                return NULL;
 
263
            }
 
264
            soap_action = axis2_options_get_action( options, env );
 
265
            if (NULL == soap_action)
 
266
            {
 
267
              is_soap_act_set = AXIS2_FALSE;
 
268
              soap_action = "EucalyptusGL#GetKeys";
 
269
              
 
270
              soap_act = axutil_string_create(env, "EucalyptusGL#GetKeys");
 
271
              axis2_options_set_soap_action(options, env, soap_act);    
 
272
              
 
273
              axis2_options_set_action( options, env, soap_action );
 
274
            }
 
275
            
 
276
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11 );
 
277
            
 
278
            ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload);
 
279
 
 
280
            if (!is_soap_act_set)
 
281
            {
 
282
              
 
283
              axis2_options_set_soap_action(options, env, NULL);    
 
284
              
 
285
              axis2_options_set_action( options, env, NULL);
 
286
            }
 
287
 
 
288
            
 
289
            
 
290
                    if ( NULL == ret_node )
 
291
                    {
 
292
                        return NULL;
 
293
                    }
 
294
                    ret_val = adb_GetKeysResponse_create(env);
 
295
 
 
296
                    if(adb_GetKeysResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
297
                    {
 
298
                        if(ret_val != NULL)
 
299
                        {
 
300
                            adb_GetKeysResponse_free(ret_val, env);
 
301
                        }
 
302
 
 
303
                        AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the GetKeysResponse_deserialize: "
 
304
                                                                "This should be due to an invalid XML");
 
305
                        return NULL;
 
306
                    }
 
307
                    return ret_val;
 
308
                
 
309
        }
 
310
        
 
311
 
 
312
        struct axis2_stub_EucalyptusGL_GetLogs_callback_data
 
313
        {   
 
314
            void *data;
 
315
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetLogsResponse_t* _getLogsResponse, void *data);
 
316
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
317
        };
 
318
 
 
319
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusGL_GetLogs(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
320
        {
 
321
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
322
            struct axis2_stub_EucalyptusGL_GetLogs_callback_data* callback_data = NULL;
 
323
            void *user_data = NULL;
 
324
 
 
325
            axis2_status_t status;
 
326
        
 
327
            callback_data = (struct axis2_stub_EucalyptusGL_GetLogs_callback_data*)axis2_callback_get_data(callback);
 
328
        
 
329
            user_data = callback_data->data;
 
330
            on_error = callback_data->on_error;
 
331
        
 
332
            status = on_error(env, exception, user_data);
 
333
 
 
334
            if(callback_data)
 
335
            {
 
336
                AXIS2_FREE(env->allocator, callback_data);
 
337
            }
 
338
            return status;
 
339
        } 
 
340
 
 
341
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusGL_GetLogs(axis2_callback_t *callback, const axutil_env_t *env)
 
342
        {
 
343
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetLogsResponse_t* _getLogsResponse, void *data);
 
344
            struct axis2_stub_EucalyptusGL_GetLogs_callback_data* callback_data = NULL;
 
345
            void *user_data = NULL;
 
346
            axis2_status_t status = AXIS2_SUCCESS;
 
347
 
 
348
            adb_GetLogsResponse_t* ret_val = NULL;
 
349
            
 
350
 
 
351
            axiom_node_t *ret_node = NULL;
 
352
            axiom_soap_envelope_t *soap_envelope = NULL;
 
353
 
 
354
            
 
355
 
 
356
            callback_data = (struct axis2_stub_EucalyptusGL_GetLogs_callback_data*)axis2_callback_get_data(callback);
 
357
 
 
358
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
359
            if(soap_envelope)
 
360
            {
 
361
                axiom_soap_body_t *soap_body;
 
362
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
363
                if(soap_body)
 
364
                {
 
365
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
366
                    if(body_node)
 
367
                    {
 
368
                        ret_node = axiom_node_get_first_child(body_node, env);
 
369
                    }
 
370
                }
 
371
                
 
372
                
 
373
            }
 
374
 
 
375
            user_data = callback_data->data;
 
376
            on_complete = callback_data->on_complete;
 
377
 
 
378
            
 
379
                    if(ret_node != NULL)
 
380
                    {
 
381
                        ret_val = adb_GetLogsResponse_create(env);
 
382
     
 
383
                        if(adb_GetLogsResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
384
                        {
 
385
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
386
                                                                    "This should be due to an invalid XML");
 
387
                            adb_GetLogsResponse_free(ret_val, env);
 
388
                            ret_val = NULL;
 
389
                        }
 
390
                     }
 
391
                     else
 
392
                     {
 
393
                         ret_val = NULL; 
 
394
                     }
 
395
                     status = on_complete(env, ret_val, user_data);
 
396
                
 
397
 
 
398
            if(callback_data)
 
399
            {
 
400
                AXIS2_FREE(env->allocator, callback_data);
 
401
            }
 
402
            return status;
 
403
        }
 
404
 
 
405
        /**
 
406
          * auto generated method signature for asynchronous invocations
 
407
          * for "GetLogs|http://eucalyptus.ucsb.edu/" operation.
 
408
          
 
409
          *
 
410
          * @param _getLogs
 
411
          * @param on_complete callback to handle on complete
 
412
          * @param on_error callback to handle on error
 
413
          */
 
414
         void axis2_stub_start_op_EucalyptusGL_GetLogs( axis2_stub_t *stub, const axutil_env_t *env,
 
415
                                                    adb_GetLogs_t* _getLogs,
 
416
                                                  void *user_data,
 
417
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetLogsResponse_t* _getLogsResponse, void *data) ,
 
418
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
419
         {
 
420
 
 
421
            axis2_callback_t *callback = NULL;
 
422
 
 
423
            axis2_svc_client_t *svc_client = NULL;
 
424
            axis2_options_t *options = NULL;
 
425
 
 
426
            const axis2_char_t *soap_action = NULL;
 
427
            axiom_node_t *payload = NULL;
 
428
 
 
429
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
430
            
 
431
            axutil_string_t *soap_act = NULL;
 
432
            
 
433
            
 
434
            struct axis2_stub_EucalyptusGL_GetLogs_callback_data *callback_data;
 
435
 
 
436
            callback_data = (struct axis2_stub_EucalyptusGL_GetLogs_callback_data*) AXIS2_MALLOC(env->allocator, 
 
437
                                    sizeof(struct axis2_stub_EucalyptusGL_GetLogs_callback_data));
 
438
            if(NULL == callback_data)
 
439
            {
 
440
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
441
                return;
 
442
            }
 
443
            
 
444
            
 
445
                       payload = adb_GetLogs_serialize(_getLogs, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
446
                   
 
447
 
 
448
 
 
449
 
 
450
            options = axis2_stub_get_options( stub, env);
 
451
            if (NULL == options)
 
452
            {
 
453
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
454
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
455
              return;
 
456
            }
 
457
            svc_client = axis2_stub_get_svc_client (stub, env);
 
458
            soap_action =axis2_options_get_action (options, env);
 
459
            if (NULL == soap_action)
 
460
            {
 
461
              is_soap_act_set = AXIS2_FALSE;
 
462
              soap_action = "EucalyptusGL#GetLogs";
 
463
              
 
464
              soap_act = axutil_string_create(env, "EucalyptusGL#GetLogs");
 
465
              axis2_options_set_soap_action(options, env, soap_act);
 
466
              
 
467
              axis2_options_set_action( options, env, soap_action);
 
468
            }
 
469
            
 
470
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
471
             
 
472
 
 
473
            callback = axis2_callback_create(env);
 
474
            /* Set our on_complete fucntion pointer to the callback object */
 
475
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusGL_GetLogs);
 
476
            /* Set our on_error function pointer to the callback object */
 
477
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusGL_GetLogs);
 
478
 
 
479
            callback_data-> data = user_data;
 
480
            callback_data-> on_complete = on_complete;
 
481
            callback_data-> on_error = on_error;
 
482
 
 
483
            axis2_callback_set_data(callback, (void*)callback_data);
 
484
 
 
485
            /* Send request */
 
486
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
487
            
 
488
            if (!is_soap_act_set)
 
489
            {
 
490
              
 
491
              axis2_options_set_soap_action(options, env, NULL);
 
492
              
 
493
              axis2_options_set_action(options, env, NULL);
 
494
            }
 
495
         }
 
496
 
 
497
         
 
498
 
 
499
        struct axis2_stub_EucalyptusGL_GetKeys_callback_data
 
500
        {   
 
501
            void *data;
 
502
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetKeysResponse_t* _getKeysResponse, void *data);
 
503
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data);
 
504
        };
 
505
 
 
506
        static axis2_status_t AXIS2_CALL axis2_stub_on_error_EucalyptusGL_GetKeys(axis2_callback_t *callback, const axutil_env_t *env, int exception)
 
507
        {
 
508
            axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int, void *data);
 
509
            struct axis2_stub_EucalyptusGL_GetKeys_callback_data* callback_data = NULL;
 
510
            void *user_data = NULL;
 
511
 
 
512
            axis2_status_t status;
 
513
        
 
514
            callback_data = (struct axis2_stub_EucalyptusGL_GetKeys_callback_data*)axis2_callback_get_data(callback);
 
515
        
 
516
            user_data = callback_data->data;
 
517
            on_error = callback_data->on_error;
 
518
        
 
519
            status = on_error(env, exception, user_data);
 
520
 
 
521
            if(callback_data)
 
522
            {
 
523
                AXIS2_FREE(env->allocator, callback_data);
 
524
            }
 
525
            return status;
 
526
        } 
 
527
 
 
528
        axis2_status_t AXIS2_CALL axis2_stub_on_complete_EucalyptusGL_GetKeys(axis2_callback_t *callback, const axutil_env_t *env)
 
529
        {
 
530
            axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetKeysResponse_t* _getKeysResponse, void *data);
 
531
            struct axis2_stub_EucalyptusGL_GetKeys_callback_data* callback_data = NULL;
 
532
            void *user_data = NULL;
 
533
            axis2_status_t status = AXIS2_SUCCESS;
 
534
 
 
535
            adb_GetKeysResponse_t* ret_val = NULL;
 
536
            
 
537
 
 
538
            axiom_node_t *ret_node = NULL;
 
539
            axiom_soap_envelope_t *soap_envelope = NULL;
 
540
 
 
541
            
 
542
 
 
543
            callback_data = (struct axis2_stub_EucalyptusGL_GetKeys_callback_data*)axis2_callback_get_data(callback);
 
544
 
 
545
            soap_envelope = axis2_callback_get_envelope(callback, env);
 
546
            if(soap_envelope)
 
547
            {
 
548
                axiom_soap_body_t *soap_body;
 
549
                soap_body = axiom_soap_envelope_get_body(soap_envelope, env);
 
550
                if(soap_body)
 
551
                {
 
552
                    axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env);
 
553
                    if(body_node)
 
554
                    {
 
555
                        ret_node = axiom_node_get_first_child(body_node, env);
 
556
                    }
 
557
                }
 
558
                
 
559
                
 
560
            }
 
561
 
 
562
            user_data = callback_data->data;
 
563
            on_complete = callback_data->on_complete;
 
564
 
 
565
            
 
566
                    if(ret_node != NULL)
 
567
                    {
 
568
                        ret_val = adb_GetKeysResponse_create(env);
 
569
     
 
570
                        if(adb_GetKeysResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 
571
                        {
 
572
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the LendResponse_deserialize: "
 
573
                                                                    "This should be due to an invalid XML");
 
574
                            adb_GetKeysResponse_free(ret_val, env);
 
575
                            ret_val = NULL;
 
576
                        }
 
577
                     }
 
578
                     else
 
579
                     {
 
580
                         ret_val = NULL; 
 
581
                     }
 
582
                     status = on_complete(env, ret_val, user_data);
 
583
                
 
584
 
 
585
            if(callback_data)
 
586
            {
 
587
                AXIS2_FREE(env->allocator, callback_data);
 
588
            }
 
589
            return status;
 
590
        }
 
591
 
 
592
        /**
 
593
          * auto generated method signature for asynchronous invocations
 
594
          * for "GetKeys|http://eucalyptus.ucsb.edu/" operation.
 
595
          
 
596
          *
 
597
          * @param _getKeys
 
598
          * @param on_complete callback to handle on complete
 
599
          * @param on_error callback to handle on error
 
600
          */
 
601
         void axis2_stub_start_op_EucalyptusGL_GetKeys( axis2_stub_t *stub, const axutil_env_t *env,
 
602
                                                    adb_GetKeys_t* _getKeys,
 
603
                                                  void *user_data,
 
604
                                                  axis2_status_t ( AXIS2_CALL *on_complete ) (const axutil_env_t *, adb_GetKeysResponse_t* _getKeysResponse, void *data) ,
 
605
                                                  axis2_status_t ( AXIS2_CALL *on_error ) (const axutil_env_t *, int exception, void *data) )
 
606
         {
 
607
 
 
608
            axis2_callback_t *callback = NULL;
 
609
 
 
610
            axis2_svc_client_t *svc_client = NULL;
 
611
            axis2_options_t *options = NULL;
 
612
 
 
613
            const axis2_char_t *soap_action = NULL;
 
614
            axiom_node_t *payload = NULL;
 
615
 
 
616
            axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 
617
            
 
618
            axutil_string_t *soap_act = NULL;
 
619
            
 
620
            
 
621
            struct axis2_stub_EucalyptusGL_GetKeys_callback_data *callback_data;
 
622
 
 
623
            callback_data = (struct axis2_stub_EucalyptusGL_GetKeys_callback_data*) AXIS2_MALLOC(env->allocator, 
 
624
                                    sizeof(struct axis2_stub_EucalyptusGL_GetKeys_callback_data));
 
625
            if(NULL == callback_data)
 
626
            {
 
627
                AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "Can not allocate memeory for the callback data structures");
 
628
                return;
 
629
            }
 
630
            
 
631
            
 
632
                       payload = adb_GetKeys_serialize(_getKeys, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
633
                   
 
634
 
 
635
 
 
636
 
 
637
            options = axis2_stub_get_options( stub, env);
 
638
            if (NULL == options)
 
639
            {
 
640
              AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 
641
              AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "options is null in stub");
 
642
              return;
 
643
            }
 
644
            svc_client = axis2_stub_get_svc_client (stub, env);
 
645
            soap_action =axis2_options_get_action (options, env);
 
646
            if (NULL == soap_action)
 
647
            {
 
648
              is_soap_act_set = AXIS2_FALSE;
 
649
              soap_action = "EucalyptusGL#GetKeys";
 
650
              
 
651
              soap_act = axutil_string_create(env, "EucalyptusGL#GetKeys");
 
652
              axis2_options_set_soap_action(options, env, soap_act);
 
653
              
 
654
              axis2_options_set_action( options, env, soap_action);
 
655
            }
 
656
            
 
657
            axis2_options_set_soap_version(options, env, AXIOM_SOAP11);
 
658
             
 
659
 
 
660
            callback = axis2_callback_create(env);
 
661
            /* Set our on_complete fucntion pointer to the callback object */
 
662
            axis2_callback_set_on_complete(callback, axis2_stub_on_complete_EucalyptusGL_GetKeys);
 
663
            /* Set our on_error function pointer to the callback object */
 
664
            axis2_callback_set_on_error(callback, axis2_stub_on_error_EucalyptusGL_GetKeys);
 
665
 
 
666
            callback_data-> data = user_data;
 
667
            callback_data-> on_complete = on_complete;
 
668
            callback_data-> on_error = on_error;
 
669
 
 
670
            axis2_callback_set_data(callback, (void*)callback_data);
 
671
 
 
672
            /* Send request */
 
673
            axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback);
 
674
            
 
675
            if (!is_soap_act_set)
 
676
            {
 
677
              
 
678
              axis2_options_set_soap_action(options, env, NULL);
 
679
              
 
680
              axis2_options_set_action(options, env, NULL);
 
681
            }
 
682
         }
 
683
 
 
684
            
 
685
 
 
686
 
 
687
     /**
 
688
      * function to free any soap input headers 
 
689
      */
 
690
     
 
691
 
 
692
 
 
693
     /**
 
694
      * function to free any soap output headers 
 
695
      */
 
696
     
 
697