← Back to branch summary

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

« back to all changes in this revision

Viewing changes to node/generated/axis2_svc_skel_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:
node/generated/axis2_svc_skel_EucalyptusNC.c
 
1
 
 
2
 
 
3
        /**
 
4
         * axis2_svc_skel_EucalyptusNC.c
 
5
         *
 
6
         * This file was auto-generated from WSDL for "EucalyptusNC|http://eucalyptus.ucsb.edu/" service
 
7
         * by the Apache Axis2 version: 1.4  Built on : Apr 26, 2008 (06:24:30 EDT)
 
8
         *  axis2_svc_skel_EucalyptusNC
 
9
         */
 
10
 
 
11
        #include "axis2_skel_EucalyptusNC.h"
 
12
        #include <axis2_svc_skeleton.h>
 
13
        #include <stdio.h>
 
14
        #include <axis2_svc.h>
 
15
#include "euca_axis.h"
 
16
 
 
17
        /**
 
18
         * functions prototypes
 
19
         */
 
20
 
 
21
        /* On fault, handle the fault */
 
22
        axiom_node_t* AXIS2_CALL
 
23
        axis2_svc_skel_EucalyptusNC_on_fault(axis2_svc_skeleton_t *svc_skeleton,
 
24
                  const axutil_env_t *env, axiom_node_t *node);
 
25
 
 
26
        /* Free the service */
 
27
        int AXIS2_CALL
 
28
        axis2_svc_skel_EucalyptusNC_free(axis2_svc_skeleton_t *svc_skeleton,
 
29
                  const axutil_env_t *env);
 
30
 
 
31
        /* This method invokes the right service method */
 
32
        axiom_node_t* AXIS2_CALL
 
33
        axis2_svc_skel_EucalyptusNC_invoke(axis2_svc_skeleton_t *svc_skeleton,
 
34
                    const axutil_env_t *env,
 
35
                    axiom_node_t *node,
 
36
                    axis2_msg_ctx_t *msg_ctx);
 
37
 
 
38
        /* Initializing the environment  */
 
39
        int AXIS2_CALL
 
40
        axis2_svc_skel_EucalyptusNC_init(axis2_svc_skeleton_t *svc_skeleton,
 
41
                        const axutil_env_t *env);
 
42
 
 
43
        /* Create the service  */
 
44
        axis2_svc_skeleton_t* AXIS2_CALL
 
45
        axis2_svc_skel_EucalyptusNC_create(const axutil_env_t *env);
 
46
 
 
47
        static const axis2_svc_skeleton_ops_t axis2_svc_skel_EucalyptusNC_svc_skeleton_ops_var = {
 
48
            axis2_svc_skel_EucalyptusNC_init,
 
49
            axis2_svc_skel_EucalyptusNC_invoke,
 
50
            axis2_svc_skel_EucalyptusNC_on_fault,
 
51
            axis2_svc_skel_EucalyptusNC_free
 
52
        };
 
53
 
 
54
 
 
55
        /**
 
56
         * Implementations for the functions
 
57
         */
 
58
 
 
59
        axis2_svc_skeleton_t* AXIS2_CALL
 
60
        axis2_svc_skel_EucalyptusNC_create(const axutil_env_t *env)
 
61
        {
 
62
            axis2_svc_skeleton_t *svc_skeleton = NULL;
 
63
        /* Allocate memory for the structs */
 
64
        svc_skeleton = (axis2_svc_skeleton_t *)AXIS2_MALLOC(env->allocator,
 
65
            sizeof(axis2_svc_skeleton_t));
 
66
 
 
67
        svc_skeleton->ops = &axis2_svc_skel_EucalyptusNC_svc_skeleton_ops_var;
 
68
 
 
69
 
 
70
            return svc_skeleton;
 
71
        }
 
72
 
 
73
 
 
74
        int AXIS2_CALL
 
75
        axis2_svc_skel_EucalyptusNC_init(axis2_svc_skeleton_t *svc_skeleton,
 
76
                                const axutil_env_t *env)
 
77
        {
 
78
            /* Any initialization stuff of axis2_skel_EucalyptusNC goes here */
 
79
            return AXIS2_SUCCESS;
 
80
        }
 
81
 
 
82
        int AXIS2_CALL
 
83
        axis2_svc_skel_EucalyptusNC_free(axis2_svc_skeleton_t *svc_skeleton,
 
84
                                 const axutil_env_t *env)
 
85
        {
 
86
 
 
87
        /* Free the service skeleton */
 
88
        if (svc_skeleton)
 
89
        {
 
90
            AXIS2_FREE(env->allocator, svc_skeleton);
 
91
            svc_skeleton = NULL;
 
92
        }
 
93
 
 
94
        return AXIS2_SUCCESS;
 
95
        }
 
96
 
 
97
 
 
98
 
 
99
     /**
 
100
      * function to free any soap input headers
 
101
      */
 
102
     
 
103
 
 
104
 
 
105
 
 
106
     /**
 
107
      * function to free any soap output headers
 
108
      */
 
109
     
 
110
 
 
111
 
 
112
 
 
113
 
 
114
        /*
 
115
         * This method invokes the right service method
 
116
         */
 
117
        axiom_node_t* AXIS2_CALL
 
118
        axis2_svc_skel_EucalyptusNC_invoke(axis2_svc_skeleton_t *svc_skeleton,
 
119
                                const axutil_env_t *env,
 
120
                                axiom_node_t *content_node,
 
121
                                axis2_msg_ctx_t *msg_ctx)
 
122
        {
 
123
         /* depending on the function name invoke the
 
124
          * corresponding  method
 
125
          */
 
126
 
 
127
          axis2_op_ctx_t *operation_ctx = NULL;
 
128
          axis2_op_t *operation = NULL;
 
129
          axutil_qname_t *op_qname = NULL;
 
130
          axis2_char_t *op_name = NULL;
 
131
          axis2_msg_ctx_t *in_msg_ctx = NULL;
 
132
          
 
133
          axiom_soap_envelope_t *req_soap_env = NULL;
 
134
          axiom_soap_header_t *req_soap_header = NULL;
 
135
          axiom_soap_envelope_t *res_soap_env = NULL;
 
136
          axiom_soap_header_t *res_soap_header = NULL;
 
137
 
 
138
          axiom_node_t *ret_node = NULL;
 
139
          axiom_node_t *input_header = NULL;
 
140
          axiom_node_t *output_header = NULL;
 
141
          axiom_node_t *header_base_node = NULL;
 
142
 
 
143
          
 
144
            adb_ncRunInstanceResponse_t* ret_val1 = NULL;
 
145
            adb_ncRunInstance_t* input_val1 = NULL;
 
146
            
 
147
            adb_ncRebootInstanceResponse_t* ret_val2 = NULL;
 
148
            adb_ncRebootInstance_t* input_val2 = NULL;
 
149
            
 
150
            adb_ncGetConsoleOutputResponse_t* ret_val3 = NULL;
 
151
            adb_ncGetConsoleOutput_t* input_val3 = NULL;
 
152
            
 
153
            adb_ncDetachVolumeResponse_t* ret_val4 = NULL;
 
154
            adb_ncDetachVolume_t* input_val4 = NULL;
 
155
            
 
156
            adb_ncDescribeInstancesResponse_t* ret_val5 = NULL;
 
157
            adb_ncDescribeInstances_t* input_val5 = NULL;
 
158
            
 
159
            adb_ncAttachVolumeResponse_t* ret_val6 = NULL;
 
160
            adb_ncAttachVolume_t* input_val6 = NULL;
 
161
            
 
162
            adb_ncPowerDownResponse_t* ret_val7 = NULL;
 
163
            adb_ncPowerDown_t* input_val7 = NULL;
 
164
            
 
165
            adb_ncDescribeResourceResponse_t* ret_val8 = NULL;
 
166
            adb_ncDescribeResource_t* input_val8 = NULL;
 
167
            
 
168
            adb_ncTerminateInstanceResponse_t* ret_val9 = NULL;
 
169
            adb_ncTerminateInstance_t* input_val9 = NULL;
 
170
            
 
171
            adb_ncStartNetworkResponse_t* ret_val10 = NULL;
 
172
            adb_ncStartNetwork_t* input_val10 = NULL;
 
173
            
 
174
 
 
175
          operation_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
 
176
          operation = axis2_op_ctx_get_op(operation_ctx, env);
 
177
          op_qname = (axutil_qname_t *)axis2_op_get_qname(operation, env);
 
178
          op_name = axutil_qname_get_localpart(op_qname, env);
 
179
 
 
180
          euca_authenticate(env,msg_ctx,operation_ctx);
 
181
 
 
182
          if (op_name)
 
183
          {
 
184
               
 
185
 
 
186
                if ( axutil_strcmp(op_name, "ncRunInstance") == 0 )
 
187
                {
 
188
                    
 
189
                    input_val1 = 
 
190
                        adb_ncRunInstance_create( env);
 
191
                        if( AXIS2_FAILURE == adb_ncRunInstance_deserialize(input_val1, env, &content_node, NULL, AXIS2_FALSE))
 
192
                        {
 
193
                            adb_ncRunInstance_free(input_val1, env);
 
194
                      
 
195
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
196
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncRunInstance_deserialize: "
 
197
                                        "This should be due to an invalid XML");
 
198
                            return NULL;      
 
199
                        }
 
200
                        
 
201
 
 
202
 
 
203
                    ret_val1 =  axis2_skel_EucalyptusNC_ncRunInstance(env ,input_val1    );
 
204
                    
 
205
                        if ( NULL == ret_val1 )
 
206
                        {
 
207
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
208
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncRunInstance ");
 
209
                            
 
210
                                adb_ncRunInstance_free(input_val1, env);
 
211
                            
 
212
                            return NULL; 
 
213
                        }
 
214
                        ret_node = 
 
215
                                   adb_ncRunInstanceResponse_serialize(ret_val1, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
216
                                   adb_ncRunInstanceResponse_free(ret_val1, env);
 
217
                                   
 
218
                                    adb_ncRunInstance_free(input_val1, env);
 
219
                                   
 
220
 
 
221
                        return ret_node;
 
222
                    
 
223
 
 
224
                    
 
225
                    
 
226
 
 
227
                }
 
228
             
 
229
 
 
230
                if ( axutil_strcmp(op_name, "ncRebootInstance") == 0 )
 
231
                {
 
232
                    
 
233
                    input_val2 = 
 
234
                        adb_ncRebootInstance_create( env);
 
235
                        if( AXIS2_FAILURE == adb_ncRebootInstance_deserialize(input_val2, env, &content_node, NULL, AXIS2_FALSE))
 
236
                        {
 
237
                            adb_ncRebootInstance_free(input_val2, env);
 
238
                      
 
239
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
240
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncRebootInstance_deserialize: "
 
241
                                        "This should be due to an invalid XML");
 
242
                            return NULL;      
 
243
                        }
 
244
                        
 
245
 
 
246
 
 
247
                    ret_val2 =  axis2_skel_EucalyptusNC_ncRebootInstance(env ,input_val2    );
 
248
                    
 
249
                        if ( NULL == ret_val2 )
 
250
                        {
 
251
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
252
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncRebootInstance ");
 
253
                            
 
254
                                adb_ncRebootInstance_free(input_val2, env);
 
255
                            
 
256
                            return NULL; 
 
257
                        }
 
258
                        ret_node = 
 
259
                                   adb_ncRebootInstanceResponse_serialize(ret_val2, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
260
                                   adb_ncRebootInstanceResponse_free(ret_val2, env);
 
261
                                   
 
262
                                    adb_ncRebootInstance_free(input_val2, env);
 
263
                                   
 
264
 
 
265
                        return ret_node;
 
266
                    
 
267
 
 
268
                    
 
269
                    
 
270
 
 
271
                }
 
272
             
 
273
 
 
274
                if ( axutil_strcmp(op_name, "ncGetConsoleOutput") == 0 )
 
275
                {
 
276
                    
 
277
                    input_val3 = 
 
278
                        adb_ncGetConsoleOutput_create( env);
 
279
                        if( AXIS2_FAILURE == adb_ncGetConsoleOutput_deserialize(input_val3, env, &content_node, NULL, AXIS2_FALSE))
 
280
                        {
 
281
                            adb_ncGetConsoleOutput_free(input_val3, env);
 
282
                      
 
283
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
284
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncGetConsoleOutput_deserialize: "
 
285
                                        "This should be due to an invalid XML");
 
286
                            return NULL;      
 
287
                        }
 
288
                        
 
289
 
 
290
 
 
291
                    ret_val3 =  axis2_skel_EucalyptusNC_ncGetConsoleOutput(env ,input_val3    );
 
292
                    
 
293
                        if ( NULL == ret_val3 )
 
294
                        {
 
295
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
296
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncGetConsoleOutput ");
 
297
                            
 
298
                                adb_ncGetConsoleOutput_free(input_val3, env);
 
299
                            
 
300
                            return NULL; 
 
301
                        }
 
302
                        ret_node = 
 
303
                                   adb_ncGetConsoleOutputResponse_serialize(ret_val3, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
304
                                   adb_ncGetConsoleOutputResponse_free(ret_val3, env);
 
305
                                   
 
306
                                    adb_ncGetConsoleOutput_free(input_val3, env);
 
307
                                   
 
308
 
 
309
                        return ret_node;
 
310
                    
 
311
 
 
312
                    
 
313
                    
 
314
 
 
315
                }
 
316
             
 
317
 
 
318
                if ( axutil_strcmp(op_name, "ncDetachVolume") == 0 )
 
319
                {
 
320
                    
 
321
                    input_val4 = 
 
322
                        adb_ncDetachVolume_create( env);
 
323
                        if( AXIS2_FAILURE == adb_ncDetachVolume_deserialize(input_val4, env, &content_node, NULL, AXIS2_FALSE))
 
324
                        {
 
325
                            adb_ncDetachVolume_free(input_val4, env);
 
326
                      
 
327
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
328
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDetachVolume_deserialize: "
 
329
                                        "This should be due to an invalid XML");
 
330
                            return NULL;      
 
331
                        }
 
332
                        
 
333
 
 
334
 
 
335
                    ret_val4 =  axis2_skel_EucalyptusNC_ncDetachVolume(env ,input_val4    );
 
336
                    
 
337
                        if ( NULL == ret_val4 )
 
338
                        {
 
339
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
340
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncDetachVolume ");
 
341
                            
 
342
                                adb_ncDetachVolume_free(input_val4, env);
 
343
                            
 
344
                            return NULL; 
 
345
                        }
 
346
                        ret_node = 
 
347
                                   adb_ncDetachVolumeResponse_serialize(ret_val4, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
348
                                   adb_ncDetachVolumeResponse_free(ret_val4, env);
 
349
                                   
 
350
                                    adb_ncDetachVolume_free(input_val4, env);
 
351
                                   
 
352
 
 
353
                        return ret_node;
 
354
                    
 
355
 
 
356
                    
 
357
                    
 
358
 
 
359
                }
 
360
             
 
361
 
 
362
                if ( axutil_strcmp(op_name, "ncDescribeInstances") == 0 )
 
363
                {
 
364
                    
 
365
                    input_val5 = 
 
366
                        adb_ncDescribeInstances_create( env);
 
367
                        if( AXIS2_FAILURE == adb_ncDescribeInstances_deserialize(input_val5, env, &content_node, NULL, AXIS2_FALSE))
 
368
                        {
 
369
                            adb_ncDescribeInstances_free(input_val5, env);
 
370
                      
 
371
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
372
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDescribeInstances_deserialize: "
 
373
                                        "This should be due to an invalid XML");
 
374
                            return NULL;      
 
375
                        }
 
376
                        
 
377
 
 
378
 
 
379
                    ret_val5 =  axis2_skel_EucalyptusNC_ncDescribeInstances(env ,input_val5    );
 
380
                    
 
381
                        if ( NULL == ret_val5 )
 
382
                        {
 
383
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
384
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncDescribeInstances ");
 
385
                            
 
386
                                adb_ncDescribeInstances_free(input_val5, env);
 
387
                            
 
388
                            return NULL; 
 
389
                        }
 
390
                        ret_node = 
 
391
                                   adb_ncDescribeInstancesResponse_serialize(ret_val5, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
392
                                   adb_ncDescribeInstancesResponse_free(ret_val5, env);
 
393
                                   
 
394
                                    adb_ncDescribeInstances_free(input_val5, env);
 
395
                                   
 
396
 
 
397
                        return ret_node;
 
398
                    
 
399
 
 
400
                    
 
401
                    
 
402
 
 
403
                }
 
404
             
 
405
 
 
406
                if ( axutil_strcmp(op_name, "ncAttachVolume") == 0 )
 
407
                {
 
408
                    
 
409
                    input_val6 = 
 
410
                        adb_ncAttachVolume_create( env);
 
411
                        if( AXIS2_FAILURE == adb_ncAttachVolume_deserialize(input_val6, env, &content_node, NULL, AXIS2_FALSE))
 
412
                        {
 
413
                            adb_ncAttachVolume_free(input_val6, env);
 
414
                      
 
415
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
416
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncAttachVolume_deserialize: "
 
417
                                        "This should be due to an invalid XML");
 
418
                            return NULL;      
 
419
                        }
 
420
                        
 
421
 
 
422
 
 
423
                    ret_val6 =  axis2_skel_EucalyptusNC_ncAttachVolume(env ,input_val6    );
 
424
                    
 
425
                        if ( NULL == ret_val6 )
 
426
                        {
 
427
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
428
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncAttachVolume ");
 
429
                            
 
430
                                adb_ncAttachVolume_free(input_val6, env);
 
431
                            
 
432
                            return NULL; 
 
433
                        }
 
434
                        ret_node = 
 
435
                                   adb_ncAttachVolumeResponse_serialize(ret_val6, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
436
                                   adb_ncAttachVolumeResponse_free(ret_val6, env);
 
437
                                   
 
438
                                    adb_ncAttachVolume_free(input_val6, env);
 
439
                                   
 
440
 
 
441
                        return ret_node;
 
442
                    
 
443
 
 
444
                    
 
445
                    
 
446
 
 
447
                }
 
448
             
 
449
 
 
450
                if ( axutil_strcmp(op_name, "ncPowerDown") == 0 )
 
451
                {
 
452
                    
 
453
                    input_val7 = 
 
454
                        adb_ncPowerDown_create( env);
 
455
                        if( AXIS2_FAILURE == adb_ncPowerDown_deserialize(input_val7, env, &content_node, NULL, AXIS2_FALSE))
 
456
                        {
 
457
                            adb_ncPowerDown_free(input_val7, env);
 
458
                      
 
459
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
460
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncPowerDown_deserialize: "
 
461
                                        "This should be due to an invalid XML");
 
462
                            return NULL;      
 
463
                        }
 
464
                        
 
465
 
 
466
 
 
467
                    ret_val7 =  axis2_skel_EucalyptusNC_ncPowerDown(env ,input_val7    );
 
468
                    
 
469
                        if ( NULL == ret_val7 )
 
470
                        {
 
471
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
472
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncPowerDown ");
 
473
                            
 
474
                                adb_ncPowerDown_free(input_val7, env);
 
475
                            
 
476
                            return NULL; 
 
477
                        }
 
478
                        ret_node = 
 
479
                                   adb_ncPowerDownResponse_serialize(ret_val7, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
480
                                   adb_ncPowerDownResponse_free(ret_val7, env);
 
481
                                   
 
482
                                    adb_ncPowerDown_free(input_val7, env);
 
483
                                   
 
484
 
 
485
                        return ret_node;
 
486
                    
 
487
 
 
488
                    
 
489
                    
 
490
 
 
491
                }
 
492
             
 
493
 
 
494
                if ( axutil_strcmp(op_name, "ncDescribeResource") == 0 )
 
495
                {
 
496
                    
 
497
                    input_val8 = 
 
498
                        adb_ncDescribeResource_create( env);
 
499
                        if( AXIS2_FAILURE == adb_ncDescribeResource_deserialize(input_val8, env, &content_node, NULL, AXIS2_FALSE))
 
500
                        {
 
501
                            adb_ncDescribeResource_free(input_val8, env);
 
502
                      
 
503
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
504
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncDescribeResource_deserialize: "
 
505
                                        "This should be due to an invalid XML");
 
506
                            return NULL;      
 
507
                        }
 
508
                        
 
509
 
 
510
 
 
511
                    ret_val8 =  axis2_skel_EucalyptusNC_ncDescribeResource(env ,input_val8    );
 
512
                    
 
513
                        if ( NULL == ret_val8 )
 
514
                        {
 
515
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
516
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncDescribeResource ");
 
517
                            
 
518
                                adb_ncDescribeResource_free(input_val8, env);
 
519
                            
 
520
                            return NULL; 
 
521
                        }
 
522
                        ret_node = 
 
523
                                   adb_ncDescribeResourceResponse_serialize(ret_val8, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
524
                                   adb_ncDescribeResourceResponse_free(ret_val8, env);
 
525
                                   
 
526
                                    adb_ncDescribeResource_free(input_val8, env);
 
527
                                   
 
528
 
 
529
                        return ret_node;
 
530
                    
 
531
 
 
532
                    
 
533
                    
 
534
 
 
535
                }
 
536
             
 
537
 
 
538
                if ( axutil_strcmp(op_name, "ncTerminateInstance") == 0 )
 
539
                {
 
540
                    
 
541
                    input_val9 = 
 
542
                        adb_ncTerminateInstance_create( env);
 
543
                        if( AXIS2_FAILURE == adb_ncTerminateInstance_deserialize(input_val9, env, &content_node, NULL, AXIS2_FALSE))
 
544
                        {
 
545
                            adb_ncTerminateInstance_free(input_val9, env);
 
546
                      
 
547
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
548
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncTerminateInstance_deserialize: "
 
549
                                        "This should be due to an invalid XML");
 
550
                            return NULL;      
 
551
                        }
 
552
                        
 
553
 
 
554
 
 
555
                    ret_val9 =  axis2_skel_EucalyptusNC_ncTerminateInstance(env ,input_val9    );
 
556
                    
 
557
                        if ( NULL == ret_val9 )
 
558
                        {
 
559
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
560
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncTerminateInstance ");
 
561
                            
 
562
                                adb_ncTerminateInstance_free(input_val9, env);
 
563
                            
 
564
                            return NULL; 
 
565
                        }
 
566
                        ret_node = 
 
567
                                   adb_ncTerminateInstanceResponse_serialize(ret_val9, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
568
                                   adb_ncTerminateInstanceResponse_free(ret_val9, env);
 
569
                                   
 
570
                                    adb_ncTerminateInstance_free(input_val9, env);
 
571
                                   
 
572
 
 
573
                        return ret_node;
 
574
                    
 
575
 
 
576
                    
 
577
                    
 
578
 
 
579
                }
 
580
             
 
581
 
 
582
                if ( axutil_strcmp(op_name, "ncStartNetwork") == 0 )
 
583
                {
 
584
                    
 
585
                    input_val10 = 
 
586
                        adb_ncStartNetwork_create( env);
 
587
                        if( AXIS2_FAILURE == adb_ncStartNetwork_deserialize(input_val10, env, &content_node, NULL, AXIS2_FALSE))
 
588
                        {
 
589
                            adb_ncStartNetwork_free(input_val10, env);
 
590
                      
 
591
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
592
                            AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the ncStartNetwork_deserialize: "
 
593
                                        "This should be due to an invalid XML");
 
594
                            return NULL;      
 
595
                        }
 
596
                        
 
597
 
 
598
 
 
599
                    ret_val10 =  axis2_skel_EucalyptusNC_ncStartNetwork(env ,input_val10    );
 
600
                    
 
601
                        if ( NULL == ret_val10 )
 
602
                        {
 
603
                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE);
 
604
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL returnted from the business logic from ncStartNetwork ");
 
605
                            
 
606
                                adb_ncStartNetwork_free(input_val10, env);
 
607
                            
 
608
                            return NULL; 
 
609
                        }
 
610
                        ret_node = 
 
611
                                   adb_ncStartNetworkResponse_serialize(ret_val10, env, NULL, NULL, AXIS2_TRUE, NULL, NULL);
 
612
                                   adb_ncStartNetworkResponse_free(ret_val10, env);
 
613
                                   
 
614
                                    adb_ncStartNetwork_free(input_val10, env);
 
615
                                   
 
616
 
 
617
                        return ret_node;
 
618
                    
 
619
 
 
620
                    
 
621
                    
 
622
 
 
623
                }
 
624
             
 
625
             }
 
626
          printf("axis2_svc_skel_EucalyptusNC service ERROR: invalid OM parameters in request\n");
 
627
          return NULL;
 
628
    }
 
629
 
 
630
    axiom_node_t* AXIS2_CALL
 
631
    axis2_svc_skel_EucalyptusNC_on_fault(axis2_svc_skeleton_t *svc_skeleton,
 
632
                  const axutil_env_t *env, axiom_node_t *node)
 
633
        {
 
634
                axiom_node_t *error_node = NULL;
 
635
                axiom_element_t *error_ele = NULL;
 
636
                error_ele = axiom_element_create(env, node, "fault", NULL,
 
637
                                        &error_node);
 
638
                axiom_element_set_text(error_ele, env, "EucalyptusNC|http://eucalyptus.ucsb.edu/ failed",
 
639
                                        error_node);
 
640
                return error_node;
 
641
        }
 
642
 
 
643
 
 
644
        /**
 
645
         * Following block distinguish the exposed part of the dll.
 
646
         */
 
647
 
 
648
    AXIS2_EXTERN int
 
649
    axis2_get_instance(struct axis2_svc_skeleton **inst,
 
650
                                const axutil_env_t *env)
 
651
        {
 
652
                *inst = axis2_svc_skel_EucalyptusNC_create(env);
 
653
 
 
654
        if(!(*inst))
 
655
        {
 
656
            return AXIS2_FAILURE;
 
657
        }
 
658
 
 
659
                return AXIS2_SUCCESS;
 
660
        }
 
661
 
 
662
        AXIS2_EXTERN int 
 
663
    axis2_remove_instance(axis2_svc_skeleton_t *inst,
 
664
                            const axutil_env_t *env)
 
665
        {
 
666
        axis2_status_t status = AXIS2_FAILURE;
 
667
        if (inst)
 
668
        {
 
669
            status = AXIS2_SVC_SKELETON_FREE(inst, env);
 
670
        }
 
671
        return status;
 
672
        }
 
673
 
 
674
 
 
675
    
 
676