← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gridengine/utopic

« back to all changes in this revision

Viewing changes to source/libs/jgdi/jgdi_common.c

  • Committer: Bazaar Package Importer
  • Author(s): Mark Hymers
  • Date: 2008-06-25 22:36:13 UTC
  • Revision ID: james.westby@ubuntu.com-20080625223613-tvd9xlhuoct9kyhm
Tags: upstream-6.2~beta2
Import upstream version 6.2~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/jgdi/jgdi_common.c
 
1
/*___INFO__MARK_BEGIN__*/
 
2
/*************************************************************************
 
3
 *
 
4
 *  The Contents of this file are made available subject to the terms of
 
5
 *  the Sun Industry Standards Source License Version 1.2
 
6
 *
 
7
 *  Sun Microsystems Inc., March, 2001
 
8
 *
 
9
 *
 
10
 *  Sun Industry Standards Source License Version 1.2
 
11
 *  =================================================
 
12
 *  The contents of this file are subject to the Sun Industry Standards
 
13
 *  Source License Version 1.2 (the "License"); You may not use this file
 
14
 *  except in compliance with the License. You may obtain a copy of the
 
15
 *  License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
 
16
 *
 
17
 *  Software provided under this License is provided on an "AS IS" basis,
 
18
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 
19
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 
20
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 
21
 *  See the License for the specific provisions governing your rights and
 
22
 *  obligations concerning the Software.
 
23
 *
 
24
 *   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 
25
 *
 
26
 *   Copyright: 2001 by Sun Microsystems, Inc.
 
27
 *
 
28
 *   All Rights Reserved.
 
29
 *
 
30
 ************************************************************************/
 
31
/*___INFO__MARK_END__*/
 
32
#include <ctype.h>
 
33
#include <string.h>
 
34
#include "jni.h"
 
35
#include "jgdi.h"
 
36
#include "basis_types.h"
 
37
#include "cull.h"
 
38
#include "commlib.h"
 
39
#include "sgermon.h"
 
40
#include "sge_all_listsL.h"
 
41
#include "sge_answer.h"
 
42
#include "sge_prog.h"
 
43
#include "sge_bootstrap.h"
 
44
#include "version.h"
 
45
#include "cl_errors.h"
 
46
#include "sge_log.h"
 
47
#include "sge_error_class.h"
 
48
#include "sge_qinstance_state.h"
 
49
#include "jgdi_common.h"
 
50
#include "cull_list.h"
 
51
#include "jgdi_wrapper.h"
 
52
#include "jgdi_factory.h"
 
53
#include "sge_calendar.h"
 
54
#include "sge_cqueue.h"
 
55
#include "jgdi_logging.h"
 
56
#include "sge_ja_task.h"
 
57
#include "msg_sgeobjlib.h"
 
58
#include "msg_common.h"
 
59
#include "sge_edit.h"
 
60
#include "sge_sharetree.h"
 
61
#include "sge_utility.h"
 
62
 
 
63
#include "gdi/sge_gdi.h"
 
64
#include "gdi/sge_gdi2.h"
 
65
 
 
66
#define MAX_GDI_CTX_ARRAY_SIZE 1024
 
67
 
 
68
static pthread_mutex_t sge_gdi_ctx_mutex = PTHREAD_MUTEX_INITIALIZER;
 
69
static sge_gdi_ctx_class_t* sge_gdi_ctx_array[MAX_GDI_CTX_ARRAY_SIZE];
 
70
 
 
71
typedef struct object_mapping_str object_mapping_t;
 
72
 
 
73
static jgdi_result_t get_map(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList **list, lList **alpp);
 
74
static jgdi_result_t set_map(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList *lp, lList **alpp);
 
75
static jgdi_result_t get_map_list(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList **list, lList **alpp);
 
76
static jgdi_result_t set_map_list(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList *lp, lList **alpp);
 
77
static jgdi_result_t set_value_in_elem(JNIEnv *env, jobject value_obj, lListElem *elem, int cullType, int pos, lList** alpp);
 
78
static jgdi_result_t create_object_from_elem(JNIEnv *env, lListElem *ep, jobject *obj, int cullType, int pos, lList **alpp);
 
79
static void exception_to_string(JNIEnv* env, jobject exc, dstring* buf);
 
80
static void print_stacktrace(JNIEnv* env, jobject exc, dstring* buf);
 
81
static void print_exception(JNIEnv* env, jobject exc, dstring* buf);
 
82
static jgdi_result_t get_descriptor_for_property(JNIEnv *env, jobject property_descr, lDescr **descr, lList **alpp);
 
83
static jgdi_result_t get_list_descriptor_for_property(JNIEnv *env, jobject property_descr, lDescr **descr, lList **alpp);
 
84
static jgdi_result_t string_list_to_list_elem(JNIEnv *env, jobject list, lList **lpp, lDescr *descr, int nm,  lList **alpp);
 
85
static jgdi_result_t build_field_filter(JNIEnv *env, jobject field, lCondition **where, lList **alpp);
 
86
static jgdi_result_t calendar_to_elem(object_mapping_t *thiz, JNIEnv *env, jobject obj, lListElem *elem, lList **alpp);
 
87
static jgdi_result_t elem_to_calendar(object_mapping_t *thiz, JNIEnv *env, lListElem *elem, jobject* obj, lList **alpp);
 
88
static object_mapping_t* get_object_mapping(const lDescr *descr);
 
89
static jgdi_result_t set_object(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lObject cob, lList **alpp);
 
90
static jgdi_result_t get_object(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lObject *cob, lList **alpp);
 
91
 
 
92
 
 
93
struct object_mapping_str {
 
94
   lDescr* descr;
 
95
   jgdi_result_t(*object_to_elem)(object_mapping_t *thiz, JNIEnv *env, jobject obj, lListElem *elem, lList **alpp);
 
96
   jgdi_result_t(*elem_to_object)(object_mapping_t *thiz, JNIEnv *env, lListElem *elem, jobject* obj, lList **alpp);
 
97
} ;
 
98
 
 
99
static object_mapping_t OBJECT_MAPPINGS [] = {
 
100
   { &(TM_Type[0]),
 
101
     calendar_to_elem,
 
102
     elem_to_calendar },
 
103
     { NULL, NULL, NULL }
 
104
};
 
105
 
 
106
 
 
107
 
 
108
 
 
109
/*
 
110
 * Class:     com_sun_grid_jgdi_jni_JGDI
 
111
 * Method:    nativeClose
 
112
 * Signature: (I)V
 
113
 */
 
114
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClose(JNIEnv *env, jobject jgdi, jint ctx_index) {
 
115
   sge_gdi_ctx_class_t *ctx = NULL;
 
116
 
 
117
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClose");
 
118
 
 
119
   pthread_mutex_lock(&sge_gdi_ctx_mutex);
 
120
   ctx = sge_gdi_ctx_array[ctx_index];
 
121
   sge_gdi_ctx_array[ctx_index] = NULL;
 
122
   pthread_mutex_unlock(&sge_gdi_ctx_mutex);
 
123
   if (ctx) {
 
124
      cl_com_handle_t *handle = cl_com_get_handle(ctx->get_component_name(ctx), 0);
 
125
      cl_commlib_shutdown_handle(handle, CL_FALSE);
 
126
      sge_gdi_ctx_class_destroy(&ctx);
 
127
   } else {
 
128
      THROW_ERROR((env, JGDI_ERROR, "ctx is NULL"));
 
129
   }
 
130
 
 
131
   DRETURN_VOID;
 
132
}
 
133
 
 
134
/*
 
135
 * Class:     com_sun_grid_jgdi_JGDIBaseImpl
 
136
 * Method:    nativeInit
 
137
 * Signature: ()V
 
138
 */
 
139
JNIEXPORT jint JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeInit(JNIEnv *env, jobject jgdi, jstring url_obj) {
 
140
   
 
141
   char* argv[] = { "jgdi" };
 
142
   int argc = 1;
 
143
   jint ret = -1;
 
144
   const char *url = NULL;
 
145
   jstring username_obj = NULL;
 
146
   const char *username = NULL;
 
147
   jobject private_key_obj = NULL;
 
148
   jobject certificate_obj = NULL;
 
149
   const char* private_key = NULL;
 
150
   const char* certificate = NULL;
 
151
   sge_gdi_ctx_class_t *ctx = NULL;
 
152
   int i;
 
153
   int ctx_index = -1;
 
154
   jgdi_result_t res = JGDI_SUCCESS;
 
155
   lList *alp = NULL;
 
156
   
 
157
   DENTER_MAIN(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeInit");
 
158
 
 
159
   if (url_obj == NULL) {
 
160
      THROW_ERROR((env, JGDI_NULL_POINTER, "url_obj is null"));
 
161
      ret = -1;
 
162
      goto error;
 
163
   }
 
164
 
 
165
   res = SecurityHelper_static_getUsername(env, &username_obj, &alp);
 
166
   if (res != JGDI_SUCCESS) {
 
167
      throw_error_from_answer_list(env, res, alp);
 
168
      ret = -1;
 
169
      goto error;
 
170
   }
 
171
   res = SecurityHelper_static_getPrivateKey(env, &private_key_obj, &alp);
 
172
   if (res != JGDI_SUCCESS) {
 
173
      throw_error_from_answer_list(env, res, alp);
 
174
      ret = -1;
 
175
      goto error;
 
176
   }
 
177
   
 
178
   res = SecurityHelper_static_getCertificate(env, &certificate_obj, &alp);
 
179
   if (res != JGDI_SUCCESS) {
 
180
      throw_error_from_answer_list(env, res, alp);
 
181
      ret = -1;
 
182
      goto error;
 
183
   }
 
184
   
 
185
   url = (*env)->GetStringUTFChars(env, url_obj, 0);
 
186
   if (username_obj != NULL) {
 
187
      username = (*env)->GetStringUTFChars(env, username_obj, 0);
 
188
   }
 
189
   if (private_key_obj != NULL) {
 
190
      private_key = (*env)->GetStringUTFChars(env, private_key_obj, 0);
 
191
   }
 
192
   if (certificate_obj != NULL) {
 
193
      certificate = (*env)->GetStringUTFChars(env, certificate_obj, 0);
 
194
   }
 
195
 
 
196
   pthread_mutex_lock(&sge_gdi_ctx_mutex);
 
197
   i = 0;
 
198
   while(true) {
 
199
      if (i>=MAX_GDI_CTX_ARRAY_SIZE) {
 
200
         pthread_mutex_unlock(&sge_gdi_ctx_mutex);
 
201
         THROW_ERROR((env, JGDI_ILLEGAL_STATE, "sge_gdi_ctx_array is full"));
 
202
         ret = -1;
 
203
         goto error;
 
204
      }
 
205
      if (sge_gdi_ctx_array[i] == NULL) {
 
206
         dstring component_name = DSTRING_INIT;
 
207
         
 
208
         sge_dstring_sprintf(&component_name, "%s-%d", prognames[JGDI_PROGNAME], i);
 
209
         
 
210
         ctx = sge_gdi_ctx_class_create_from_bootstrap(JGDI_PROGNAME,
 
211
                                                       sge_dstring_get_string(&component_name),
 
212
                                                       MAIN_THREAD,
 
213
                                                       threadnames[MAIN_THREAD],
 
214
                                                       url, username, &alp);
 
215
         sge_dstring_free(&component_name);
 
216
 
 
217
         /*
 
218
         ** TODO: find a more consistent solution for logging -> sge_log()
 
219
         **       to suppress any console log output
 
220
         */
 
221
         log_state_set_log_verbose(0);
 
222
         sge_gdi_set_thread_local_ctx(ctx);
 
223
   
 
224
         if (ctx == NULL) {
 
225
            pthread_mutex_unlock(&sge_gdi_ctx_mutex);
 
226
            throw_error_from_answer_list(env, JGDI_ERROR, alp);
 
227
            ret = -1;
 
228
            goto error;
 
229
         } else {
 
230
            sge_gdi_ctx_array[i] = ctx;
 
231
            ctx_index = i;
 
232
            pthread_mutex_unlock(&sge_gdi_ctx_mutex);
 
233
            ret = 0;
 
234
            break;
 
235
         }
 
236
      }
 
237
      i++;
 
238
   }
 
239
   
 
240
   /* for csp system we need the private key and the certificate of the user */
 
241
   ctx->set_private_key(ctx, private_key);
 
242
   ctx->set_certificate(ctx, certificate);
 
243
   
 
244
   ret = ctx->connect(ctx);
 
245
   if (ret != CL_RETVAL_OK) {
 
246
      ctx->get_errors(ctx, &alp, true);
 
247
      throw_error_from_answer_list(env, JGDI_ERROR, alp);
 
248
      ret = -1;
 
249
      goto error;
 
250
   }
 
251
 
 
252
error:
 
253
 
 
254
   if (url != NULL) {
 
255
      (*env)->ReleaseStringUTFChars(env, url_obj, url);
 
256
   }
 
257
   if (username != NULL) {
 
258
      (*env)->ReleaseStringUTFChars(env, username_obj, username);
 
259
   }
 
260
   if (private_key != NULL) {
 
261
      (*env)->ReleaseStringUTFChars(env, private_key_obj, private_key);
 
262
   }
 
263
   if (certificate != NULL) {
 
264
      (*env)->ReleaseStringUTFChars(env, certificate_obj, certificate);
 
265
   }
 
266
   
 
267
   lFreeList(&alp);
 
268
   
 
269
   sge_gdi_set_thread_local_ctx(NULL);
 
270
   if (ret < 0) {
 
271
      if (ctx_index >= 0) {
 
272
         pthread_mutex_lock(&sge_gdi_ctx_mutex);
 
273
         sge_gdi_ctx_array[ctx_index] = NULL;
 
274
         pthread_mutex_unlock(&sge_gdi_ctx_mutex);
 
275
      }
 
276
      sge_gdi_ctx_class_destroy(&ctx);
 
277
   } else {
 
278
      ret = ctx_index;
 
279
   }
 
280
   
 
281
   DRETURN(ret);
 
282
}
 
283
 
 
284
/*
 
285
 * Class:     com_sun_grid_jgdi_JGDI
 
286
 * Method:    nativeGetEnv
 
287
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 
288
 */
 
289
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDI_nativeGetEnv(JNIEnv *env, jobject jgdi, jstring name) {
 
290
   const char * env_name = NULL;
 
291
   char* buf = NULL;
 
292
   
 
293
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDI_nativeGetEnv");
 
294
   
 
295
   if (name == NULL) {
 
296
      DRETURN(NULL);
 
297
   }
 
298
   env_name = (*env)->GetStringUTFChars(env, name, 0);
 
299
   if (env_name == NULL) {
 
300
      DRETURN(NULL);
 
301
   }
 
302
   
 
303
   buf = getenv(env_name);
 
304
 
 
305
   (*env)->ReleaseStringUTFChars(env, name, env_name);
 
306
   
 
307
   if (buf) {
 
308
      DRETURN((*env)->NewStringUTF(env, buf));
 
309
   } else {
 
310
      DRETURN(NULL);
 
311
   }
 
312
}
 
313
 
 
314
jgdi_result_t getGDIContext(JNIEnv *env, jobject jgdi, sge_gdi_ctx_class_t **ctx, lList **alpp) {
 
315
   static jmethodID get_ctx_mid = NULL;
 
316
   int ctx_index = 0;
 
317
 
 
318
   DENTER(JGDI_LAYER, "getGDIContext");
 
319
 
 
320
   if (get_ctx_mid == NULL) {
 
321
      jclass cls = (*env)->GetObjectClass(env, jgdi);
 
322
      
 
323
      get_ctx_mid = get_methodid(env, cls, "getCtxIndex", "()I", alpp);
 
324
      
 
325
      if (get_ctx_mid == NULL) {
 
326
         answer_list_add(alpp, "method getCtxIndex in jgdi class not found", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
327
         DRETURN(JGDI_ILLEGAL_STATE);
 
328
      }
 
329
   }
 
330
   
 
331
   ctx_index = (*env)->CallIntMethod(env, jgdi, get_ctx_mid);
 
332
   if (test_jni_error(env, "getGDIContext failed", alpp)) {
 
333
      DRETURN(JGDI_ILLEGAL_STATE);
 
334
   }
 
335
   
 
336
   *ctx = sge_gdi_ctx_array[ctx_index];
 
337
   DRETURN(JGDI_SUCCESS);
 
338
}
 
339
 
 
340
 
 
341
/*
 
342
 * Class:    com_sun_grid_jgdi_jni_JGDIBaseImpl
 
343
 * Method:    nativeGetActQMaster
 
344
 * Signature: ()Ljava/lang/String;
 
345
 */
 
346
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetActQMaster(JNIEnv *env, jobject jgdi) {
 
347
 
 
348
   lList *alp = NULL;
 
349
   sge_gdi_ctx_class_t *ctx = NULL;
 
350
   sge_bootstrap_state_class_t *bs = NULL;
 
351
   const char* master = NULL;
 
352
   jgdi_result_t ret = JGDI_SUCCESS;
 
353
   
 
354
   DENTER(JGDI_LAYER, "Java_com_sun_grid_jgdi_jni_JGDI_nativeGetActQMaster");
 
355
   
 
356
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS)  {
 
357
      throw_error_from_answer_list(env, ret, alp);
 
358
      lFreeList(&alp);
 
359
      DRETURN(NULL);
 
360
   }
 
361
   bs = ctx->get_sge_bootstrap_state(ctx);
 
362
   if (!bs) {
 
363
      THROW_ERROR((env, JGDI_ILLEGAL_STATE, "bootstrap state not found"));
 
364
      DRETURN(NULL);
 
365
   }
 
366
 
 
367
   master = ctx->get_master(ctx, false);
 
368
   if (master != NULL) {
 
369
      DRETURN((*env)->NewStringUTF(env, master));
 
370
   }
 
371
   DRETURN(NULL);
 
372
   
 
373
}
 
374
 
 
375
/*
 
376
 * Class:     com_sun_grid_jgdi_JGDI
 
377
 * Method:    nativeGetAdminUser
 
378
 * Signature: ()Ljava/lang/String;
 
379
 */
 
380
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetAdminUser(JNIEnv *env, jobject jgdi) {
 
381
   
 
382
   lList *alp = NULL;
 
383
   sge_gdi_ctx_class_t *ctx = NULL;
 
384
   sge_bootstrap_state_class_t *bs = NULL;
 
385
   const char *admin_user = NULL;
 
386
   jgdi_result_t ret = JGDI_SUCCESS;
 
387
   
 
388
   DENTER(JGDI_LAYER, "Java_com_sun_grid_jgdi_jni_JGDI_nativeGetAdminUser");
 
389
 
 
390
   if ((ret=getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
391
      throw_error_from_answer_list(env, ret, alp);
 
392
      lFreeList(&alp);
 
393
      DRETURN(NULL);
 
394
   }
 
395
   bs = ctx->get_sge_bootstrap_state(ctx);
 
396
   if (!bs) {
 
397
      THROW_ERROR((env, JGDI_ILLEGAL_STATE, "bootstrap state not found"));
 
398
      DRETURN(NULL);
 
399
   }
 
400
 
 
401
   admin_user = bs->get_admin_user(bs);
 
402
   if (admin_user != NULL) {
 
403
      DRETURN((*env)->NewStringUTF(env, admin_user));
 
404
   }
 
405
   DRETURN(NULL);
 
406
}
 
407
 
 
408
 
 
409
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetSGERoot(JNIEnv *env, jobject jgdi) {
 
410
   lList *alp = NULL;
 
411
   sge_gdi_ctx_class_t *ctx = NULL;
 
412
   const char *sge_root = NULL;
 
413
   jgdi_result_t ret = JGDI_SUCCESS;
 
414
   
 
415
   DENTER(JGDI_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetSGERoot");
 
416
 
 
417
   if ((ret=getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
418
      throw_error_from_answer_list(env, ret, alp);
 
419
      lFreeList(&alp);
 
420
      DRETURN(NULL);
 
421
   }
 
422
   sge_root = ctx->get_sge_root(ctx);
 
423
   if (sge_root != NULL) {
 
424
      DRETURN((*env)->NewStringUTF(env, sge_root));
 
425
   }
 
426
   DRETURN(NULL);
 
427
}
 
428
 
 
429
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetSGECell(JNIEnv *env, jobject jgdi) {
 
430
   lList *alp = NULL;
 
431
   sge_gdi_ctx_class_t *ctx = NULL;
 
432
   const char *sge_cell = NULL;
 
433
   jgdi_result_t ret = JGDI_SUCCESS;
 
434
   
 
435
   DENTER(JGDI_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetSGECell");
 
436
 
 
437
   if ((ret=getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
438
      throw_error_from_answer_list(env, ret, alp);
 
439
      lFreeList(&alp);
 
440
      DRETURN(NULL);
 
441
   }
 
442
   sge_cell = ctx->get_cell_root(ctx);
 
443
   if (sge_cell != NULL) {
 
444
      DRETURN((*env)->NewStringUTF(env, sge_cell));
 
445
   }
 
446
   DRETURN(NULL);
 
447
}
 
448
 
 
449
jgdi_result_t listelem_to_obj(JNIEnv *env, lListElem *ep, jobject *obj, const lDescr* descr, jclass clazz, lList **alpp) {
 
450
   jobject obj_descr = NULL;
 
451
   jgdi_result_t ret = JGDI_SUCCESS;
 
452
   jint prop_count;
 
453
   int i;
 
454
 
 
455
   DENTER(JGDI_LAYER, "listelem_to_obj");
 
456
 
 
457
   if (obj == NULL) {
 
458
      answer_list_add(alpp, "listelem_to_obj: obj must not be null", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
459
      DRETURN(JGDI_NULL_POINTER);
 
460
   }
 
461
 
 
462
   /* If the elem is NULL, we simple return NULL */
 
463
   if (ep == NULL) {
 
464
       *obj = NULL;
 
465
       DRETURN(ret);
 
466
   }
 
467
   
 
468
   /* Get the descriptor class of the bean class */
 
469
   if ((ret=Util_static_getDescriptor(env, clazz, &obj_descr, alpp)) != JGDI_SUCCESS) {
 
470
      DRETURN(ret);
 
471
   }
 
472
 
 
473
   /* Create a new instance of the class by its class descriptor */
 
474
   if ((ret=ClassDescriptor_newInstance(env, obj_descr, obj, alpp)) != JGDI_SUCCESS) {
 
475
      DRETURN(ret);
 
476
   }
 
477
   
 
478
   /* get the property count */
 
479
   if ((ret=ClassDescriptor_getPropertyCount(env, obj_descr, &prop_count, alpp)) != JGDI_SUCCESS) {
 
480
      DRETURN(ret);
 
481
   }
 
482
   
 
483
   /* fill all property fields */
 
484
   for (i = 0; i < prop_count; i++) {
 
485
     jobject prop_descr = NULL;
 
486
     if ((ret=ClassDescriptor_getProperty(env, obj_descr, i, &prop_descr, alpp)) != JGDI_SUCCESS) {
 
487
        DRETURN(ret);
 
488
     }
 
489
     if ((ret=set_object_attribute(env, ep, descr, *obj, prop_descr, alpp)) != JGDI_SUCCESS) {
 
490
        DRETURN(ret);
 
491
     }
 
492
   }
 
493
 
 
494
   DRETURN(ret);
 
495
}
 
496
 
 
497
jgdi_result_t obj_to_listelem(JNIEnv *env, jobject obj, lListElem **elem, const lDescr* descr, lList **alpp) {
 
498
   jobject obj_descr;
 
499
   jint prop_count;
 
500
   int i;
 
501
   jobject prop_descr;
 
502
   jclass clazz;
 
503
   jgdi_result_t ret = JGDI_SUCCESS;
 
504
 
 
505
   DENTER(JGDI_LAYER, "obj_to_listelem");
 
506
   
 
507
   if (obj == NULL) {
 
508
      *elem = NULL;
 
509
      ret = JGDI_SUCCESS;
 
510
      goto error;
 
511
   }
 
512
   
 
513
   if ((ret = Object_getClass(env, obj, &clazz, alpp)) != JGDI_SUCCESS) {
 
514
      goto error;
 
515
   }
 
516
 
 
517
   /* Get the descriptor class of the bean class */
 
518
   if ((ret=Util_static_getDescriptor(env, clazz, &obj_descr, alpp)) != JGDI_SUCCESS) {
 
519
      goto error;
 
520
   }
 
521
 
 
522
   /* Create a new instance of the class by its class descriptor */
 
523
   *elem = lCreateElem(descr);
 
524
   if (!(*elem)) {
 
525
      answer_list_add(alpp, "lCreateElem failed", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
526
      ret = JGDI_ILLEGAL_STATE;
 
527
      goto error;
 
528
   }
 
529
   
 
530
   /* get the property count */
 
531
   if ((ret=ClassDescriptor_getPropertyCount(env, obj_descr, &prop_count, alpp)) != JGDI_SUCCESS) {
 
532
      goto error;
 
533
   }
 
534
   
 
535
   for (i = 0; i < prop_count; i++) {
 
536
     jboolean is_set = false;
 
537
 
 
538
     if ((ret=ClassDescriptor_getProperty(env, obj_descr, i, &prop_descr, alpp)) != JGDI_SUCCESS) {
 
539
        goto error;
 
540
     }
 
541
     if ((ret=PropertyDescriptor_isSet(env, prop_descr, obj, &is_set, alpp)) != JGDI_SUCCESS) {
 
542
        goto error;
 
543
     }
 
544
     if (is_set == true) {
 
545
        if ((ret=set_elem_attribute(env, *elem, descr, obj, prop_descr, alpp)) != JGDI_SUCCESS) {
 
546
           goto error;
 
547
        }
 
548
     }
 
549
   }
 
550
#if 0 
 
551
{
 
552
   lInit(nmv);
 
553
   lWriteElemTo(*elem, stdout);
 
554
}
 
555
#endif
 
556
 
 
557
error:
 
558
 
 
559
   if (ret != JGDI_SUCCESS) {
 
560
      lFreeElem(elem);
 
561
   }
 
562
   DRETURN(ret);
 
563
}
 
564
 
 
565
/**
 
566
 *   set a attribute of a java object into a cull element
 
567
 *   @param  elem          the cull object
 
568
 *   @param  target        java object
 
569
 *   @param  prop_descr the property descriptor
 
570
 */
 
571
jgdi_result_t set_elem_attribute(JNIEnv* env, lListElem *ep, const lDescr* descr, jobject obj, jobject prop_descr, lList **alpp) {
 
572
   jclass object_class;
 
573
   int pos, type = lEndT;
 
574
   jstring property_name_str;
 
575
   const char* property_name;
 
576
   bool unknown_type=false;
 
577
   jint elem_field_name;
 
578
   jgdi_result_t result = JGDI_SUCCESS;
 
579
   
 
580
   DENTER(BASIS_LAYER, "set_elem_attribute");
 
581
   
 
582
   if (obj == NULL) {
 
583
      answer_list_add(alpp, "set_elem_attribute: obj is NULL, can't call GetObjectClass(env, NULL)", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
584
      DRETURN(JGDI_ILLEGAL_STATE);
 
585
   }
 
586
   object_class = (*env)->GetObjectClass(env, obj);
 
587
 
 
588
   if (PropertyDescriptor_getPropertyName(env, prop_descr, &property_name_str, alpp) != JGDI_SUCCESS) {
 
589
      DRETURN(JGDI_ERROR);
 
590
   }
 
591
   if (property_name_str == NULL) {
 
592
       answer_list_add(alpp, "set_elem_attribute: property_name_str is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
593
       DRETURN(JGDI_ILLEGAL_STATE);
 
594
   }
 
595
   
 
596
   if (PropertyDescriptor_getCullFieldName(env, prop_descr, &elem_field_name, alpp) != JGDI_SUCCESS) {
 
597
      DRETURN(JGDI_ERROR);
 
598
   }
 
599
   if (elem_field_name == 0) {
 
600
       answer_list_add(alpp, "set_elem_attribute: elem_field_name is 0", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
601
       DRETURN(JGDI_ILLEGAL_STATE);
 
602
   }
 
603
   
 
604
   property_name = (*env)->GetStringUTFChars(env, property_name_str, 0);
 
605
   if (property_name == NULL) {
 
606
       answer_list_add(alpp, "set_elem_attribute: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
607
       DRETURN(JGDI_ERROR);
 
608
   }
 
609
   
 
610
   pos = lGetPosInDescr(descr, elem_field_name);
 
611
   if (pos < 0) {
 
612
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
613
                              "field %s not found in descriptor", lNm2Str(elem_field_name));
 
614
      DRETURN(JGDI_ILLEGAL_STATE);
 
615
   }
 
616
   
 
617
   type = lGetPosType(descr, pos);
 
618
   
 
619
   switch (type) {
 
620
      case lBoolT:
 
621
         {
 
622
            lBool b;
 
623
            result = get_bool(env, object_class, obj, property_name, &b, alpp);
 
624
            if (result == JGDI_SUCCESS)  {
 
625
               lSetPosBool(ep, pos, b);
 
626
            }
 
627
            break;
 
628
         }
 
629
      case lUlongT:
 
630
         {
 
631
            u_long32 u;
 
632
            result = get_int(env, object_class, obj, property_name, &u, alpp);
 
633
            if (result == JGDI_SUCCESS)  {
 
634
               lSetPosUlong(ep, pos, u);
 
635
            }
 
636
            break;
 
637
         }
 
638
      case lLongT:
 
639
         {
 
640
            lLong u;
 
641
            result = get_long(env, object_class, obj, property_name, &u, alpp);
 
642
            if (result == JGDI_SUCCESS)  {
 
643
               lSetPosLong(ep, pos, u);
 
644
            }
 
645
            break;
 
646
         }
 
647
      case lStringT:
 
648
         {
 
649
            char* str = NULL;
 
650
            result = get_string(env, object_class, obj, property_name, &str, alpp);
 
651
            if (result == JGDI_SUCCESS)  {
 
652
               lSetPosString(ep, pos, str);
 
653
               FREE(str);
 
654
            } else {
 
655
               lSetPosString(ep, pos, NULL);
 
656
            }            
 
657
            break;
 
658
         }
 
659
      case lHostT:
 
660
         {
 
661
            char* str = NULL;
 
662
            result = get_string(env, object_class, obj, property_name, &str, alpp);
 
663
            if (result == JGDI_SUCCESS)  {
 
664
               lSetPosHost(ep, pos, str);
 
665
               FREE(str);
 
666
            } else {
 
667
               lSetPosHost(ep, pos, NULL);
 
668
            }            
 
669
            break;
 
670
         }
 
671
      case lDoubleT:
 
672
         {
 
673
            double value;
 
674
            result = get_double(env, object_class, obj, property_name, &value, alpp);
 
675
            if (result == JGDI_SUCCESS)  {
 
676
               lSetPosDouble(ep, pos, value);
 
677
            }
 
678
            break;
 
679
         }
 
680
      case lFloatT:
 
681
         {
 
682
            float value;
 
683
            result = get_float(env, object_class, obj, property_name, &value, alpp);
 
684
            if (result == JGDI_SUCCESS)  {
 
685
               lSetPosFloat(ep, pos, value);
 
686
            }
 
687
            break;
 
688
         }
 
689
      case lListT:
 
690
         {
 
691
           jclass map_prop_descr_class;
 
692
           jclass map_list_prop_descr_class;
 
693
           jclass prop_descr_class; 
 
694
           jboolean is_map;
 
695
           lList *list = NULL;
 
696
           jboolean is_map_list;
 
697
           
 
698
           map_prop_descr_class = MapPropertyDescriptor_find_class(env, alpp);
 
699
           if (map_prop_descr_class == NULL) {
 
700
              result = JGDI_ERROR;
 
701
              break;
 
702
           } 
 
703
           
 
704
           map_list_prop_descr_class = MapListPropertyDescriptor_find_class(env, alpp);
 
705
           if (map_list_prop_descr_class == NULL) {
 
706
              result = JGDI_ERROR;
 
707
              break;
 
708
           } 
 
709
 
 
710
           if (Object_getClass(env, prop_descr, &prop_descr_class, alpp) != JGDI_SUCCESS) {
 
711
              result = JGDI_ERROR;
 
712
              break;
 
713
           }
 
714
 
 
715
           if (Class_isAssignableFrom(env, map_list_prop_descr_class, prop_descr_class, &is_map_list, alpp) != JGDI_SUCCESS) {
 
716
              result = JGDI_ERROR;
 
717
              break;
 
718
           }
 
719
           if (Class_isAssignableFrom(env, map_prop_descr_class, prop_descr_class, &is_map, alpp) != JGDI_SUCCESS) {
 
720
              result = JGDI_ERROR;
 
721
              break;
 
722
           }
 
723
 
 
724
           if (is_map_list) {
 
725
              result = get_map_list(env, object_class, obj, prop_descr, &list, alpp);
 
726
           } else if (is_map) {
 
727
              result = get_map(env, object_class, obj, prop_descr, &list, alpp);
 
728
           } else {
 
729
              result = get_list(env, object_class, obj, prop_descr, &list, alpp);
 
730
           }
 
731
           if (result == JGDI_SUCCESS) {
 
732
              lSetPosList(ep, pos, list);
 
733
           }
 
734
           break;
 
735
         }
 
736
      case lObjectT:
 
737
         {
 
738
           jclass prop_descr_class; 
 
739
           lObject cob = NULL;
 
740
           
 
741
           if (Object_getClass(env, prop_descr, &prop_descr_class, alpp) != JGDI_SUCCESS) {
 
742
              result = JGDI_ERROR;
 
743
              break;
 
744
           }
 
745
 
 
746
           result = get_object(env, object_class, obj, prop_descr, &cob, alpp);
 
747
 
 
748
           if (result == JGDI_SUCCESS) {
 
749
              lSetPosObject(ep, pos, cob);
 
750
           }
 
751
           break;
 
752
         }
 
753
      case lRefT:
 
754
         /* TODO implement reference converion */
 
755
         break;
 
756
      case lEndT:
 
757
         /* Attribute not set in cull object, skip it */
 
758
         /* TODO set flag in java object */
 
759
         break;
 
760
      default:
 
761
        /* error handling */
 
762
        unknown_type = true;
 
763
   }
 
764
   
 
765
   if (property_name) {
 
766
      (*env)->ReleaseStringUTFChars(env, property_name_str, property_name);
 
767
   }
 
768
   
 
769
   if (unknown_type) {
 
770
     answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
771
                             "unknown cull type %d found", type);
 
772
     DRETURN(JGDI_ERROR);
 
773
   }
 
774
 
 
775
   DRETURN(result);
 
776
}
 
777
 
 
778
/**
 
779
 *   set a attribute of a cull object into the java object
 
780
 *   @param  elem          the cull object
 
781
 *   @param  target        java object
 
782
 *   @param  prop_descr the property descriptor
 
783
 */
 
784
jgdi_result_t set_object_attribute(JNIEnv* env, lListElem *ep, const lDescr* descr, jobject target, jobject prop_descr, lList **alpp) {
 
785
   jclass target_class;
 
786
   int pos, type = lEndT;
 
787
   jstring property_name_str;
 
788
   const char* property_name;
 
789
   bool unknown_type=false;
 
790
   jint elem_field_name;
 
791
   jgdi_result_t result = JGDI_SUCCESS;
 
792
   
 
793
   DENTER(BASIS_LAYER, "set_object_attribute");
 
794
 
 
795
   target_class = (*env)->GetObjectClass(env, target);
 
796
   if (!target_class) {
 
797
      DRETURN(JGDI_ERROR);
 
798
   }
 
799
   if ((result = PropertyDescriptor_getPropertyName(env, prop_descr, &property_name_str, alpp)) != JGDI_SUCCESS) {
 
800
      DRETURN(result);
 
801
   }
 
802
   if (property_name_str == NULL) {
 
803
       answer_list_add(alpp, "set_object_attribute: property_name_str is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
804
       DRETURN(JGDI_ERROR);
 
805
   }
 
806
   
 
807
   if ((result = PropertyDescriptor_getCullFieldName(env, prop_descr, &elem_field_name, alpp)) != JGDI_SUCCESS) {
 
808
      DRETURN(result);
 
809
   }
 
810
   if (elem_field_name == 0) {
 
811
       answer_list_add(alpp, "set_object_attribute: elem_field_name is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
812
       DRETURN(JGDI_ILLEGAL_STATE);
 
813
   }
 
814
   
 
815
   property_name = (*env)->GetStringUTFChars(env, property_name_str, 0);
 
816
   if (property_name == NULL) {
 
817
      answer_list_add(alpp, "set_object_attribute: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
818
      DRETURN(JGDI_ERROR);
 
819
   }
 
820
   
 
821
   pos = lGetPosInDescr(descr, elem_field_name);
 
822
   if (pos < 0) {
 
823
#if 0   
 
824
      /* 
 
825
      ** AA TODO: for reduced descr, a field may not be available 
 
826
      **     how to we handle this correctly ?
 
827
      **     java obj has more props than specific cull obj
 
828
      **       
 
829
      */
 
830
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
831
                              "field %s not found in descriptor", lNm2Str(elem_field_name));
 
832
      DRETURN(JGDI_ILLEGAL_STATE);
 
833
#else
 
834
      DRETURN(result);
 
835
#endif
 
836
   }
 
837
   
 
838
   jgdi_log_printf(env, JGDI_LOGGER, FINER, "Convert property %s", property_name);
 
839
   
 
840
   type = lGetPosType(descr, pos);
 
841
   
 
842
   switch (type) {
 
843
      case lBoolT:
 
844
         {
 
845
            lBool b = lGetPosBool(ep, pos);
 
846
            result = set_bool(env, target_class, target, property_name, b, alpp);
 
847
            break;
 
848
         }
 
849
      case lUlongT:
 
850
         {
 
851
            u_long32 u = lGetPosUlong(ep, pos);
 
852
            result = set_int(env, target_class, target, property_name, u, alpp);
 
853
            break;
 
854
         }
 
855
      case lLongT:
 
856
         {
 
857
            lLong u = lGetPosLong(ep, pos);
 
858
            result = set_long(env, target_class, target, property_name, u, alpp);
 
859
            break;
 
860
         }
 
861
      case lStringT:
 
862
         {
 
863
            const char* str = lGetPosString(ep,pos);
 
864
            result = set_string(env, target_class, target, property_name, str, alpp);
 
865
            break;
 
866
         }
 
867
      case lHostT:
 
868
         {
 
869
            const char* str = lGetPosHost(ep,pos);
 
870
            result = set_string(env, target_class, target, property_name, str, alpp);
 
871
            break;
 
872
         }
 
873
      case lDoubleT:
 
874
         {
 
875
            double value = lGetPosDouble(ep,pos);
 
876
            result = set_double(env, target_class, target, property_name, value, alpp);
 
877
            break;
 
878
         }
 
879
      case lFloatT:
 
880
         {
 
881
            float value = lGetPosFloat(ep,pos);
 
882
            result = set_float(env, target_class, target, property_name, value, alpp);
 
883
            break;
 
884
         }
 
885
      case lListT:
 
886
         {
 
887
           lList* list = lGetPosList(ep, pos);
 
888
           
 
889
           jclass map_prop_descr_class;
 
890
           jclass map_list_prop_descr_class;
 
891
           jclass prop_descr_class; 
 
892
           jboolean is_map;
 
893
           jboolean is_map_list;
 
894
           
 
895
           map_prop_descr_class = MapPropertyDescriptor_find_class(env, alpp);
 
896
           if (map_prop_descr_class == NULL) {
 
897
              result = JGDI_ERROR;
 
898
              break;
 
899
           }     
 
900
           
 
901
           map_list_prop_descr_class = MapListPropertyDescriptor_find_class(env, alpp);
 
902
           if (map_list_prop_descr_class == NULL) {
 
903
              result = JGDI_ERROR;
 
904
              break;
 
905
           } 
 
906
 
 
907
           if (Object_getClass(env, prop_descr, &prop_descr_class, alpp) != JGDI_SUCCESS) {
 
908
              result = JGDI_ERROR;
 
909
              break;
 
910
           }
 
911
 
 
912
           if (Class_isAssignableFrom(env, map_list_prop_descr_class, prop_descr_class, &is_map_list, alpp) != JGDI_SUCCESS) {
 
913
              result = JGDI_ERROR;
 
914
              break;
 
915
           }
 
916
           
 
917
           if (Class_isAssignableFrom(env, map_prop_descr_class, prop_descr_class, &is_map, alpp) != JGDI_SUCCESS) {
 
918
              result = JGDI_ERROR;
 
919
              break;
 
920
           }
 
921
           
 
922
           if (is_map_list) {
 
923
              jgdi_log_printf(env, JGDI_LOGGER, FINER, "Property %s is a map list", property_name);
 
924
              
 
925
              result = set_map_list(env, target_class, target, prop_descr, list, alpp);
 
926
              if (result != JGDI_SUCCESS) {
 
927
                 answer_list_add_sprintf(alpp,  STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
928
                                         "set_object_attribute: set_map_list of property %s failed", 
 
929
                                         property_name);
 
930
              }
 
931
           } else if (is_map) {
 
932
              jgdi_log_printf(env, JGDI_LOGGER, FINER, "Property %s is a map", property_name);
 
933
 
 
934
              result = set_map(env, target_class, target, prop_descr, list, alpp);
 
935
              if (result != JGDI_SUCCESS) {
 
936
                 answer_list_add_sprintf(alpp,  STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
937
                                         "set_object_attribute: set_map of property %s failed", 
 
938
                                         property_name);
 
939
              }
 
940
           } else {
 
941
/* TODO handle primitive types in set_list */                 
 
942
              jgdi_log_printf(env, JGDI_LOGGER, FINER, "Property %s is a list", property_name);
 
943
              if (result != JGDI_SUCCESS) {
 
944
                 break;
 
945
              }
 
946
              result = set_list(env, target_class, target, prop_descr, list, alpp);
 
947
              if (result != JGDI_SUCCESS) {
 
948
                 answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
949
                                         "set_object_attribute: set_list of property %s failed", 
 
950
                                         property_name);
 
951
              }
 
952
           }
 
953
           break;
 
954
         }
 
955
      case lObjectT:
 
956
         {
 
957
           lObject cob = lGetPosObject(ep,pos);
 
958
           
 
959
           if (cob) {
 
960
              jclass prop_descr_class; 
 
961
              
 
962
              if (Object_getClass(env, prop_descr, &prop_descr_class, alpp) != JGDI_SUCCESS) {
 
963
                 result = JGDI_ERROR;
 
964
                 break;
 
965
              }
 
966
              jgdi_log_printf(env, JGDI_LOGGER, FINER, "Property %s is an object", property_name);
 
967
              result = set_object(env, target_class, target, prop_descr, cob, alpp);
 
968
              if (result != JGDI_SUCCESS) {
 
969
                 answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
970
                                         "set_object_attribute: set_object of property %s failed", 
 
971
                                         property_name);
 
972
              }
 
973
           }
 
974
           break;
 
975
         }
 
976
      case lEndT:
 
977
         /* Attribute not set in cull object, skip it */
 
978
         /* TODO set flag in java object */
 
979
         break;
 
980
      default:
 
981
        /* error handling */
 
982
        unknown_type = true;
 
983
   }
 
984
   
 
985
   if (property_name) {
 
986
      (*env)->ReleaseStringUTFChars(env, property_name_str, property_name);
 
987
   }
 
988
   
 
989
   if (unknown_type) {
 
990
     answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
991
                             "unknown cull type %d found", type);
 
992
     DRETURN(JGDI_ERROR);
 
993
   }
 
994
 
 
995
   DRETURN(result);
 
996
}
 
997
 
 
998
 
 
999
static jgdi_result_t get_map(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList **list, lList **alpp) 
 
1000
{
 
1001
 
 
1002
   jobject    iter = NULL;
 
1003
   jobject key_set = NULL;
 
1004
   jint        key_field_name;
 
1005
   int        key_field_pos;
 
1006
   int        key_field_type;
 
1007
   jint        value_field_name;
 
1008
   lList      *tmp_list = NULL;
 
1009
   jboolean   has_next = false;
 
1010
   lDescr     *descr = NULL;
 
1011
   jgdi_result_t        ret = JGDI_SUCCESS;
 
1012
   
 
1013
   DENTER(BASIS_LAYER, "get_map");
 
1014
 
 
1015
   if ((ret=MapPropertyDescriptor_getKeys(env, property_descr, bean, &key_set, alpp)) != JGDI_SUCCESS) {
 
1016
      DRETURN(ret);
 
1017
   }
 
1018
 
 
1019
   if ((ret=MapPropertyDescriptor_getKeyCullFieldName(env, property_descr, &key_field_name, alpp)) != JGDI_SUCCESS) {
 
1020
      DRETURN(ret);
 
1021
   }
 
1022
 
 
1023
   if ((ret=MapPropertyDescriptor_getValueCullFieldName(env, property_descr, &value_field_name, alpp)) != JGDI_SUCCESS) {
 
1024
      DRETURN(ret);
 
1025
   }
 
1026
 
 
1027
   if ((ret=Set_iterator(env, key_set, &iter, alpp)) != JGDI_SUCCESS) {
 
1028
      DRETURN(ret);
 
1029
   }
 
1030
   
 
1031
   if ((ret = get_descriptor_for_property(env, property_descr, &descr, alpp)) != JGDI_SUCCESS) {
 
1032
      DRETURN(ret);
 
1033
   }
 
1034
   
 
1035
   key_field_pos = lGetPosInDescr(descr, key_field_name);
 
1036
   if (key_field_pos < 0) {
 
1037
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1038
                              "key field %s not found in descriptor", lNm2Str(key_field_pos));
 
1039
      DRETURN(JGDI_ILLEGAL_STATE);
 
1040
   }
 
1041
   
 
1042
   key_field_type = lGetPosType(descr, key_field_pos);
 
1043
 
 
1044
   if ((ret=Iterator_hasNext(env, iter, &has_next, alpp)) != JGDI_SUCCESS) {
 
1045
      DRETURN(ret);
 
1046
   } else if (has_next == false) {
 
1047
      /* intialize the default value with an empty list */
 
1048
      jstring key_obj;
 
1049
      const char* key;
 
1050
      lListElem *elem = NULL;
 
1051
      
 
1052
      if ((ret=MapPropertyDescriptor_getDefaultKey(env, property_descr, &key_obj, alpp)) != JGDI_SUCCESS) {
 
1053
         DRETURN(ret);
 
1054
      }
 
1055
 
 
1056
      if (key_obj == NULL) {
 
1057
         answer_list_add(alpp, "get_map: key_obj is NULL (1)", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1058
         DRETURN(JGDI_ILLEGAL_STATE);
 
1059
      }
 
1060
      
 
1061
      *list = lCreateList("", descr);
 
1062
      if (!*list) {
 
1063
         answer_list_add(alpp, "lCreateList failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1064
         DRETURN(JGDI_ILLEGAL_STATE);
 
1065
      }
 
1066
         
 
1067
      elem =  lCreateElem(descr);
 
1068
      if (!elem) {
 
1069
         answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1070
         lFreeList(list);
 
1071
         DRETURN(JGDI_ILLEGAL_STATE);
 
1072
      }
 
1073
 
 
1074
      lAppendElem(*list, elem);
 
1075
      
 
1076
      key = (*env)->GetStringUTFChars(env, key_obj, 0);
 
1077
      if (key == NULL) {
 
1078
         answer_list_add(alpp, "get_map: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1079
         lFreeList(list);
 
1080
         DRETURN(JGDI_ERROR);
 
1081
      }
 
1082
      switch(key_field_type) {
 
1083
         case lHostT:
 
1084
            lSetPosHost(elem, key_field_pos, key);
 
1085
            break;
 
1086
         case lStringT:
 
1087
            lSetPosString(elem, key_field_pos, key);
 
1088
            break;
 
1089
         default:
 
1090
            answer_list_add(alpp, "type key field must be string or host", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1091
            ret = JGDI_ERROR;
 
1092
      }
 
1093
      (*env)->ReleaseStringUTFChars(env, key_obj, key);
 
1094
      if (ret != JGDI_SUCCESS) {
 
1095
         lFreeList(list);
 
1096
         DRETURN(ret);
 
1097
      }
 
1098
      DRETURN(JGDI_SUCCESS);
 
1099
   } else {
 
1100
      int value_field_pos;
 
1101
      int value_field_type;
 
1102
      jboolean  has_cull_wrapper = false;
 
1103
      jint      content_field_name = 0;
 
1104
      int       content_field_type = lEndT;
 
1105
      int       content_field_pos = lEndT;
 
1106
 
 
1107
      value_field_pos = lGetPosInDescr(descr, value_field_name);
 
1108
      if (value_field_pos < 0) {
 
1109
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1110
                                 "value field %s not found in descriptor", lNm2Str(value_field_name));
 
1111
         DRETURN(JGDI_ILLEGAL_STATE);
 
1112
      }
 
1113
      
 
1114
      value_field_type = lGetPosType(descr, value_field_pos);
 
1115
      
 
1116
      if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
1117
         DRETURN(ret);
 
1118
      }
 
1119
      
 
1120
      if (has_cull_wrapper) {
 
1121
         if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
1122
            DRETURN(ret);
 
1123
         }
 
1124
         if (content_field_name >= 0) {
 
1125
            content_field_pos = lGetPosInDescr(&descr[value_field_pos], content_field_name);
 
1126
            if (content_field_pos < 0) {
 
1127
               answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1128
                                       "content field %s not found in descriptor", lNm2Str(content_field_name));
 
1129
               DRETURN(JGDI_ILLEGAL_STATE);
 
1130
            }
 
1131
            content_field_type = lGetPosType(&descr[value_field_pos], content_field_pos);
 
1132
         }
 
1133
      }
 
1134
      
 
1135
      
 
1136
      tmp_list = lCreateList("", descr);
 
1137
      if (!tmp_list) {
 
1138
         answer_list_add(alpp, "lCreateList failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1139
         DRETURN(JGDI_ERROR);
 
1140
      }
 
1141
      while (TRUE) {
 
1142
         lListElem *elem;
 
1143
         jstring key_obj;
 
1144
         jobject value_obj;
 
1145
         const char* key;
 
1146
         
 
1147
         if ((ret=Iterator_hasNext(env, iter, &has_next, alpp)) != JGDI_SUCCESS) {
 
1148
            break;
 
1149
         } else if (has_next == false) {
 
1150
            break;
 
1151
         }
 
1152
 
 
1153
         if ((ret=Iterator_next(env, iter, &key_obj, alpp)) != JGDI_SUCCESS) {
 
1154
            break;
 
1155
         }
 
1156
         if ((ret=MapPropertyDescriptor_get(env, property_descr, bean, key_obj, &value_obj, alpp)) != JGDI_SUCCESS) {
 
1157
            break;
 
1158
         }
 
1159
         if (key_obj == NULL) {
 
1160
            answer_list_add(alpp, "get_map: key_obj is NULL (2)", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1161
            ret = JGDI_ILLEGAL_STATE;
 
1162
            break;
 
1163
         }
 
1164
         
 
1165
         elem = lCreateElem(descr);
 
1166
         if (elem == NULL) {
 
1167
            answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1168
            ret = JGDI_ILLEGAL_STATE;
 
1169
            break;
 
1170
         }
 
1171
         
 
1172
         lAppendElem(tmp_list, elem);
 
1173
 
 
1174
         key = (*env)->GetStringUTFChars(env, key_obj, 0);
 
1175
         if (key == NULL) {
 
1176
            answer_list_add(alpp, "get_map: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1177
            ret = JGDI_ERROR;
 
1178
            break;
 
1179
         }
 
1180
         switch(key_field_type) {
 
1181
            case lStringT:
 
1182
              lSetPosString(elem, key_field_pos, key);
 
1183
              break;
 
1184
            case lHostT:
 
1185
              lSetPosHost(elem, key_field_pos, key);
 
1186
              break;
 
1187
            default:
 
1188
              answer_list_add(alpp, "type key field must be string or host", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1189
              ret = JGDI_ERROR;
 
1190
         }                
 
1191
         (*env)->ReleaseStringUTFChars(env, key_obj, key);
 
1192
         if (ret != JGDI_SUCCESS) {
 
1193
            break;
 
1194
         }
 
1195
         
 
1196
         if (has_cull_wrapper) {
 
1197
            lListElem *sub_elem = lCreateElem(&descr[value_field_pos]);
 
1198
            if (sub_elem == NULL) {
 
1199
               answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1200
               ret = JGDI_ILLEGAL_STATE;
 
1201
               break;
 
1202
            }
 
1203
 
 
1204
            if ((ret=set_value_in_elem(env, value_obj, sub_elem, content_field_type, content_field_pos, alpp)) != JGDI_SUCCESS) {
 
1205
               lFreeElem(&sub_elem);
 
1206
               break;
 
1207
            }
 
1208
            lSetPosObject(elem, content_field_pos, sub_elem);
 
1209
         } else {
 
1210
            if ((ret=set_value_in_elem(env, value_obj, elem, value_field_type, value_field_pos, alpp)) != JGDI_SUCCESS) {
 
1211
               break;
 
1212
            }
 
1213
         }
 
1214
      }
 
1215
   }
 
1216
   
 
1217
   if (ret != JGDI_SUCCESS) {
 
1218
      lFreeList(&tmp_list);
 
1219
      DRETURN(ret);
 
1220
   } else {
 
1221
      *list = tmp_list;
 
1222
      DRETURN(JGDI_SUCCESS);
 
1223
   }
 
1224
}
 
1225
 
 
1226
static jgdi_result_t set_map_list(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList *lp, lList **alpp)
 
1227
{
 
1228
 
 
1229
   const lDescr*   descr;
 
1230
   lDescr*   elem_descr;
 
1231
   lListElem* ep = NULL;
 
1232
   jint key_field_name;
 
1233
   int key_field_pos;
 
1234
   int key_field_type;
 
1235
   jint value_field_name;
 
1236
   int value_field_pos;
 
1237
   jclass elem_class;
 
1238
   const char* elem_class_name = NULL;
 
1239
   char property_name[512];
 
1240
   jboolean has_cull_wrapper = false;
 
1241
   jint content_field_name = 0;
 
1242
   int  content_field_pos = lEndT;
 
1243
   int  content_field_type = 0;
 
1244
   jgdi_result_t  ret = JGDI_SUCCESS;
 
1245
 
 
1246
   DENTER(BASIS_LAYER, "set_map_list");
 
1247
 
 
1248
   {
 
1249
      jstring property_name_obj = NULL;
 
1250
      const char* tmp_property_name = NULL;
 
1251
      if ((ret=PropertyDescriptor_getPropertyName(env, property_descr, &property_name_obj, alpp)) != JGDI_SUCCESS) {
 
1252
         DRETURN(ret);
 
1253
      }
 
1254
      if (property_name_obj == NULL) {
 
1255
         answer_list_add(alpp, "set_map_list: property_name_obj is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1256
         DRETURN(JGDI_ILLEGAL_STATE);
 
1257
      }
 
1258
      tmp_property_name = (*env)->GetStringUTFChars(env, property_name_obj, 0);
 
1259
      if (tmp_property_name == NULL) {
 
1260
         answer_list_add(alpp, "set_map_list: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1261
         DRETURN(JGDI_ERROR);
 
1262
      }
 
1263
      strncpy(property_name, tmp_property_name, sizeof(tmp_property_name) - 1);
 
1264
      (*env)->ReleaseStringUTFChars(env, property_name_obj, tmp_property_name);
 
1265
   }
 
1266
   
 
1267
   if ((ret=MapListPropertyDescriptor_getKeyCullFieldName(env, property_descr, &key_field_name, alpp)) != JGDI_SUCCESS) {
 
1268
      DRETURN(ret);
 
1269
   }
 
1270
   
 
1271
   if ((ret=MapListPropertyDescriptor_getValueCullFieldName(env, property_descr, &value_field_name, alpp)) != JGDI_SUCCESS) {
 
1272
      DRETURN(ret);
 
1273
   }
 
1274
   
 
1275
   if (lp == NULL) {
 
1276
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1277
                              "property %s cannot be an empty list", property_name);
 
1278
      DRETURN(JGDI_NULL_POINTER);
 
1279
   }
 
1280
 
 
1281
   descr = lGetListDescr(lp);
 
1282
   
 
1283
   ret = get_list_descriptor_for_property(env, property_descr, &elem_descr, alpp); 
 
1284
   if (ret != JGDI_SUCCESS) {
 
1285
      DRETURN(ret);
 
1286
   }
 
1287
   
 
1288
   elem_class_name = get_classname_for_descr(elem_descr);
 
1289
   if (elem_class_name == NULL) {
 
1290
      answer_list_add(alpp, "set_map_list: class name for elem_descr not found", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1291
      DRETURN(JGDI_ERROR);
 
1292
   }
 
1293
   
 
1294
   elem_class = (*env)->FindClass(env, elem_class_name);
 
1295
   if (test_jni_error(env, "", NULL)) {
 
1296
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1297
                              "set_map_list: class %s for elem_descr not found", elem_class_name);
 
1298
      DRETURN(JGDI_ERROR);
 
1299
   }
 
1300
   key_field_pos = lGetPosInDescr(descr, key_field_name);
 
1301
   if (key_field_pos < 0) {
 
1302
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1303
                              "key field %s not found in descriptor", lNm2Str(key_field_name));
 
1304
      DRETURN(JGDI_ILLEGAL_STATE);
 
1305
   }
 
1306
   
 
1307
   key_field_type =  lGetPosType(descr, key_field_pos);
 
1308
   
 
1309
   value_field_pos = lGetPosInDescr(descr, value_field_name);
 
1310
   if (value_field_pos < 0) {
 
1311
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1312
                              "value field %s not found in descriptor", lNm2Str(value_field_name));
 
1313
      DRETURN(JGDI_ILLEGAL_STATE);
 
1314
   }
 
1315
   
 
1316
   if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
1317
      DRETURN(ret);
 
1318
   }
 
1319
   if (has_cull_wrapper == true) {
 
1320
      DPRINTF(("Property %s has a cull wrapper\n", property_name));
 
1321
      if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
1322
         DRETURN(ret);
 
1323
      }
 
1324
   } else {
 
1325
      DPRINTF(("Property %s has no cull wrapper\n", property_name));
 
1326
   }
 
1327
   
 
1328
   for_each(ep, lp) {
 
1329
      lList  *sub_list = lGetPosList(ep, value_field_pos);
 
1330
      lListElem *sub_ep = NULL;
 
1331
      const char *key = NULL;
 
1332
      jstring key_obj = NULL;
 
1333
      int value_count = 0;
 
1334
      switch(key_field_type) {
 
1335
         case lStringT:
 
1336
            key = lGetPosString(ep, key_field_pos);
 
1337
            break;
 
1338
         case lHostT:
 
1339
            key = lGetPosHost(ep, key_field_pos);
 
1340
            break;
 
1341
         default:
 
1342
            answer_list_add(alpp, "key of a map must be of type String or Host", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1343
            DRETURN(JGDI_ERROR);
 
1344
      }
 
1345
      key_obj = (*env)->NewStringUTF(env, key);
 
1346
      
 
1347
      for_each(sub_ep, sub_list) {
 
1348
         jobject value_obj = NULL;
 
1349
         if (has_cull_wrapper == true) {
 
1350
            
 
1351
            if (content_field_pos == lEndT) {
 
1352
               content_field_pos = lGetPosInDescr(sub_ep->descr, content_field_name);
 
1353
               if (content_field_pos < 0) {
 
1354
                  answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, 
 
1355
                                          "content field %s not found in descriptor", lNm2Str(content_field_name));
 
1356
                  DRETURN(JGDI_ILLEGAL_STATE);
 
1357
               }
 
1358
               content_field_type = lGetPosType(sub_ep->descr, content_field_pos);
 
1359
            }
 
1360
            if ((ret = create_object_from_elem(env, sub_ep, &value_obj, content_field_type, content_field_pos, alpp)) != JGDI_SUCCESS) {
 
1361
               DRETURN(ret);
 
1362
            }
 
1363
         } else {
 
1364
            if ((ret = listelem_to_obj(env, sub_ep, &value_obj, elem_descr, elem_class, alpp)) != JGDI_SUCCESS) {
 
1365
               DRETURN(ret);
 
1366
            }
 
1367
         }
 
1368
         if (value_obj != NULL) {
 
1369
            if ((ret=MapListPropertyDescriptor_add(env, property_descr, bean, key_obj, value_obj, alpp)) != JGDI_SUCCESS) {
 
1370
               DRETURN(ret);
 
1371
            }
 
1372
            value_count++;
 
1373
         } else {
 
1374
            /* skip NULL value_obj */
 
1375
         }   
 
1376
      }
 
1377
      if (value_count == 0) {
 
1378
         if ((ret=MapListPropertyDescriptor_addEmpty(env, property_descr, bean, key_obj, alpp)) != JGDI_SUCCESS) {
 
1379
            DRETURN(ret);
 
1380
         }
 
1381
      }
 
1382
   }
 
1383
 
 
1384
   DRETURN(JGDI_SUCCESS);
 
1385
}
 
1386
 
 
1387
static jgdi_result_t get_map_list(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList **list, lList **alpp) 
 
1388
{
 
1389
 
 
1390
   jclass    property_descr_class = NULL;
 
1391
   jobject   iter = NULL;
 
1392
   jobject   key_set = NULL;
 
1393
   jint      key_field_name = 0;
 
1394
   int       key_field_pos = lEndT;
 
1395
   int       key_field_type = 0;
 
1396
   jint      value_field_name = 0;
 
1397
   lList     *tmp_list = NULL;
 
1398
   char      property_name[100];
 
1399
   jboolean  has_next = false;
 
1400
   lDescr    *descr = NULL;
 
1401
   jgdi_result_t       ret = JGDI_SUCCESS;
 
1402
 
 
1403
   DENTER(BASIS_LAYER, "get_map_list");
 
1404
   
 
1405
   {
 
1406
      jstring property_name_obj = NULL;
 
1407
      const char* tmp_name = NULL;
 
1408
      lInit(nmv);
 
1409
      if ((ret=PropertyDescriptor_getPropertyName(env, property_descr, &property_name_obj, alpp)) != JGDI_SUCCESS) {
 
1410
         DRETURN(ret);
 
1411
      }
 
1412
      if (property_name_obj == NULL) {
 
1413
         answer_list_add(alpp, "get_map_list: property_name_obj is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1414
         DRETURN(JGDI_ILLEGAL_STATE);
 
1415
      }
 
1416
      tmp_name = (*env)->GetStringUTFChars(env, property_name_obj, 0);
 
1417
      if (tmp_name == NULL) {
 
1418
         answer_list_add(alpp, "get_map_list: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1419
         DRETURN(JGDI_ERROR);
 
1420
      }
 
1421
      strncpy(property_name, tmp_name, 100);
 
1422
      (*env)->ReleaseStringUTFChars(env, property_name_obj, tmp_name);
 
1423
   }
 
1424
   
 
1425
   if ((ret=Object_getClass(env, property_descr, &property_descr_class, alpp)) != JGDI_SUCCESS) {
 
1426
      DRETURN(ret);
 
1427
   }
 
1428
 
 
1429
   if ((ret=MapListPropertyDescriptor_getKeys(env, property_descr, bean, &key_set, alpp)) != JGDI_SUCCESS) {
 
1430
      DRETURN(ret);
 
1431
   }
 
1432
 
 
1433
   if ((ret=MapListPropertyDescriptor_getKeyCullFieldName(env, property_descr, &key_field_name, alpp)) != JGDI_SUCCESS) {
 
1434
      DRETURN(ret);
 
1435
   }
 
1436
 
 
1437
   if ((ret=MapListPropertyDescriptor_getValueCullFieldName(env, property_descr, &value_field_name, alpp)) != JGDI_SUCCESS) {
 
1438
      DRETURN(ret);
 
1439
   }
 
1440
 
 
1441
   if ((ret=get_descriptor_for_property(env, property_descr, &descr, alpp)) != JGDI_SUCCESS) {
 
1442
      DRETURN(ret);
 
1443
   }
 
1444
   
 
1445
   key_field_pos = lGetPosInDescr(descr, key_field_name);
 
1446
   if (key_field_pos < 0) {
 
1447
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1448
                              "field %s not found in desriptor of property %s",
 
1449
                              lNm2Str(key_field_name), property_name); 
 
1450
      DRETURN(JGDI_ERROR);
 
1451
   }
 
1452
 
 
1453
   key_field_type = lGetPosType(descr, key_field_pos);
 
1454
 
 
1455
   if ((ret = Set_iterator(env, key_set, &iter, alpp)) != JGDI_SUCCESS) {
 
1456
      DRETURN(ret);
 
1457
   }
 
1458
   
 
1459
   if ((ret=Iterator_hasNext(env, iter, &has_next, alpp)) != JGDI_SUCCESS) {
 
1460
      DRETURN(ret);
 
1461
   }
 
1462
   
 
1463
   if (has_next == 0) {
 
1464
      /* new have empty map */
 
1465
      /* intialize the default value with an empty list */
 
1466
      jstring key_obj;
 
1467
      const char* key;
 
1468
      lListElem *elem = NULL;
 
1469
      
 
1470
      if ((ret=MapListPropertyDescriptor_getDefaultKey(env, property_descr, &key_obj, alpp)) != JGDI_SUCCESS) {
 
1471
         DRETURN(ret);
 
1472
      }
 
1473
      if (key_obj == NULL) {
 
1474
         answer_list_add(alpp, "get_map_list: key_obj is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1475
         DRETURN(JGDI_ILLEGAL_STATE);
 
1476
      }
 
1477
      *list = lCreateList("", descr);
 
1478
      if (!*list) {
 
1479
         answer_list_add(alpp, "lCreateList failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1480
         DRETURN(JGDI_ERROR);
 
1481
      }
 
1482
         
 
1483
      elem =  lCreateElem(descr);
 
1484
      if (!elem) {
 
1485
         answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1486
         lFreeList(list);
 
1487
         DRETURN(JGDI_ILLEGAL_STATE);
 
1488
      }
 
1489
         
 
1490
      key = (*env)->GetStringUTFChars(env, key_obj, 0);
 
1491
      if (key == NULL) {
 
1492
         answer_list_add(alpp, "get_map_list: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1493
         lFreeList(list);
 
1494
         lFreeElem(&elem);
 
1495
         DRETURN(JGDI_ERROR);
 
1496
      }
 
1497
      switch(key_field_type) {
 
1498
         case lHostT:
 
1499
            lSetPosHost(elem, key_field_pos, key);
 
1500
            break;
 
1501
         case lStringT:
 
1502
            lSetPosString(elem, key_field_pos, key);
 
1503
            break;
 
1504
         default:
 
1505
            answer_list_add(alpp, "type key field must be string or host", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1506
            ret = JGDI_ERROR;
 
1507
      }
 
1508
      (*env)->ReleaseStringUTFChars(env, key_obj, key);
 
1509
      if (ret != JGDI_SUCCESS) {
 
1510
         lFreeList(list);
 
1511
         lFreeElem(&elem);
 
1512
      } else {
 
1513
         lAppendElem(*list, elem);
 
1514
      }
 
1515
      DRETURN(ret);
 
1516
   } else {
 
1517
      int value_field_pos;
 
1518
      int key_field_name_pos;
 
1519
      lDescr    *elem_descr = NULL;
 
1520
 
 
1521
      jboolean  has_cull_wrapper = false;
 
1522
      jint      content_field_name = 0;
 
1523
      int       content_field_type = lEndT;
 
1524
      int       content_field_pos = lEndT;
 
1525
 
 
1526
      value_field_pos = lGetPosInDescr(descr, value_field_name);
 
1527
      if (value_field_pos < 0) {
 
1528
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1529
                                 "value field %s not found", lNm2Str(value_field_name));
 
1530
         DRETURN(JGDI_ERROR);
 
1531
      }
 
1532
      
 
1533
      
 
1534
      key_field_name_pos = lGetPosInDescr(descr, key_field_name);
 
1535
      if (key_field_name_pos < 0) {
 
1536
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1537
                                 "key field %s not found", lNm2Str(key_field_name));
 
1538
         DRETURN(JGDI_ERROR);
 
1539
      }
 
1540
      
 
1541
      ret = get_list_descriptor_for_property(env, property_descr, &elem_descr, alpp);
 
1542
      if (ret != JGDI_SUCCESS) {
 
1543
         DRETURN(JGDI_ERROR);
 
1544
      }
 
1545
      
 
1546
      if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
1547
         DRETURN(ret);
 
1548
      }
 
1549
      
 
1550
      if (has_cull_wrapper) {
 
1551
         if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
1552
            DRETURN(ret);
 
1553
         }
 
1554
         if (content_field_name >= 0) {
 
1555
            content_field_pos = lGetPosInDescr(elem_descr, content_field_name);
 
1556
            if (content_field_pos < 0) {
 
1557
               answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, 
 
1558
                                       "content field %s not found in descriptor", lNm2Str(content_field_name));
 
1559
               DRETURN(JGDI_ILLEGAL_STATE);
 
1560
            }
 
1561
            content_field_type = lGetPosType(elem_descr, content_field_pos);
 
1562
         }
 
1563
      }
 
1564
      
 
1565
      
 
1566
      tmp_list = lCreateList("", descr);
 
1567
      if (!tmp_list) {
 
1568
         answer_list_add(alpp, "lCreateList failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1569
         DRETURN(JGDI_ILLEGAL_STATE);
 
1570
      }
 
1571
      
 
1572
      while (TRUE) {
 
1573
         jstring key_obj;
 
1574
         jobject value_list = NULL;
 
1575
         jobject value_iter = NULL;
 
1576
         jboolean has_next_value = false;
 
1577
         const char *key;
 
1578
         lListElem *elem = NULL;
 
1579
         
 
1580
         if ((ret=Iterator_hasNext(env, iter, &has_next, alpp)) != JGDI_SUCCESS) {
 
1581
            break;
 
1582
         } 
 
1583
         
 
1584
         if (has_next == 0) {
 
1585
            break;
 
1586
         }
 
1587
 
 
1588
         if ((ret=Iterator_next(env, iter, &key_obj, alpp)) != JGDI_SUCCESS) {
 
1589
            break;
 
1590
         }
 
1591
         if (key_obj == NULL) {
 
1592
            answer_list_add(alpp, "get_map_list: key_obj is NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1593
            ret = JGDI_ILLEGAL_STATE;
 
1594
            break;
 
1595
         }
 
1596
         
 
1597
         if ((ret=MapListPropertyDescriptor_getList(env, property_descr, bean, key_obj, &value_list, alpp)) != JGDI_SUCCESS) {
 
1598
            break;
 
1599
         }
 
1600
         if ((ret=List_iterator(env, value_list, &value_iter, alpp)) != JGDI_SUCCESS) {
 
1601
            break;
 
1602
         }
 
1603
 
 
1604
         if ((ret=Iterator_hasNext(env, value_iter, &has_next_value, alpp)) != JGDI_SUCCESS) {
 
1605
            break;
 
1606
         }
 
1607
         
 
1608
         /*
 
1609
         ** there is always an element added for a map list
 
1610
         ** it is appended to tmp_list to free also the element
 
1611
         ** in case of error
 
1612
         */
 
1613
         elem = lCreateElem(descr);
 
1614
         if (!elem) {
 
1615
            answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1616
            ret = JGDI_ILLEGAL_STATE;
 
1617
            break;
 
1618
         }
 
1619
         lAppendElem(tmp_list, elem);
 
1620
 
 
1621
         if (has_next_value) {
 
1622
            lList     *value_list = NULL;
 
1623
            value_list = lCreateList("", elem_descr);
 
1624
            if (!value_list) {
 
1625
               answer_list_add(alpp, "lCreateList failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1626
               ret = JGDI_ILLEGAL_STATE;
 
1627
               break;
 
1628
            }
 
1629
            
 
1630
            while (has_next_value) {
 
1631
               jobject value_obj;
 
1632
               lListElem *value_elem = NULL;
 
1633
               
 
1634
               if ((ret=Iterator_next(env, value_iter, &value_obj, alpp)) != JGDI_SUCCESS) {
 
1635
                  break;
 
1636
               }
 
1637
               if (value_obj != NULL) {
 
1638
                  if (has_cull_wrapper) {
 
1639
                     value_elem = lCreateElem(elem_descr);
 
1640
                     if (!value_elem) {
 
1641
                        answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1642
                        ret = JGDI_ILLEGAL_STATE;
 
1643
                        break;
 
1644
                     }
 
1645
                     if ((ret=set_value_in_elem(env, value_obj, value_elem, content_field_type, content_field_pos, alpp)) != JGDI_SUCCESS) {
 
1646
                        lFreeElem(&value_elem);
 
1647
                        break;
 
1648
                     }
 
1649
                  } else {
 
1650
                     if ((ret=obj_to_listelem(env, value_obj, &value_elem, elem_descr, alpp)) != JGDI_SUCCESS) {
 
1651
                        break;
 
1652
                     }
 
1653
                  }
 
1654
                  lAppendElem(value_list, value_elem);
 
1655
               }
 
1656
 
 
1657
               if ((ret=Iterator_hasNext(env, value_iter, &has_next_value, alpp)) != JGDI_SUCCESS) {
 
1658
                  break;
 
1659
               }
 
1660
            }
 
1661
            if (ret != JGDI_SUCCESS) {
 
1662
               lFreeList(&value_list);
 
1663
               break;
 
1664
            }
 
1665
            
 
1666
            if (lGetNumberOfElem(value_list) > 0) {
 
1667
               lSetPosList(elem, value_field_pos, value_list);
 
1668
            } else {
 
1669
               lFreeList(&value_list);
 
1670
               lSetPosList(elem, value_field_pos, NULL);
 
1671
            }
 
1672
         } else { /*not has_next_value */
 
1673
            lSetPosList(elem, value_field_pos, NULL);
 
1674
         }
 
1675
 
 
1676
         key = (*env)->GetStringUTFChars(env, key_obj, 0);
 
1677
         if (key == NULL) {
 
1678
            answer_list_add(alpp, "get_map_list: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1679
            ret = JGDI_ILLEGAL_STATE;
 
1680
            break;
 
1681
         }
 
1682
         
 
1683
         switch(key_field_type) {
 
1684
            case lHostT:
 
1685
               lSetPosHost(elem, key_field_pos, key);
 
1686
               break;
 
1687
            case lStringT:
 
1688
               lSetPosString(elem, key_field_pos, key);
 
1689
               break;
 
1690
            default:
 
1691
               answer_list_add(alpp, "type key field must be string or host", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1692
               ret = JGDI_ILLEGAL_STATE;
 
1693
         }
 
1694
         (*env)->ReleaseStringUTFChars(env, key_obj, key);
 
1695
         
 
1696
         if (ret != JGDI_SUCCESS) {
 
1697
            break;
 
1698
         }
 
1699
      }
 
1700
   }
 
1701
   
 
1702
   if (ret != JGDI_SUCCESS) {
 
1703
     lFreeList(&tmp_list);
 
1704
     DRETURN(ret);
 
1705
   } else {
 
1706
     *list = tmp_list;
 
1707
     DRETURN(JGDI_SUCCESS);
 
1708
   }
 
1709
}
 
1710
 
 
1711
 
 
1712
static jgdi_result_t create_object_from_elem(JNIEnv *env, lListElem *ep, jobject *value_obj, int cullType, int pos, lList **alpp) {
 
1713
   
 
1714
   jgdi_result_t ret = JGDI_SUCCESS;
 
1715
   
 
1716
   DENTER(JGDI_LAYER, "create_object_from_elem");
 
1717
   
 
1718
   switch(cullType) {
 
1719
         case lBoolT:
 
1720
            {
 
1721
               lBool value = lGetPosBool(ep, pos);
 
1722
               if ((ret=Boolean_init(env, value_obj, (jboolean)value, alpp)) != JGDI_SUCCESS) {
 
1723
                  DRETURN(ret);
 
1724
               }
 
1725
               break;
 
1726
            }
 
1727
         case lUlongT:
 
1728
            {
 
1729
               u_long32 value = lGetPosUlong(ep, pos);
 
1730
               
 
1731
               if ((ret = Integer_init(env, value_obj, (jint)value, alpp)) != JGDI_SUCCESS) {
 
1732
                  DRETURN(ret);
 
1733
               }
 
1734
               break;
 
1735
            }
 
1736
         case lLongT:
 
1737
            {
 
1738
               lLong value = lGetPosLong(ep, pos);
 
1739
               if ((ret = Long_init_0(env, value_obj, (jlong)value, alpp)) != JGDI_SUCCESS) {
 
1740
                  DRETURN(ret);
 
1741
               }
 
1742
               break;
 
1743
            }
 
1744
         case lDoubleT:
 
1745
            {
 
1746
               lDouble value = lGetPosDouble(ep, pos);
 
1747
               
 
1748
               if ((ret = Double_init(env, value_obj, (jdouble)value, alpp)) != JGDI_SUCCESS) {
 
1749
                  DRETURN(ret);
 
1750
               }
 
1751
               break;
 
1752
            }
 
1753
         case lFloatT:
 
1754
            {
 
1755
               lDouble value = lGetPosDouble(ep, pos);
 
1756
               if ((ret = Float_init(env, value_obj, (jfloat)value, alpp)) != JGDI_SUCCESS) {
 
1757
                  DRETURN(ret);
 
1758
               }
 
1759
               break;
 
1760
            }
 
1761
         case lStringT:
 
1762
            {
 
1763
               const char *value = lGetPosString(ep, pos);
 
1764
               if (value == NULL) {
 
1765
                  *value_obj = (*env)->NewStringUTF(env, "NONE");
 
1766
               } else {
 
1767
                  *value_obj = (*env)->NewStringUTF(env, value);
 
1768
               }   
 
1769
               if (test_jni_error(env, "create_object_from_elem: can not create instanceof java.lang.String", alpp)) {
 
1770
                  DRETURN(JGDI_ERROR);
 
1771
               }
 
1772
               break;
 
1773
            }
 
1774
         case lHostT:
 
1775
            {
 
1776
               const char *value = lGetPosHost(ep, pos);
 
1777
               if (value == NULL) {
 
1778
                  *value_obj = (*env)->NewStringUTF(env, "NONE");
 
1779
               } else {
 
1780
                  *value_obj = (*env)->NewStringUTF(env, value);
 
1781
               }   
 
1782
               if (test_jni_error(env, "create_object_from_elem: can not create instanceof java.lang.String", alpp)) {
 
1783
                  DRETURN(JGDI_ERROR);
 
1784
               }
 
1785
               break;
 
1786
            }
 
1787
         case lObjectT:
 
1788
            {
 
1789
               const lDescr *descr = lGetElemDescr(ep);
 
1790
               object_mapping_t *mapping = get_object_mapping(descr);
 
1791
               
 
1792
               if (mapping != NULL) {
 
1793
                  if ((ret=mapping->elem_to_object(mapping, env, ep, value_obj, alpp)) != JGDI_SUCCESS) {
 
1794
                     DRETURN(ret);
 
1795
                  }
 
1796
               } else {
 
1797
                  answer_list_add(alpp, "No mapping for cull element found", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1798
                  DRETURN(JGDI_ERROR);
 
1799
               }
 
1800
            }
 
1801
            break;
 
1802
         case lListT:
 
1803
            {
 
1804
               /*  value_obj = obj_to_listelem(env, value_obj, descr, alpp); */
 
1805
               answer_list_add(alpp, "create_object_from_elem: lList type not yet implemented", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1806
               DRETURN(JGDI_ERROR);
 
1807
            }
 
1808
         case lEndT:
 
1809
            /* Attribute not set in cull object, skip it */
 
1810
            /* TODO set flag in java object */
 
1811
            break;
 
1812
         default:
 
1813
            /* error handling */
 
1814
            answer_list_add(alpp, "create_object_from_elem: unknown type", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1815
            DRETURN(JGDI_ERROR);
 
1816
   }
 
1817
   DRETURN(JGDI_SUCCESS);
 
1818
}
 
1819
 
 
1820
static jgdi_result_t set_value_in_elem(JNIEnv *env, jobject value_obj, lListElem *elem, int cullType, int pos, lList** alpp) {
 
1821
   
 
1822
   jgdi_result_t ret = JGDI_SUCCESS;
 
1823
   
 
1824
   DENTER(BASIS_LAYER, "set_value_in_elem");
 
1825
   switch (cullType) {
 
1826
      case lBoolT:
 
1827
         {
 
1828
            jboolean value = false;
 
1829
            if ((ret=Boolean_booleanValue(env, value_obj, &value, alpp)) != JGDI_SUCCESS) {
 
1830
               DRETURN(ret);
 
1831
            } else {
 
1832
               lSetPosBool(elem, pos, (bool)value);
 
1833
            }   
 
1834
            break;
 
1835
         }
 
1836
      case lUlongT:
 
1837
         {
 
1838
            jint value = 0;
 
1839
            if ((ret=Number_intValue(env, value_obj, &value, alpp)) != JGDI_SUCCESS) {
 
1840
               DRETURN(ret);
 
1841
            } else {
 
1842
               lSetPosUlong(elem, pos, (u_long32)value);
 
1843
            }   
 
1844
            break;
 
1845
         }
 
1846
      case lLongT:
 
1847
         {
 
1848
            jlong value = 0;
 
1849
            if ((ret=Number_longValue(env, value_obj, &value, alpp)) != JGDI_SUCCESS) {
 
1850
               DRETURN(ret);
 
1851
            } else {
 
1852
               lSetPosLong(elem, pos, (long)value);
 
1853
            }   
 
1854
            break;
 
1855
         }
 
1856
      case lStringT:
 
1857
         {
 
1858
            char *str = NULL;
 
1859
            if (value_obj == NULL) {
 
1860
               lSetPosString(elem, pos, NULL);
 
1861
            } else {
 
1862
               str = (char*) (*env)->GetStringUTFChars(env, (jstring)value_obj, 0);
 
1863
               if (str == NULL) {
 
1864
                  answer_list_add(alpp, "set_object_in_elem: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1865
                  DRETURN(JGDI_ERROR);
 
1866
               }
 
1867
               lSetPosString(elem, pos, str);
 
1868
               (*env)->ReleaseStringUTFChars(env, (jstring)value_obj, str);
 
1869
            }
 
1870
            break;
 
1871
         }
 
1872
      case lHostT:
 
1873
         {
 
1874
            char *str = NULL;
 
1875
            if (value_obj == NULL) {
 
1876
               lSetPosHost(elem, pos, NULL);
 
1877
            } else {
 
1878
               str = (char*) (*env)->GetStringUTFChars(env, (jstring)value_obj, 0);
 
1879
               if (str == NULL) {
 
1880
                  answer_list_add(alpp, "set_object_in_elem: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
1881
                  DRETURN(JGDI_ERROR);
 
1882
               }
 
1883
               lSetPosHost(elem, pos, str);
 
1884
               (*env)->ReleaseStringUTFChars(env, (jstring)value_obj, str);
 
1885
            }
 
1886
            break;
 
1887
         }
 
1888
      case lDoubleT:
 
1889
         {
 
1890
            jdouble value = 0;
 
1891
            if ((ret=Number_doubleValue(env, value_obj, &value, alpp)) != JGDI_SUCCESS) {
 
1892
               DRETURN(ret);
 
1893
            } else {
 
1894
               lSetPosDouble(elem, pos, (double)value);
 
1895
            }   
 
1896
            break;
 
1897
         }
 
1898
      case lFloatT:
 
1899
         {
 
1900
            jfloat value = 0;
 
1901
            if ((ret=Number_floatValue(env, value_obj, &value, alpp)) != JGDI_SUCCESS) {
 
1902
               DRETURN(ret);
 
1903
            } else {
 
1904
               lSetPosDouble(elem, pos, (float)value);
 
1905
            }   
 
1906
            break;
 
1907
         }
 
1908
      case lObjectT:
 
1909
         {
 
1910
            const lDescr *descr = lGetElemDescr(elem);
 
1911
            object_mapping_t *mapping = get_object_mapping(descr);
 
1912
            
 
1913
            if (mapping != NULL) {
 
1914
               if ((ret=mapping->object_to_elem(mapping, env, value_obj, elem, alpp)) != JGDI_SUCCESS) {
 
1915
                  DRETURN(ret);
 
1916
               }
 
1917
            } else {
 
1918
               answer_list_add(alpp, "No mapping for cull element found", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1919
               DRETURN(JGDI_ERROR);
 
1920
            }
 
1921
            break;
 
1922
         }
 
1923
      case lListT:
 
1924
         {
 
1925
            /* value_obj = obj_to_listelem(env, value_obj, descr, alpp); */
 
1926
            answer_list_add(alpp, "get_map: lList type yet not implemented", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1927
            DRETURN(JGDI_ERROR);
 
1928
         }
 
1929
      case lEndT:
 
1930
         /* Attribute not set in cull object, skip it */
 
1931
         /* TODO set flag in java object */
 
1932
         break;
 
1933
      default:
 
1934
        /* error handling */
 
1935
        answer_list_add(alpp, "get_map: unknown type", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
1936
        DRETURN(JGDI_ERROR);
 
1937
   }
 
1938
   DRETURN(JGDI_SUCCESS);
 
1939
}
 
1940
 
 
1941
static jgdi_result_t set_map(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList *lp, lList **alpp)
 
1942
{
 
1943
 
 
1944
   jgdi_result_t ret = JGDI_SUCCESS;
 
1945
 
 
1946
   DENTER(BASIS_LAYER, "set_map");
 
1947
 
 
1948
   if (lp != NULL && lGetNumberOfElem(lp) > 0) {
 
1949
      const lDescr*   descr;
 
1950
      lListElem* ep = NULL;
 
1951
      jint key_field_name;
 
1952
      int key_field_pos;
 
1953
      int key_field_type;
 
1954
      jint value_field_name;
 
1955
      int value_field_pos;
 
1956
      int value_field_type=0;
 
1957
      /* for primitve wrappers */
 
1958
      jint content_field_name = 0;
 
1959
      int  content_field_pos = lEndT;
 
1960
      int  content_field_type = 0;
 
1961
      jboolean has_cull_wrapper = false;
 
1962
 
 
1963
      if ((ret=MapPropertyDescriptor_getKeyCullFieldName(env, property_descr, &key_field_name, alpp)) != JGDI_SUCCESS) {
 
1964
         DRETURN(ret);
 
1965
      }
 
1966
      
 
1967
      if ((ret=MapPropertyDescriptor_getValueCullFieldName(env, property_descr, &value_field_name, alpp)) != JGDI_SUCCESS) {
 
1968
         DRETURN(ret);
 
1969
      }
 
1970
 
 
1971
      descr = lGetListDescr(lp);
 
1972
      
 
1973
      key_field_pos = lGetPosInDescr(descr, key_field_name);
 
1974
      if (key_field_pos < 0) {
 
1975
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1976
                                 "key field %s not found in descriptor", lNm2Str(key_field_name));
 
1977
         DRETURN(JGDI_ILLEGAL_STATE);
 
1978
      }
 
1979
      
 
1980
      key_field_type = lGetPosType(descr,key_field_pos);
 
1981
      
 
1982
      value_field_pos = lGetPosInDescr(descr, value_field_name);
 
1983
      if (value_field_pos < 0) {
 
1984
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
1985
                                 "value field %s not found in descriptor", lNm2Str(value_field_name));
 
1986
         DRETURN(JGDI_ILLEGAL_STATE);
 
1987
      }
 
1988
      
 
1989
      value_field_type = lGetPosType(descr, value_field_pos);
 
1990
      
 
1991
      if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
1992
         DRETURN(ret);
 
1993
      }
 
1994
 
 
1995
      if (has_cull_wrapper == true) {
 
1996
         if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
1997
            DRETURN(ret);
 
1998
         }
 
1999
      }
 
2000
      
 
2001
      for_each(ep, lp) {
 
2002
         jobject value_obj = NULL;
 
2003
         const char *key = NULL;
 
2004
         jstring key_obj = NULL;
 
2005
         
 
2006
         switch(key_field_type) {
 
2007
            case lStringT:
 
2008
               key = lGetPosString(ep, key_field_pos);
 
2009
               break;
 
2010
            case lHostT:
 
2011
               key = lGetPosHost(ep, key_field_pos);
 
2012
               break;
 
2013
            default:
 
2014
               answer_list_add(alpp, "key of a map must be of type String or Host", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2015
               ret = JGDI_ILLEGAL_STATE;
 
2016
         }
 
2017
         
 
2018
         if (ret != JGDI_SUCCESS) {
 
2019
            break;
 
2020
         }
 
2021
         
 
2022
         key_obj = (*env)->NewStringUTF(env, key);
 
2023
         
 
2024
         if (has_cull_wrapper == true) {
 
2025
            lListElem *wrapper = lGetPosObject(ep, value_field_pos);
 
2026
            
 
2027
            if (content_field_pos == lEndT) {
 
2028
               content_field_pos = lGetPosInDescr(wrapper->descr, content_field_name);
 
2029
               if (content_field_pos < 0) {
 
2030
                  answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2031
                                          "content field %s not found in descriptor", lNm2Str(content_field_name));
 
2032
                  DEXIT;
 
2033
                  DRETURN(JGDI_ILLEGAL_STATE);
 
2034
               }
 
2035
               content_field_type = lGetPosType(wrapper->descr, content_field_pos);
 
2036
            }
 
2037
            ret = create_object_from_elem(env, wrapper, &value_obj, content_field_type, content_field_pos, alpp);
 
2038
         } else {
 
2039
            ret = create_object_from_elem(env, ep, &value_obj, value_field_type, value_field_pos, alpp);
 
2040
         }
 
2041
 
 
2042
         if (ret != JGDI_SUCCESS) {
 
2043
            break;
 
2044
         }
 
2045
         
 
2046
         if ((ret=MapPropertyDescriptor_put(env, property_descr, bean, key_obj, value_obj, alpp)) != JGDI_SUCCESS) {
 
2047
            break;
 
2048
         }
 
2049
      }
 
2050
   }
 
2051
 
 
2052
   DRETURN(ret);
 
2053
}
 
2054
 
 
2055
jgdi_result_t get_list(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList**list, lList **alpp) {
 
2056
 
 
2057
   lDescr*    descr;
 
2058
   jint        count;
 
2059
   int        i;
 
2060
   jobject    obj;
 
2061
   lList      *tmp_list = NULL;
 
2062
   lListElem  *ep = NULL;
 
2063
   jboolean  has_cull_wrapper = false;
 
2064
   jint      content_field_name = 0;
 
2065
   int       content_field_type = lEndT;
 
2066
   int       content_field_pos = lEndT;
 
2067
   jgdi_result_t       ret = JGDI_SUCCESS;
 
2068
   
 
2069
   DENTER(BASIS_LAYER, "get_list");
 
2070
 
 
2071
   if ((ret=get_descriptor_for_property(env, property_descr, &descr, alpp)) != JGDI_SUCCESS) {
 
2072
      DRETURN(ret);
 
2073
   }
 
2074
 
 
2075
   if ((ret=ListPropertyDescriptor_getCount(env, property_descr, bean, &count, alpp)) != JGDI_SUCCESS) {
 
2076
      DRETURN(ret);
 
2077
   }
 
2078
   
 
2079
   if (count == 0) {
 
2080
      /* new have an empty list */
 
2081
      *list = NULL;
 
2082
      DRETURN(JGDI_SUCCESS);
 
2083
   }
 
2084
 
 
2085
   if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
2086
      DRETURN(ret);
 
2087
   }
 
2088
 
 
2089
   if (has_cull_wrapper) {
 
2090
      if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
2091
         DRETURN(ret);
 
2092
      }
 
2093
      content_field_pos = lGetPosInDescr(descr, content_field_name);
 
2094
      if (content_field_pos < 0) {
 
2095
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2096
                                 "content field %s not found in descriptor", lNm2Str(content_field_name));
 
2097
         DRETURN(JGDI_ILLEGAL_STATE);
 
2098
      }
 
2099
      content_field_type =lGetPosType(descr, content_field_pos);
 
2100
      if (content_field_type == lEndT) {
 
2101
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2102
                                 "type of content field of attr %s not found", lNm2Str(content_field_name));
 
2103
         DRETURN(JGDI_ILLEGAL_STATE);
 
2104
      }
 
2105
   }
 
2106
   
 
2107
   tmp_list = lCreateList("", descr);
 
2108
   if (!tmp_list) {
 
2109
      answer_list_add(alpp, "lCreateList failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
2110
      DRETURN(JGDI_ERROR);
 
2111
   }
 
2112
   
 
2113
 
 
2114
   for(i = 0; i < count; i++) {
 
2115
      if ((ret=ListPropertyDescriptor_get(env, property_descr, bean, i, &obj, alpp)) != JGDI_SUCCESS) {
 
2116
         break;
 
2117
      }
 
2118
      if (has_cull_wrapper) {
 
2119
         ep = lCreateElem(descr);
 
2120
         if ((ret=set_value_in_elem(env, obj, ep, content_field_type, content_field_pos, alpp)) != JGDI_SUCCESS) {
 
2121
            lFreeElem(&ep);
 
2122
            break;
 
2123
         }
 
2124
      } else if ((ret=obj_to_listelem(env, obj, &ep, descr, alpp)) != JGDI_SUCCESS) {
 
2125
         break;
 
2126
      }
 
2127
      lAppendElem(tmp_list, ep);
 
2128
   }
 
2129
   
 
2130
   if (ret != JGDI_SUCCESS) {
 
2131
      lFreeList(&tmp_list);
 
2132
      DRETURN(ret);
 
2133
   } else {
 
2134
      *list = tmp_list;
 
2135
      DRETURN(JGDI_SUCCESS);
 
2136
   }
 
2137
}
 
2138
 
 
2139
jgdi_result_t set_list(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lList *lp, lList **alpp) {
 
2140
 
 
2141
   jclass    property_class;
 
2142
   jgdi_result_t  ret = JGDI_SUCCESS;
 
2143
   
 
2144
   DENTER(BASIS_LAYER, "set_list");
 
2145
 
 
2146
   if ((ret=PropertyDescriptor_getPropertyType(env, property_descr, &property_class, alpp)) != JGDI_SUCCESS) {
 
2147
      DRETURN(ret);
 
2148
   }
 
2149
   
 
2150
   if (lGetNumberOfElem(lp) > 0) {
 
2151
      const lDescr* descr;
 
2152
      lListElem* ep = NULL;
 
2153
      /* for primitive wrappers */
 
2154
      jint content_field_name = 0;
 
2155
      int  content_field_pos = lEndT;
 
2156
      int  content_field_type = 0;
 
2157
      jboolean has_cull_wrapper = false;
 
2158
 
 
2159
      descr = lGetListDescr(lp);
 
2160
 
 
2161
      if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
2162
         DRETURN(ret);
 
2163
      }
 
2164
      if (has_cull_wrapper == true) {
 
2165
         if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
2166
            DRETURN(ret);
 
2167
         }
 
2168
      }
 
2169
  
 
2170
      for_each(ep,lp) {
 
2171
         jobject obj = NULL;
 
2172
 
 
2173
         if (has_cull_wrapper == true) {
 
2174
            if (content_field_pos == lEndT) {
 
2175
               content_field_pos = lGetPosInDescr(descr, (jint)content_field_name);
 
2176
               if (content_field_pos < 0) {
 
2177
                  answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, 
 
2178
                                          "content field %s not found in descriptor", lNm2Str(content_field_name));
 
2179
                  DRETURN(JGDI_ILLEGAL_STATE);
 
2180
               }
 
2181
               content_field_type = lGetPosType(descr, content_field_pos);
 
2182
            }
 
2183
            ret = create_object_from_elem(env, ep, &obj, content_field_type, content_field_pos, alpp);
 
2184
         } else {
 
2185
            ret = listelem_to_obj(env, ep, &obj, descr, property_class, alpp);
 
2186
         }
 
2187
         
 
2188
         if (ret != JGDI_SUCCESS) {
 
2189
            DRETURN(ret);
 
2190
         }
 
2191
         if ((ret=ListPropertyDescriptor_add(env, property_descr, bean, obj, alpp)) != JGDI_SUCCESS) {
 
2192
            DRETURN(ret);
 
2193
         }
 
2194
      }   
 
2195
   } else {
 
2196
      jgdi_log_printf(env, JGDI_LOGGER, FINER, "set_list: is empty list");
 
2197
   }
 
2198
 
 
2199
   DRETURN(ret);
 
2200
}
 
2201
 
 
2202
static jgdi_result_t get_object(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lObject *cob, lList **alpp) {
 
2203
 
 
2204
   lDescr*    descr;
 
2205
   jobject    obj;
 
2206
   lListElem* ep;
 
2207
   jboolean  has_cull_wrapper = false;
 
2208
   jint      content_field_name = 0;
 
2209
   int       content_field_type = lEndT;
 
2210
   int       content_field_pos = lEndT;
 
2211
   jgdi_result_t       ret = JGDI_SUCCESS;
 
2212
   
 
2213
   DENTER(BASIS_LAYER, "get_object");
 
2214
 
 
2215
   if ((ret=get_descriptor_for_property(env, property_descr, &descr, alpp)) != JGDI_SUCCESS) {
 
2216
      DRETURN(ret);
 
2217
   }
 
2218
 
 
2219
   ret = SimplePropertyDescriptor_getValue(env, property_descr, bean, &obj, alpp);
 
2220
 
 
2221
   if (ret != JGDI_SUCCESS) {
 
2222
      DRETURN(ret);
 
2223
   }
 
2224
 
 
2225
   if (obj == NULL) {
 
2226
      /* new have an empty object */
 
2227
      *cob = NULL;
 
2228
      DRETURN(JGDI_SUCCESS);
 
2229
   }
 
2230
 
 
2231
   
 
2232
   if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
2233
      DRETURN(ret);
 
2234
   }
 
2235
   if (has_cull_wrapper) {
 
2236
      if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
2237
         DRETURN(ret);
 
2238
      }
 
2239
      content_field_pos = lGetPosInDescr(descr, content_field_name);
 
2240
      if (content_field_pos < 0) {
 
2241
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2242
                                 "content field %s not found in descriptor", lNm2Str(content_field_name));
 
2243
         DRETURN(JGDI_ILLEGAL_STATE);
 
2244
      }
 
2245
      content_field_type = lGetPosType(descr, content_field_pos);
 
2246
      if (content_field_type == lEndT) {
 
2247
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2248
                                 "type of content field of attr %s not found", lNm2Str(content_field_name));
 
2249
         DRETURN(JGDI_ILLEGAL_STATE);
 
2250
      }
 
2251
      ep = lCreateElem(descr);
 
2252
      if (!ep) {
 
2253
         answer_list_add(alpp, "lCreateElem failed", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
2254
         DRETURN(JGDI_ILLEGAL_STATE);
 
2255
      }
 
2256
      ret=set_value_in_elem(env, obj, ep, content_field_type, content_field_pos, alpp);
 
2257
   } else {
 
2258
      ret=obj_to_listelem(env, obj, &ep, descr, alpp);
 
2259
   }
 
2260
 
 
2261
   if (ret != JGDI_SUCCESS) {
 
2262
      lFreeElem(&ep);
 
2263
      DRETURN(ret);
 
2264
   } else {
 
2265
      *cob = ep;
 
2266
      DRETURN(JGDI_SUCCESS);
 
2267
   }
 
2268
}
 
2269
 
 
2270
static jgdi_result_t set_object(JNIEnv *env, jclass bean_class, jobject bean, jobject property_descr, lObject cob, lList **alpp) {
 
2271
 
 
2272
   jobject   obj;
 
2273
   const lDescr*   descr;
 
2274
   jclass    property_class;
 
2275
 
 
2276
   /* for primitive wrappers */
 
2277
   jint content_field_name = 0;
 
2278
   int  content_field_pos = lEndT;
 
2279
   int  content_field_type = 0;
 
2280
   jboolean has_cull_wrapper = false;
 
2281
   jgdi_result_t  ret = JGDI_SUCCESS;
 
2282
   
 
2283
   DENTER(BASIS_LAYER, "set_object");
 
2284
 
 
2285
   if ((ret=PropertyDescriptor_getPropertyType(env, property_descr, &property_class, alpp)) != JGDI_SUCCESS) {
 
2286
      DEXIT;
 
2287
      DRETURN(ret);
 
2288
   }
 
2289
   
 
2290
   descr = lGetElemDescr(cob);
 
2291
   
 
2292
   if ((ret=PropertyDescriptor_hasCullWrapper(env, property_descr, &has_cull_wrapper, alpp)) != JGDI_SUCCESS) {
 
2293
      DRETURN(ret);
 
2294
   }
 
2295
   if (has_cull_wrapper == true) {
 
2296
      jgdi_log_printf(env, JGDI_LOGGER, FINER, "Property has a cull wrapper");
 
2297
      if (ret != JGDI_SUCCESS) {
 
2298
         DRETURN(ret);
 
2299
      }
 
2300
      
 
2301
      if ((ret=PropertyDescriptor_getCullContentField(env, property_descr, &content_field_name, alpp)) != JGDI_SUCCESS) {
 
2302
         DRETURN(ret);
 
2303
      }
 
2304
      if (content_field_pos == lEndT) {
 
2305
         content_field_pos = lGetPosInDescr(descr, (jint)content_field_name);
 
2306
         if (content_field_pos < 0) {
 
2307
            answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2308
                                    "content field %s not found in descriptor", lNm2Str(content_field_name));
 
2309
            DRETURN(JGDI_ILLEGAL_STATE);
 
2310
         }
 
2311
         content_field_type = lGetPosType(descr, content_field_pos);
 
2312
      }
 
2313
      ret = create_object_from_elem(env, cob, &obj, content_field_type, content_field_pos, alpp);
 
2314
   } else {
 
2315
      ret = listelem_to_obj(env, cob, &obj, descr, property_class, alpp);
 
2316
   }
 
2317
   
 
2318
   jgdi_log_printf(env, JGDI_LOGGER, FINER, "add converter property to list");
 
2319
   
 
2320
   ret=SimplePropertyDescriptor_setValue(env, property_descr, bean, obj, alpp);
 
2321
 
 
2322
   DRETURN(ret);
 
2323
}
 
2324
 
 
2325
jgdi_result_t get_double(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, double *retdou, lList **alpp) {
 
2326
   char buf[1024];
 
2327
   jmethodID mid = NULL;
 
2328
   jdouble jd = 0;
 
2329
 
 
2330
   DENTER(BASIS_LAYER, "get_double");
 
2331
   
 
2332
   sprintf(buf, "get%c%s", toupper(property_name[0]), &property_name[1]);
 
2333
   mid = get_methodid(env, bean_class, buf, "()D", alpp);
 
2334
   if (!mid) {
 
2335
      DRETURN(JGDI_ERROR);
 
2336
   }
 
2337
 
 
2338
   jd = (*env)->CallDoubleMethod(env, obj, mid);
 
2339
   if (test_jni_error(env, "get_double: CallDoubleMethod failed", alpp)) {
 
2340
      DRETURN(JGDI_ERROR);
 
2341
   }
 
2342
 
 
2343
   *retdou = jd;
 
2344
 
 
2345
   DRETURN(JGDI_SUCCESS);
 
2346
}
 
2347
 
 
2348
jgdi_result_t set_double(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, double value, lList **alpp) {
 
2349
   char buf[1024];
 
2350
   jmethodID mid;
 
2351
   
 
2352
   DENTER(BASIS_LAYER, "set_double");
 
2353
   sprintf(buf, "set%c%s", toupper(property_name[0]), &property_name[1]);
 
2354
   mid = get_methodid(env, bean_class, buf, "(D)V", alpp);
 
2355
   if (!mid) {
 
2356
      DRETURN(JGDI_ERROR);
 
2357
   }
 
2358
 
 
2359
   (*env)->CallVoidMethod(env, obj, mid, (jdouble)value);
 
2360
   if (test_jni_error(env, "set_double: CallVoidMethod failed", alpp)) {
 
2361
      DRETURN(JGDI_ERROR);
 
2362
   }
 
2363
 
 
2364
   DRETURN(JGDI_SUCCESS);
 
2365
}
 
2366
 
 
2367
jgdi_result_t get_float(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, float *retfl, lList **alpp) {
 
2368
   char buf[1024];
 
2369
   jmethodID mid = NULL;
 
2370
   jfloat jf = 0;
 
2371
 
 
2372
   DENTER(BASIS_LAYER, "get_float");
 
2373
   
 
2374
   sprintf(buf, "get%c%s", toupper(property_name[0]), &property_name[1]);
 
2375
   mid = get_methodid(env, bean_class, buf, "()F", alpp);
 
2376
   if (!mid) {
 
2377
      DRETURN(JGDI_ERROR);
 
2378
   }
 
2379
 
 
2380
 
 
2381
   jf = (*env)->CallFloatMethod(env, obj, mid);
 
2382
   if (test_jni_error(env, "get_float: CallFloatMethod failed", alpp)) {
 
2383
      DRETURN(JGDI_ERROR);
 
2384
   }
 
2385
 
 
2386
   *retfl = jf;
 
2387
 
 
2388
   DRETURN(JGDI_SUCCESS);
 
2389
}
 
2390
 
 
2391
jgdi_result_t set_float(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, float value, lList **alpp) {
 
2392
   char buf[1024];
 
2393
   jmethodID mid;
 
2394
   
 
2395
   DENTER(BASIS_LAYER, "set_float");
 
2396
   sprintf(buf, "set%c%s", toupper(property_name[0]), &property_name[1]);
 
2397
   mid = get_methodid(env, bean_class, buf, "(F)V", alpp);
 
2398
   if (!mid) {
 
2399
      DRETURN(JGDI_ERROR);
 
2400
   }
 
2401
 
 
2402
   (*env)->CallVoidMethod(env, obj, mid, (jfloat)value);
 
2403
   if (test_jni_error(env, "set_double: CallVoidMethod failed", alpp)) {
 
2404
      DRETURN(JGDI_ERROR);
 
2405
   }
 
2406
 
 
2407
   DRETURN(JGDI_SUCCESS);
 
2408
}
 
2409
 
 
2410
jgdi_result_t get_string(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, char **retstr, lList **alpp) {
 
2411
   char buf[1024];
 
2412
   jmethodID mid = NULL;
 
2413
   jstring jstr;
 
2414
   const char *name = NULL;
 
2415
 
 
2416
   DENTER(BASIS_LAYER, "get_string");
 
2417
   
 
2418
   sprintf(buf, "get%c%s", toupper(property_name[0]), &property_name[1]);
 
2419
   mid = get_methodid(env, bean_class, buf, "()Ljava/lang/String;", alpp);
 
2420
   if (!mid) {
 
2421
      *retstr = NULL;
 
2422
      DRETURN(JGDI_ERROR);
 
2423
   }
 
2424
 
 
2425
   jstr = (jstring) (*env)->CallObjectMethod(env, obj, mid);
 
2426
   if (test_jni_error(env, "get_string: CallObjectMethod failed", alpp)) {
 
2427
      *retstr = NULL;
 
2428
      DRETURN(JGDI_ERROR);
 
2429
   }
 
2430
 
 
2431
   if (jstr == NULL) {
 
2432
      *retstr = NULL;
 
2433
   } else {
 
2434
      name = (*env)->GetStringUTFChars(env, jstr, 0);
 
2435
      if (name == NULL) {
 
2436
         answer_list_add(alpp, "get_string: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
2437
         DRETURN(JGDI_ERROR);
 
2438
      }
 
2439
      *retstr = strdup(name);
 
2440
      (*env)->ReleaseStringUTFChars(env, jstr, name);
 
2441
   }
 
2442
 
 
2443
   DRETURN(JGDI_SUCCESS);
 
2444
}
 
2445
 
 
2446
jgdi_result_t set_string(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, const char* value, lList **alpp) {
 
2447
   char buf[1024];
 
2448
   jmethodID mid = NULL;
 
2449
   jstring str;
 
2450
 
 
2451
   DENTER(BASIS_LAYER, "set_string");
 
2452
   
 
2453
   sprintf(buf, "set%c%s", toupper(property_name[0]), &property_name[1]);
 
2454
   mid = get_methodid(env, bean_class, buf, "(Ljava/lang/String;)V", alpp);
 
2455
   if (!mid) {
 
2456
      DRETURN(JGDI_ERROR);
 
2457
   }
 
2458
 
 
2459
   str = (*env)->NewStringUTF(env, value);
 
2460
   if (test_jni_error(env, "set_string: NewStringUTF failed", alpp)) {
 
2461
      DRETURN(JGDI_ERROR);
 
2462
   }
 
2463
 
 
2464
   (*env)->CallVoidMethod(env, obj, mid, str);
 
2465
   if (test_jni_error(env, "set_string: CallVoidMethod failed", alpp)) {
 
2466
      DRETURN(JGDI_ERROR);
 
2467
   }
 
2468
   
 
2469
   DRETURN(JGDI_SUCCESS);
 
2470
}
 
2471
 
 
2472
jgdi_result_t get_int(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, u_long32 *reti, lList **alpp) {
 
2473
   char buf[1024];
 
2474
   jmethodID mid = NULL;
 
2475
   jint     ji = 0;
 
2476
 
 
2477
   DENTER(BASIS_LAYER, "get_int");
 
2478
   
 
2479
   sprintf(buf, "get%c%s", toupper(property_name[0]), &property_name[1]);
 
2480
   mid = get_methodid(env, bean_class, buf, "()I", alpp);
 
2481
   if (!mid) {
 
2482
      DRETURN(JGDI_ERROR);
 
2483
   }
 
2484
 
 
2485
 
 
2486
   ji = (*env)->CallIntMethod(env, obj, mid);
 
2487
   if (test_jni_error(env, "get_int: CallIntMethod failed", alpp)) {
 
2488
      DRETURN(JGDI_ERROR);
 
2489
   }
 
2490
 
 
2491
   *reti = ji;
 
2492
 
 
2493
   DRETURN(JGDI_SUCCESS);
 
2494
}
 
2495
 
 
2496
jgdi_result_t set_int(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, u_long32 value, lList **alpp) {
 
2497
   char buf[1024];
 
2498
   jmethodID mid = NULL;
 
2499
   
 
2500
   DENTER(BASIS_LAYER, "set_int");
 
2501
   /* jint overflow */
 
2502
   if (value > LONG32_MAX) {
 
2503
      DPRINTF(("set_int: ulong32 to jint overflow (returning -1)\n"));
 
2504
      value = -1;
 
2505
   }
 
2506
   sprintf(buf, "set%c%s", toupper(property_name[0]), &property_name[1]);
 
2507
   mid = get_methodid(env, bean_class, buf, "(I)V", alpp);
 
2508
   if (!mid) {
 
2509
      DRETURN(JGDI_ERROR);
 
2510
   }
 
2511
 
 
2512
   (*env)->CallVoidMethod(env, obj, mid, (jint)value);
 
2513
   if (test_jni_error(env, "set_int: CallVoidMethod failed", alpp)) {
 
2514
      DRETURN(JGDI_ERROR);
 
2515
   }
 
2516
 
 
2517
   DRETURN(JGDI_SUCCESS);
 
2518
}
 
2519
 
 
2520
jgdi_result_t get_long(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, lLong *ret, lList **alpp) {
 
2521
   char buf[1024];
 
2522
   jmethodID mid = NULL;
 
2523
   jlong     jl = 0;
 
2524
 
 
2525
   DENTER(BASIS_LAYER, "get_long");
 
2526
   
 
2527
   sprintf(buf, "get%c%s", toupper(property_name[0]), &property_name[1]);
 
2528
   mid = get_methodid(env, bean_class, buf, "()J", alpp);
 
2529
   if (!mid) {
 
2530
      DRETURN(JGDI_ERROR);
 
2531
   }
 
2532
 
 
2533
   jl = (*env)->CallLongMethod(env, obj, mid);
 
2534
   if (test_jni_error(env, "get_int: CallLongMethod failed", alpp)) {
 
2535
      DRETURN(JGDI_ERROR);
 
2536
   }
 
2537
 
 
2538
   *ret = (lLong)jl;
 
2539
 
 
2540
   DRETURN(JGDI_SUCCESS);
 
2541
}
 
2542
 
 
2543
jgdi_result_t set_long(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, lLong value, lList **alpp) {
 
2544
   char buf[1024];
 
2545
   jmethodID mid = NULL;
 
2546
   
 
2547
   DENTER(BASIS_LAYER, "set_long");
 
2548
 
 
2549
   sprintf(buf, "set%c%s", toupper(property_name[0]), &property_name[1]);
 
2550
   mid = get_methodid(env, bean_class, buf, "(J)V", alpp);
 
2551
   if (!mid) {
 
2552
      DRETURN(JGDI_ERROR);
 
2553
   }
 
2554
 
 
2555
   (*env)->CallVoidMethod(env, obj, mid, (jlong)value);
 
2556
   if (test_jni_error(env, "set_long: CallVoidMethod failed", alpp)) {
 
2557
      DRETURN(JGDI_ERROR);
 
2558
   }
 
2559
 
 
2560
   DRETURN(JGDI_SUCCESS);
 
2561
}
 
2562
 
 
2563
 
 
2564
jgdi_result_t get_bool(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, lBool *retb, lList **alpp) {
 
2565
   char buf[1024];
 
2566
   jmethodID mid = NULL;
 
2567
   jboolean  jb = 0;
 
2568
 
 
2569
   DENTER(BASIS_LAYER, "get_bool");
 
2570
   
 
2571
   sprintf(buf, "is%c%s", toupper(property_name[0]), &property_name[1]);
 
2572
   mid = get_methodid(env, bean_class, buf, "()Z", alpp);
 
2573
   if (!mid) {
 
2574
      DRETURN(JGDI_ERROR);
 
2575
   }
 
2576
 
 
2577
 
 
2578
   jb = (*env)->CallBooleanMethod(env, obj, mid);
 
2579
   if (test_jni_error(env, "get_bool: CallIntMethod failed", alpp)) {
 
2580
      DRETURN(JGDI_ERROR);
 
2581
   }
 
2582
 
 
2583
   jgdi_log_printf(env, JGDI_LOGGER, FINER, "property %s =", property_name, *retb);
 
2584
 
 
2585
   *retb = (lBool)jb;
 
2586
 
 
2587
   DRETURN(JGDI_SUCCESS);
 
2588
}
 
2589
 
 
2590
jgdi_result_t set_bool(JNIEnv *env, jclass bean_class, jobject obj, const char* property_name, lBool value, lList **alpp) {
 
2591
   char buf[1024];
 
2592
   jmethodID mid = NULL;
 
2593
   
 
2594
   DENTER(BASIS_LAYER, "set_bool");
 
2595
 
 
2596
   sprintf(buf, "set%c%s", toupper(property_name[0]), &property_name[1]);
 
2597
   mid = get_methodid(env, bean_class, buf, "(Z)V", alpp);
 
2598
   if (!mid) {
 
2599
      DRETURN(JGDI_ERROR);
 
2600
   }
 
2601
 
 
2602
   (*env)->CallVoidMethod(env, obj, mid, (jboolean)value);
 
2603
   if (test_jni_error(env, "set_bool: CallVoidMethod failed", alpp)) {
 
2604
      DRETURN(JGDI_ERROR);
 
2605
   }
 
2606
 
 
2607
   jgdi_log_printf(env, JGDI_LOGGER, FINER, "property %s =", property_name, value);
 
2608
   
 
2609
   DRETURN(JGDI_SUCCESS);
 
2610
}
 
2611
 
 
2612
 
 
2613
jstring get_class_name(JNIEnv *env, jclass cls, lList **alpp) {
 
2614
 
 
2615
   jclass cls_cls;
 
2616
   jmethodID mid;
 
2617
   jstring ret = NULL;
 
2618
   
 
2619
   DENTER(BASIS_LAYER, "get_class_name");
 
2620
   
 
2621
   cls_cls = (*env)->FindClass(env, "java/lang/Class");
 
2622
   if ((*env)->ExceptionOccurred(env)) {
 
2623
      answer_list_add(alpp, "class java/lang/Class not found", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2624
      DRETURN(NULL);
 
2625
   }
 
2626
 
 
2627
   mid = (*env)->GetMethodID(env, cls_cls, "getName", "()Ljava/lang/String;");
 
2628
   if (mid == NULL) {
 
2629
      DRETURN(NULL);
 
2630
   }
 
2631
   
 
2632
   if ((*env)->ExceptionOccurred(env)) {
 
2633
      (*env)->ExceptionClear(env);
 
2634
      answer_list_add(alpp, "exception occured in GetMethodID", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2635
      DRETURN(NULL);
 
2636
   }
 
2637
 
 
2638
   ret = (*env)->CallObjectMethod(env, cls, mid);
 
2639
#if 0   
 
2640
   if ((*env)->ExceptionOccurred(env)) {
 
2641
      (*env)->ExceptionClear(env);
 
2642
      answer_list_add(alpp, "exception occured in CallObjectMethod", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2643
      DRETURN(NULL);
 
2644
   }
 
2645
#endif
 
2646
 
 
2647
   DRETURN(ret);
 
2648
}
 
2649
 
 
2650
jmethodID get_static_methodid(JNIEnv *env, jclass cls, const char* methodName,
 
2651
                               const char* signature, lList **alpp) {
 
2652
   jmethodID mid = NULL;
 
2653
 
 
2654
   DENTER(BASIS_LAYER, "get_static_methodid");
 
2655
 
 
2656
   mid = (*env)->GetStaticMethodID(env, cls, methodName, signature);
 
2657
   
 
2658
   /* error occured */
 
2659
   if (mid == NULL) {
 
2660
      jstring class_name_str;
 
2661
      const char* class_name = NULL;
 
2662
 
 
2663
      test_jni_error(env, "GetMethodID failed", alpp);
 
2664
      clear_error(env);
 
2665
      
 
2666
      class_name_str = get_class_name(env, cls, alpp);
 
2667
      
 
2668
      if (class_name_str != NULL) {
 
2669
         class_name = (*env)->GetStringUTFChars(env, class_name_str, 0);
 
2670
      }
 
2671
      
 
2672
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2673
                              "static method %s(%s) not found in class %s", 
 
2674
                              signature, class_name ? class_name : "NA");      
 
2675
                              
 
2676
      if (class_name) {
 
2677
         (*env)->ReleaseStringUTFChars(env, class_name_str, class_name);
 
2678
      }
 
2679
   }
 
2680
 
 
2681
   DRETURN(mid);
 
2682
}
 
2683
 
 
2684
jfieldID get_static_fieldid(JNIEnv *env, jclass cls, const char* fieldName,
 
2685
                               const char* signature, lList **alpp) {
 
2686
   jfieldID mid = NULL;
 
2687
 
 
2688
   DENTER(BASIS_LAYER, "get_static_fieldid");
 
2689
 
 
2690
   mid = (*env)->GetStaticFieldID(env, cls, fieldName, signature);
 
2691
   
 
2692
   /* error occured */
 
2693
   if (mid == NULL) {
 
2694
      jstring class_name_str;
 
2695
      const char* class_name = NULL;
 
2696
 
 
2697
      test_jni_error(env, "GetStaticFieldID failed", alpp);
 
2698
      clear_error(env);
 
2699
      
 
2700
      class_name_str = get_class_name(env, cls, alpp);
 
2701
      
 
2702
      if (class_name_str != NULL) {
 
2703
         class_name = (*env)->GetStringUTFChars(env, class_name_str, 0);
 
2704
      }
 
2705
      
 
2706
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2707
                              "static field %s(%s) not found in class %s", 
 
2708
                              signature, class_name ? class_name : "NA");
 
2709
               
 
2710
      if (class_name) {
 
2711
         (*env)->ReleaseStringUTFChars(env, class_name_str, class_name);
 
2712
      }
 
2713
   }
 
2714
 
 
2715
   DRETURN(mid);
 
2716
}
 
2717
 
 
2718
 
 
2719
jmethodID get_methodid(JNIEnv *env, jclass cls, const char* methodName,
 
2720
                               const char* signature, lList **alpp) {
 
2721
   jmethodID mid = NULL;
 
2722
 
 
2723
   DENTER(BASIS_LAYER, "get_methodid");
 
2724
 
 
2725
   if (env == NULL) {
 
2726
      DPRINTF(("env must not be null\n"));
 
2727
      abort();
 
2728
      DRETURN(NULL);
 
2729
   }
 
2730
   
 
2731
   if (cls == NULL) {
 
2732
      DPRINTF(("cls must not be null\n"));
 
2733
      abort();
 
2734
      DRETURN(NULL);
 
2735
   }
 
2736
   
 
2737
   if (methodName == NULL) {
 
2738
      answer_list_add(alpp, "methodName must not be null",
 
2739
                              STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2740
      DRETURN(NULL);
 
2741
   }
 
2742
   
 
2743
   if (signature == NULL) {
 
2744
      answer_list_add(alpp, "signature must not be null",
 
2745
                              STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2746
      DRETURN(NULL);
 
2747
   }
 
2748
 
 
2749
   mid = (*env)->GetMethodID(env, cls, methodName, signature);
 
2750
   
 
2751
   /* error occured */
 
2752
   if (mid == NULL) {
 
2753
      jstring class_name_str;
 
2754
      const char* class_name = NULL;
 
2755
 
 
2756
      test_jni_error(env, "GetMethodID failed", alpp);
 
2757
      clear_error(env);
 
2758
      
 
2759
      class_name_str = get_class_name(env, cls, alpp);
 
2760
      
 
2761
      if (class_name_str != NULL) {
 
2762
         class_name = (*env)->GetStringUTFChars(env, class_name_str, 0);
 
2763
      }
 
2764
      
 
2765
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
2766
                              "method %s(%s) not found in class %s", methodName,
 
2767
                              signature, class_name ? class_name : "NA");
 
2768
      
 
2769
      if (class_name) {
 
2770
         (*env)->ReleaseStringUTFChars(env, class_name_str, class_name);
 
2771
      }
 
2772
   }
 
2773
 
 
2774
   DRETURN(mid);
 
2775
}
 
2776
 
 
2777
static const char* JGDI_EXCEPTION = "com/sun/grid/jgdi/JGDIException";
 
2778
static const char* ILLEGAL_STATE_EXCEPTION = "java/lang/IllegalStateException";
 
2779
static const char* ILLEGAL_ARGUMENT_EXCEPTION = "java/lang/IllegalArgumentException";
 
2780
static const char* NULL_POINTER_EXCEPTION = "java/lang/NullPointerException";
 
2781
 
 
2782
void throw_error(JNIEnv *env, jgdi_result_t result, const char* message, ...) {
 
2783
   jclass new_exc_cls;
 
2784
   va_list ap;
 
2785
   char buf[BUFSIZ];
 
2786
   const char* exc_name = NULL;
 
2787
   jthrowable exc = NULL;
 
2788
 
 
2789
   
 
2790
   DENTER(BASIS_LAYER, "throw_error");
 
2791
   
 
2792
   exc = (*env)->ExceptionOccurred(env);
 
2793
   
 
2794
   if (exc) {
 
2795
      dstring ds = DSTRING_INIT;
 
2796
      (*env)->ExceptionClear(env);
 
2797
      exc = (*env)->NewGlobalRef(env, exc);
 
2798
      printf("Warning: can not throw a new exception: previous exception %s not cleared\n", exc_name);
 
2799
      print_exception(env, exc, &ds);
 
2800
      printf("%s\n", sge_dstring_get_string(&ds));
 
2801
      sge_dstring_free(&ds);
 
2802
      (*env)->DeleteGlobalRef(env, exc);
 
2803
   }
 
2804
 
 
2805
   va_start(ap, message);
 
2806
   vsnprintf(buf, BUFSIZ-1, message, ap);
 
2807
   clear_error(env);     
 
2808
   switch(result) {
 
2809
      case JGDI_ERROR:
 
2810
         exc_name = JGDI_EXCEPTION;
 
2811
         break;
 
2812
      case JGDI_ILLEGAL_STATE:
 
2813
         exc_name = ILLEGAL_STATE_EXCEPTION;
 
2814
         break;
 
2815
      case JGDI_ILLEGAL_ARGUMENT:
 
2816
         exc_name = ILLEGAL_ARGUMENT_EXCEPTION;
 
2817
         break;
 
2818
      case JGDI_NULL_POINTER:
 
2819
         exc_name = NULL_POINTER_EXCEPTION;
 
2820
         break;
 
2821
      default:
 
2822
         abort();
 
2823
   }
 
2824
   new_exc_cls = (*env)->FindClass(env, exc_name);
 
2825
   
 
2826
   {
 
2827
      jthrowable exc = (*env)->ExceptionOccurred(env);
 
2828
      if (exc) {
 
2829
         dstring ds = DSTRING_INIT;
 
2830
         (*env)->ExceptionClear(env);
 
2831
         exc = (*env)->NewGlobalRef(env, exc);
 
2832
         printf("Fatal Error: exception %s not found\n", exc_name);
 
2833
         print_exception(env, exc, &ds);
 
2834
         printf("%s\n", sge_dstring_get_string(&ds));
 
2835
         sge_dstring_free(&ds);
 
2836
         abort();
 
2837
      }
 
2838
   }
 
2839
   (*env)->ThrowNew(env, new_exc_cls, buf);
 
2840
   DRETURN_VOID;
 
2841
}
 
2842
 
 
2843
void throw_error_from_answer_list(JNIEnv *env, jgdi_result_t result, lList* alp) {
 
2844
   
 
2845
   dstring ds = DSTRING_INIT;
 
2846
   
 
2847
   DENTER(BASIS_LAYER, "throw_error_from_answer_list");
 
2848
   
 
2849
   answer_list_to_dstring(alp, &ds);
 
2850
   
 
2851
   throw_error(env, result, sge_dstring_get_string(&ds));
 
2852
   
 
2853
   sge_dstring_free(&ds);
 
2854
 
 
2855
   DRETURN_VOID;
 
2856
}
 
2857
 
 
2858
 
 
2859
void throw_error_from_handler(JNIEnv *env, sge_error_class_t *eh) {
 
2860
   sge_error_iterator_class_t *iter = NULL;
 
2861
   dstring ds = DSTRING_INIT;
 
2862
   bool first = true;
 
2863
 
 
2864
   DENTER(BASIS_LAYER, "throw_error_from_handler");
 
2865
   
 
2866
   iter = eh->iterator(eh);
 
2867
 
 
2868
   while (iter && iter->next(iter)) {
 
2869
      if (first) {
 
2870
         first = false;
 
2871
      } else {   
 
2872
         sge_dstring_append(&ds, "\n");
 
2873
      }
 
2874
      sge_dstring_append(&ds, iter->get_message(iter));
 
2875
   }
 
2876
   throw_error(env, JGDI_ERROR, sge_dstring_get_string(&ds));
 
2877
   
 
2878
   sge_dstring_free(&ds);
 
2879
   DRETURN_VOID;
 
2880
}
 
2881
 
 
2882
 
 
2883
void clear_error(JNIEnv* env) {
 
2884
   jthrowable exc;
 
2885
 
 
2886
   DENTER(BASIS_LAYER, "clear_error");
 
2887
   exc = (*env)->ExceptionOccurred(env);
 
2888
   if (exc) {
 
2889
      (*env)->ExceptionClear(env);
 
2890
   }
 
2891
   DRETURN_VOID;
 
2892
}
 
2893
 
 
2894
jboolean test_jni_error(JNIEnv* env, const char* message, lList **alpp) {
 
2895
   jthrowable exc;
 
2896
   
 
2897
   DENTER(BASIS_LAYER, "test_jni_error");
 
2898
   
 
2899
   exc = (*env)->ExceptionOccurred(env);
 
2900
   
 
2901
   if (exc) {
 
2902
      DPRINTF(("An exception occured\n"));
 
2903
#if 1
 
2904
      if (alpp != NULL) {
 
2905
         dstring buf = DSTRING_INIT;
 
2906
         jobject newExc = NULL;
 
2907
         (*env)->ExceptionClear(env);
 
2908
         
 
2909
         newExc = (*env)->NewGlobalRef(env, exc);
 
2910
         if ((*env)->ExceptionOccurred(env)) {
 
2911
            DPRINTF(("NewGlobalRef did not work\n"));
 
2912
            abort();
 
2913
         }
 
2914
         
 
2915
         exception_to_string(env, newExc, &buf);
 
2916
         DPRINTF(("Exception text: %s\n", sge_dstring_get_string(&buf)));
 
2917
         sge_dstring_clear(&buf);
 
2918
         
 
2919
         sge_dstring_append(&buf, message);
 
2920
         sge_dstring_append(&buf, "\n");
 
2921
         print_exception(env, newExc, &buf);
 
2922
         sge_dstring_append(&buf, "\n");
 
2923
         answer_list_add(alpp, sge_dstring_get_string(&buf), STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
2924
         sge_dstring_free(&buf);
 
2925
         
 
2926
         (*env)->DeleteGlobalRef(env, newExc);
 
2927
      }
 
2928
#endif
 
2929
      DRETURN(TRUE);
 
2930
   } else {
 
2931
      DRETURN(FALSE);
 
2932
   }
 
2933
}
 
2934
 
 
2935
static void exception_to_string(JNIEnv* env, jobject exc, dstring* buf) {
 
2936
   jclass cls = (*env)->FindClass(env, "java/lang/Throwable");
 
2937
   jmethodID to_string_mid;
 
2938
   jstring msg_obj;
 
2939
   const char* msg;
 
2940
 
 
2941
   DENTER(BASIS_LAYER, "exception_to_string");
 
2942
   
 
2943
   to_string_mid = (*env)->GetMethodID(env, cls, "toString", "()Ljava/lang/String;");
 
2944
   if (to_string_mid == NULL) {
 
2945
      sge_dstring_append(buf, "ERROR: method toString not found in java.lang.Throwable");
 
2946
      (*env)->ExceptionClear(env);
 
2947
      DRETURN_VOID;
 
2948
   }
 
2949
   msg_obj = (jstring)(*env)->CallObjectMethod(env, exc, to_string_mid);
 
2950
   if ((*env)->ExceptionOccurred(env)) {
 
2951
      sge_dstring_append(buf, "ERROR: method java.lang.Throwable.toString failed");
 
2952
      (*env)->ExceptionClear(env);
 
2953
      DRETURN_VOID;
 
2954
   }
 
2955
   
 
2956
   msg = (*env)->GetStringUTFChars(env, msg_obj, 0);
 
2957
   if ((*env)->ExceptionOccurred(env)) {
 
2958
      sge_dstring_append(buf, "ERROR: method GetStringUTFChars failed");
 
2959
      (*env)->ExceptionClear(env);
 
2960
      DRETURN_VOID;
 
2961
   }
 
2962
   if (msg == NULL || strlen(msg) == 0) {
 
2963
      sge_dstring_append(buf, "null");
 
2964
   } else {
 
2965
      sge_dstring_append(buf, msg);
 
2966
   }
 
2967
   
 
2968
   (*env)->ReleaseStringUTFChars(env, msg_obj, msg);
 
2969
   
 
2970
   DRETURN_VOID;
 
2971
}
 
2972
 
 
2973
static void print_exception(JNIEnv* env, jobject exc, dstring* buf) {
 
2974
   
 
2975
   jclass cls = (*env)->FindClass(env, "java/lang/Throwable");
 
2976
   jmethodID to_string_mid;
 
2977
   jmethodID get_cause_mid;
 
2978
   jstring msg_obj;
 
2979
   const char* msg;
 
2980
   
 
2981
   DENTER(BASIS_LAYER, "print_exception");
 
2982
   
 
2983
   if (exc == NULL) {
 
2984
      sge_dstring_append(buf, "ERROR: exc is null");
 
2985
      DRETURN_VOID;
 
2986
   }
 
2987
   
 
2988
   if (cls==NULL) {
 
2989
      sge_dstring_append(buf, "ERROR: class java.lang.Throwable not found");
 
2990
      (*env)->ExceptionClear(env);
 
2991
      DRETURN_VOID;
 
2992
   }
 
2993
   
 
2994
   to_string_mid = (*env)->GetMethodID(env, cls, "toString", "()Ljava/lang/String;");
 
2995
   if (to_string_mid == NULL) {
 
2996
      sge_dstring_append(buf, "ERROR: method toString not found in java.lang.Throwable");
 
2997
      (*env)->ExceptionClear(env);
 
2998
      DRETURN_VOID;
 
2999
   }
 
3000
   
 
3001
   msg_obj = (jstring)(*env)->CallObjectMethod(env, exc, to_string_mid);
 
3002
   if ((*env)->ExceptionOccurred(env)) {
 
3003
      sge_dstring_append(buf, "ERROR: method java.lang.Throwable.toString failed");
 
3004
      (*env)->ExceptionClear(env);
 
3005
      DRETURN_VOID;
 
3006
   }
 
3007
   
 
3008
   msg = (*env)->GetStringUTFChars(env, msg_obj, 0);
 
3009
   if ((*env)->ExceptionOccurred(env)) {
 
3010
      sge_dstring_append(buf, "ERROR: method GetStringUTFChars failed");
 
3011
      (*env)->ExceptionClear(env);
 
3012
      DRETURN_VOID;
 
3013
   }
 
3014
   if (msg == NULL || strlen(msg) == 0) {
 
3015
      sge_dstring_append(buf, "null");
 
3016
   } else {
 
3017
      sge_dstring_append(buf, msg);
 
3018
   }
 
3019
   
 
3020
   (*env)->ReleaseStringUTFChars(env, msg_obj, msg);
 
3021
   
 
3022
   print_stacktrace(env, exc, buf);
 
3023
   
 
3024
   /* Looking for cause execeptions */
 
3025
   get_cause_mid = (*env)->GetMethodID(env, cls, "getCause", "()Ljava/lang/Throwable;");
 
3026
   if (get_cause_mid == NULL) {
 
3027
      sge_dstring_append(buf, "ERROR: method getCause not found in java.lang.Throwable");
 
3028
      (*env)->ExceptionClear(env);
 
3029
      DRETURN_VOID;
 
3030
   }
 
3031
   
 
3032
   exc = (*env)->CallObjectMethod(env, exc, get_cause_mid);
 
3033
   if ((*env)->ExceptionOccurred(env)) {
 
3034
      sge_dstring_append(buf, "ERROR: method java.lang.Throwable.getCause failed");
 
3035
      (*env)->ExceptionClear(env);
 
3036
      DRETURN_VOID;
 
3037
   }
 
3038
   if (exc != NULL) {
 
3039
      sge_dstring_append(buf, "\n   caused by ");
 
3040
      print_exception(env, exc, buf);
 
3041
   }
 
3042
   DRETURN_VOID;
 
3043
}
 
3044
 
 
3045
 
 
3046
static void print_stacktrace(JNIEnv* env, jobject exc, dstring* buf) {
 
3047
   
 
3048
   jclass throwable_class;
 
3049
   jclass stacktrace_element_class;
 
3050
   jmethodID get_stacktrace_mid;
 
3051
   jmethodID to_string_mid;
 
3052
   jobjectArray stacktrace;
 
3053
   jint len;
 
3054
   int i;
 
3055
   
 
3056
   throwable_class = (*env)->GetObjectClass(env, exc);
 
3057
   if (throwable_class == NULL) {
 
3058
      sge_dstring_append(buf, "\nERROR: Can't find class java/lang/Throwable");
 
3059
      (*env)->ExceptionClear(env);
 
3060
      return;
 
3061
   }
 
3062
   
 
3063
   stacktrace_element_class = (*env)->FindClass(env, "java/lang/StackTraceElement");
 
3064
   if (stacktrace_element_class == NULL) {
 
3065
      sge_dstring_append(buf, "\nERROR: Can't find class java.lang.StackTraceElement");
 
3066
      (*env)->ExceptionClear(env);
 
3067
      return;
 
3068
   }
 
3069
   
 
3070
   get_stacktrace_mid = (*env)->GetMethodID(env, throwable_class,
 
3071
                                          "getStackTrace", "()[Ljava/lang/StackTraceElement;");
 
3072
   if (get_stacktrace_mid == NULL) {
 
3073
      sge_dstring_append(buf, "\nERROR: Can't find method getStacktrace in class java.lang.StackTraceElement");
 
3074
      (*env)->ExceptionClear(env);
 
3075
      return;
 
3076
   }
 
3077
 
 
3078
   to_string_mid = (*env)->GetMethodID(env, stacktrace_element_class,
 
3079
                                     "toString", "()Ljava/lang/String;");
 
3080
   if (to_string_mid == NULL) {
 
3081
      sge_dstring_append(buf, "\nERROR: Can't find method toString in class java.lang.StackTraceElement");
 
3082
      (*env)->ExceptionClear(env);
 
3083
      return;
 
3084
   }
 
3085
   
 
3086
   stacktrace = (*env)->CallObjectMethod(env, exc, get_stacktrace_mid);
 
3087
   if (stacktrace == NULL) {
 
3088
      sge_dstring_append(buf, "\nERROR: Call of method getStacktrace in class java.lang.StackTraceElement failed");
 
3089
      (*env)->ExceptionClear(env);
 
3090
      return;
 
3091
   }
 
3092
   
 
3093
   len = (*env)->GetArrayLength(env, stacktrace);
 
3094
   if ((*env)->ExceptionOccurred(env)) {
 
3095
      sge_dstring_append(buf, "\nERROR: Call of method GetArrayLength on stacktrace failed");
 
3096
      (*env)->ExceptionClear(env);
 
3097
      return;
 
3098
   }
 
3099
   
 
3100
   for(i = 0; i < len; i++) {
 
3101
     jobject stacktrace_elem;
 
3102
     jstring stacktrace_str_obj;
 
3103
     const char* stacktrace_str;
 
3104
     
 
3105
     stacktrace_elem = (*env)->GetObjectArrayElement(env, stacktrace, i);
 
3106
     if (stacktrace_elem==NULL) {
 
3107
        sge_dstring_append(buf, "\nERROR: Call of method GetObjectArrayElement on stacktrace failed");
 
3108
        (*env)->ExceptionClear(env);
 
3109
        break;
 
3110
     }
 
3111
     
 
3112
     stacktrace_str_obj = (jstring)(*env)->CallObjectMethod(env, stacktrace_elem, to_string_mid);
 
3113
     if (stacktrace_str_obj==NULL) {
 
3114
        sge_dstring_append(buf, "\nERROR: Call of method StackTraceElement.toString failed");
 
3115
        break;
 
3116
     }
 
3117
     
 
3118
     stacktrace_str = (*env)->GetStringUTFChars(env, stacktrace_str_obj, 0);
 
3119
     if (stacktrace_str != NULL) {
 
3120
        sge_dstring_append(buf, "\n     ");
 
3121
        sge_dstring_append(buf, stacktrace_str);
 
3122
        (*env)->ReleaseStringUTFChars(env, stacktrace_str_obj, stacktrace_str);
 
3123
     } else {
 
3124
        sge_dstring_append(buf, "\nERROR: Call of method GetStringUTFChars failed");
 
3125
        break;
 
3126
     }
 
3127
   }
 
3128
   (*env)->ExceptionClear(env);
 
3129
}
 
3130
 
 
3131
 
 
3132
 
 
3133
void object_to_str(JNIEnv* env, jobject obj, char* buf, size_t max_len) {
 
3134
   
 
3135
   if (obj == NULL) {
 
3136
      snprintf(buf, max_len, "%s", "null");
 
3137
   } else {
 
3138
      
 
3139
      lList *alpp;
 
3140
      jclass clazz;
 
3141
      jstring classname_obj;
 
3142
      const char* classname = NULL;
 
3143
      jmethodID mid;
 
3144
      jstring obj_str_obj;
 
3145
      const char* objStr;
 
3146
      
 
3147
      clazz = (*env)->GetObjectClass(env, obj);
 
3148
      
 
3149
      classname_obj = get_class_name(env, clazz, &alpp);
 
3150
      if (classname_obj == NULL) {
 
3151
         snprintf(buf, max_len, "object_to_string: classname_obj is NULL");
 
3152
         return;
 
3153
      }
 
3154
      mid = get_methodid(env, clazz, "toString", "()Ljava/lang/String;", &alpp);
 
3155
      
 
3156
      obj_str_obj = (jstring)(*env)->CallObjectMethod(env, obj, mid);
 
3157
      if (obj_str_obj == NULL) {
 
3158
         snprintf(buf, max_len, "NULL");
 
3159
         return;
 
3160
      }
 
3161
 
 
3162
      classname = (*env)->GetStringUTFChars(env, classname_obj, 0);
 
3163
      objStr = (*env)->GetStringUTFChars(env, obj_str_obj, 0);
 
3164
      if (classname == NULL || objStr == NULL) {
 
3165
         snprintf(buf, max_len, "object_to_string: GetStringUTFChars failed. Out of memory.");
 
3166
         return;
 
3167
      }
 
3168
      
 
3169
      snprintf(buf, max_len, "%s (%s)", objStr, classname);
 
3170
      
 
3171
      (*env)->ReleaseStringUTFChars(env, classname_obj, classname);
 
3172
      (*env)->ReleaseStringUTFChars(env, obj_str_obj, objStr);
 
3173
   }
 
3174
}
 
3175
 
 
3176
static jgdi_result_t get_descriptor_for_property(JNIEnv *env, jobject property_descr, lDescr **descr, lList **alpp) {
 
3177
 
 
3178
   jstring   cull_type_name_obj;
 
3179
   const char* cull_type_name;
 
3180
   jgdi_result_t  ret = JGDI_SUCCESS;
 
3181
 
 
3182
   DENTER(BASIS_LAYER, "get_descriptor_for_property");
 
3183
 
 
3184
   ret = PropertyDescriptor_getCullType(env, property_descr, &cull_type_name_obj, alpp);
 
3185
   if (ret != JGDI_SUCCESS) {
 
3186
      DRETURN(ret);
 
3187
   }
 
3188
   if (cull_type_name_obj == NULL) {
 
3189
      answer_list_add(alpp, "get_descriptor_for_property: cull_type_name_obj is NULL.", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
3190
      DRETURN(JGDI_ILLEGAL_STATE);
 
3191
   }
 
3192
   
 
3193
   cull_type_name = (*env)->GetStringUTFChars(env, cull_type_name_obj, 0);
 
3194
   if (cull_type_name == NULL) {
 
3195
      answer_list_add(alpp, "get_descriptor_for_property: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3196
      DRETURN(JGDI_ERROR);
 
3197
   }   
 
3198
 
 
3199
   *descr = get_descr(cull_type_name);
 
3200
   if (*descr == NULL) {
 
3201
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3202
                              "get_descriptor_for_property: no descr for cull type %s found",  cull_type_name);
 
3203
      ret = JGDI_ERROR;
 
3204
   }
 
3205
   (*env)->ReleaseStringUTFChars(env, cull_type_name_obj, cull_type_name);
 
3206
   
 
3207
   DRETURN(ret);
 
3208
}
 
3209
   
 
3210
static jgdi_result_t get_list_descriptor_for_property(JNIEnv *env, jobject property_descr, lDescr **descr, lList **alpp) {
 
3211
 
 
3212
   jstring   cull_type_name_obj;
 
3213
   const char* cull_type_name;
 
3214
   jgdi_result_t  ret = JGDI_SUCCESS;
 
3215
 
 
3216
   DENTER(BASIS_LAYER, "get_list_descriptor_for_property");
 
3217
 
 
3218
   ret = MapListPropertyDescriptor_getCullListType(env, property_descr, &cull_type_name_obj, alpp);
 
3219
   if (ret != JGDI_SUCCESS) {
 
3220
      DRETURN(ret);
 
3221
   }
 
3222
   if (cull_type_name_obj == NULL) {
 
3223
      answer_list_add(alpp, "get_list_descriptor_for_property: cull_type_name_obj is NULL. ", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
3224
      DRETURN(JGDI_ILLEGAL_STATE);
 
3225
   }
 
3226
 
 
3227
   cull_type_name = (*env)->GetStringUTFChars(env, cull_type_name_obj, 0);
 
3228
   if (cull_type_name == NULL) {
 
3229
      answer_list_add(alpp, "get_list_descriptor_for_property: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3230
      DRETURN(JGDI_ERROR);
 
3231
   }
 
3232
 
 
3233
   *descr = get_descr(cull_type_name);
 
3234
   if (descr == NULL) {
 
3235
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3236
                              "get_list_descriptor_for_property: no descr for cull type %s found",  cull_type_name);
 
3237
      ret = JGDI_ERROR;
 
3238
   }
 
3239
   (*env)->ReleaseStringUTFChars(env, cull_type_name_obj, cull_type_name);
 
3240
   
 
3241
   DRETURN(ret);
 
3242
}
 
3243
 
 
3244
 
 
3245
jgdi_result_t get_string_list(JNIEnv *env, jobject obj, const char* getter, lList **lpp, lDescr* descr, int nm, lList **alpp) {
 
3246
   jmethodID get_mid;
 
3247
   jclass    cls;
 
3248
   jobject   list;
 
3249
 
 
3250
   DENTER(BASIS_LAYER, "get_string_list");
 
3251
   
 
3252
   cls = (*env)->GetObjectClass(env, obj);
 
3253
   if (test_jni_error(env, "get_string_list: class for obj not found", alpp)) {
 
3254
      DRETURN(JGDI_ERROR);
 
3255
   }
 
3256
   
 
3257
   get_mid = get_methodid(env, cls, getter, "()Ljava/util/List;", alpp);
 
3258
   if (!get_mid) {
 
3259
      DRETURN(JGDI_ERROR);
 
3260
   }
 
3261
 
 
3262
   list = (*env)->CallObjectMethod(env, obj, get_mid);
 
3263
   if (test_jni_error(env, "get_string_list: call of getter failed", alpp)) {
 
3264
      DRETURN(JGDI_ERROR);
 
3265
   }
 
3266
   
 
3267
   if (string_list_to_list_elem(env, list, lpp, descr, nm, alpp) != JGDI_SUCCESS) {
 
3268
      DRETURN(JGDI_ERROR);
 
3269
   }
 
3270
   
 
3271
   DRETURN(JGDI_SUCCESS);
 
3272
}
 
3273
 
 
3274
static jgdi_result_t string_list_to_list_elem(JNIEnv *env, jobject list, lList **lpp, lDescr *descr, int nm, lList **alpp) {
 
3275
   
 
3276
   jobject  iter = NULL;
 
3277
   jboolean has_next = 0;
 
3278
   
 
3279
   DENTER(BASIS_LAYER, "string_list_to_list_elem");
 
3280
   
 
3281
   if (List_iterator(env, list, &iter, alpp) != JGDI_SUCCESS) {
 
3282
      DRETURN(JGDI_ERROR);
 
3283
   }
 
3284
   
 
3285
   while (TRUE) {
 
3286
      if (Iterator_hasNext(env, iter, &has_next, alpp) != JGDI_SUCCESS) {
 
3287
        DRETURN(JGDI_ERROR);
 
3288
      } else if (has_next == false) {
 
3289
         break;
 
3290
      } else {
 
3291
         jstring str_obj = NULL;
 
3292
         if (Iterator_next(env, iter, &str_obj, alpp) != JGDI_SUCCESS) {
 
3293
            DRETURN(JGDI_ERROR);
 
3294
         } else {
 
3295
           const char* str;
 
3296
           if (str_obj != NULL) {
 
3297
              str = (*env)->GetStringUTFChars(env, str_obj, 0);
 
3298
              if (str == NULL) {
 
3299
                 answer_list_add(alpp, "string_list_to_list_elem: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3300
                 DRETURN(JGDI_ERROR);
 
3301
              }
 
3302
           } else {
 
3303
              str = NULL;
 
3304
           }
 
3305
           DPRINTF(("Got %s from list\n", str));
 
3306
           lAddElemStr(lpp, nm, str, descr);
 
3307
           if (str) {
 
3308
               (*env)->ReleaseStringUTFChars(env, str_obj, str);
 
3309
           }
 
3310
         }
 
3311
      }
 
3312
   }
 
3313
   
 
3314
   DRETURN(JGDI_SUCCESS);
 
3315
}
 
3316
 
 
3317
 
 
3318
 
 
3319
/*-------------------------------------------------------------------------*
 
3320
 * NAME
 
3321
 *   build_filter - build a lCondition from a PrimaryKeyFilter filter object
 
3322
 * PARAMETER
 
3323
 *  env    - the JNI Environment
 
3324
 *  filter - the PrimaryKeyFilter object (instanceof com.sun.grid.jgdi.filter.PrimaryKeyFilter)
 
3325
 *  where  - the resulting condition (output)
 
3326
 *  alpp   - answer list for error reporting
 
3327
 *
 
3328
 * RETURN
 
3329
 *
 
3330
 *  JGDI_SUCCESS  - condition has been built
 
3331
 *  JGDI_ERROR    - error reason has been reported in alpp
 
3332
 *
 
3333
 *
 
3334
 * DESCRIPTION
 
3335
 *-------------------------------------------------------------------------*/
 
3336
jgdi_result_t build_filter(JNIEnv *env, jobject filter, lCondition **where, lList **alpp) {
 
3337
   
 
3338
   jclass pk_filter_class = NULL;
 
3339
   jclass filter_class = NULL;
 
3340
   jboolean is_pk_filter = false;
 
3341
   
 
3342
   DENTER(JGDI_LAYER, "build_filter");
 
3343
   
 
3344
   pk_filter_class = PrimaryKeyFilter_find_class(env, alpp);
 
3345
   
 
3346
   if (pk_filter_class == NULL) {
 
3347
      DRETURN(JGDI_ERROR);
 
3348
   }
 
3349
   
 
3350
   if (Object_getClass(env, filter, &filter_class, alpp) != JGDI_SUCCESS) {
 
3351
      DRETURN(JGDI_ERROR);
 
3352
   }
 
3353
   
 
3354
   if (Class_isAssignableFrom(env, pk_filter_class, filter_class, &is_pk_filter, alpp) != JGDI_SUCCESS) {
 
3355
      DRETURN(JGDI_ERROR);
 
3356
   }
 
3357
   
 
3358
   if (is_pk_filter) {
 
3359
      
 
3360
      jobject fields = NULL;
 
3361
      jobject field = NULL;
 
3362
      jobject iter = NULL;
 
3363
      jboolean has_next = false;
 
3364
      
 
3365
      jstring type_obj = NULL;  /* string representation of the cull type */
 
3366
      
 
3367
      lCondition *result = NULL;
 
3368
      
 
3369
      if (PrimaryKeyFilter_getType(env, filter, &type_obj, alpp) != JGDI_SUCCESS) {
 
3370
         DRETURN(JGDI_ERROR);
 
3371
      }
 
3372
      
 
3373
      
 
3374
      if (PrimaryKeyFilter_getFields(env, filter, &fields, alpp) != JGDI_SUCCESS) {
 
3375
         DRETURN(JGDI_ERROR);
 
3376
      }
 
3377
      
 
3378
      if (List_iterator(env, fields, &iter, alpp) != JGDI_SUCCESS) {
 
3379
         DRETURN(JGDI_ERROR);
 
3380
      }
 
3381
      
 
3382
      
 
3383
      while (1) {
 
3384
         lCondition *field_where = NULL;
 
3385
         
 
3386
         if (Iterator_hasNext(env, iter, &has_next, alpp) != JGDI_SUCCESS) {
 
3387
            lFreeWhere(&result);
 
3388
            DRETURN(JGDI_ERROR);
 
3389
         }
 
3390
         
 
3391
         if (has_next == false) {
 
3392
            break;
 
3393
         }
 
3394
         
 
3395
         if (Iterator_next(env, iter, &field, alpp) != JGDI_SUCCESS) {
 
3396
            lFreeWhere(&result);
 
3397
            DRETURN(JGDI_ERROR);
 
3398
         }
 
3399
         
 
3400
         if (build_field_filter(env, field, &field_where, alpp) != JGDI_SUCCESS) {
 
3401
            lFreeWhere(&result);
 
3402
            DRETURN(JGDI_ERROR);
 
3403
         }
 
3404
         
 
3405
         /* Add the condition for the primary key field to the result */
 
3406
         if (result == NULL) {
 
3407
            result = field_where;
 
3408
         } else {
 
3409
            result = lAndWhere(result, field_where);
 
3410
         }
 
3411
      } /* end of while */
 
3412
      
 
3413
      *where = result;
 
3414
      
 
3415
      
 
3416
#if 0
 
3417
      printf("build where from filter -----------------\n");
 
3418
      lWriteWhereTo(result, stdout);
 
3419
#endif
 
3420
      DRETURN(JGDI_SUCCESS);
 
3421
      
 
3422
   } else {
 
3423
      /* filter is not an instanceof of pk filter */
 
3424
      jstring class_name_obj = NULL;
 
3425
      const char* class_name = NULL;
 
3426
      
 
3427
      if (Class_getName(env, pk_filter_class, &class_name_obj, alpp) != JGDI_SUCCESS) {
 
3428
         DRETURN(JGDI_ERROR);
 
3429
      }
 
3430
      class_name =  (*env)->GetStringUTFChars(env, class_name_obj, 0);
 
3431
      if (class_name == NULL) {
 
3432
         answer_list_add(alpp, "build_filter: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3433
         DRETURN(JGDI_ERROR);
 
3434
      }
 
3435
      answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3436
                              "build_filter: filter must be an instanceof %s",
 
3437
                              class_name);
 
3438
      (*env)->ReleaseStringUTFChars(env, class_name_obj, class_name);
 
3439
      DRETURN(JGDI_ERROR);
 
3440
   }
 
3441
}
 
3442
 
 
3443
/*-------------------------------------------------------------------------*
 
3444
 * NAME
 
3445
 *   build_field_filter - build a condition from a primary key filter
 
3446
 * PARAMETER
 
3447
 *  env   -  the jni environment
 
3448
 *  field -  the primary key filter (instance of com.sun.grid.jgdi.filter.WhereClause)
 
3449
 *  where -  the condition (output parameter)
 
3450
 *  alpp -   answer list for error reporting
 
3451
 *
 
3452
 * RETURN
 
3453
 *   JGDI_SUCCESS - if the condition has been successfully built
 
3454
 *   JGDI_ERROR   - error
 
3455
 *
 
3456
 *
 
3457
 * DESCRIPTION
 
3458
 *
 
3459
 *  This method builds a lCondition element from a object of type
 
3460
 *  com.sun.grid.jgdi.filter.StringWhereClause or
 
3461
 *  com.sun.grid.jgdi.filter.IntWhereClause
 
3462
 *
 
3463
 *  EXAMPLE
 
3464
 *
 
3465
 *  Java:
 
3466
 *  IntWhereClause wc = new IntWhereClause("JB_Type", CullConstants.JB_Name, 1);
 
3467
 *
 
3468
 *  Result of build_field_filter:
 
3469
 *
 
3470
 *   lCondition where = lWhere("%T(%I==%s)", JB_Type, JB_Name, "MyJob");
 
3471
 *   lCondition where = lWhere("%T(%I==%u)", JB_Type, JB_job_number, 1);
 
3472
 *
 
3473
 *  Java:
 
3474
 *
 
3475
 *  StringWhereClause wc = new StringWhereClause("CQ_Type", "CQ_Name", "all.q");
 
3476
 *
 
3477
 *  Result of build_field_filter:
 
3478
 *
 
3479
 *   lCondition where = lWhere("%T(%I==%s)", CQ_Type, CQ_Name, "all.q");
 
3480
 *
 
3481
 *-------------------------------------------------------------------------*/
 
3482
static jgdi_result_t build_field_filter(JNIEnv *env, jobject field, lCondition **where, lList **alpp) {
 
3483
   jstring type_obj = NULL;
 
3484
   lDescr  *descr = NULL;
 
3485
   jstring pattern_obj = NULL;
 
3486
   jclass  field_class = NULL;
 
3487
   jint    field_name = 0;
 
3488
   jclass  string_where_class = NULL;
 
3489
   jboolean is_string_field = false;
 
3490
   
 
3491
   DENTER(JGDI_LAYER, "build_field_filter");
 
3492
   
 
3493
   if (WhereClause_getType(env, field, &type_obj, alpp) != JGDI_SUCCESS) {
 
3494
      DRETURN(JGDI_ERROR);
 
3495
   }
 
3496
   
 
3497
   {
 
3498
      const char* type = NULL;
 
3499
      if (type_obj != NULL) {
 
3500
         type = (*env)->GetStringUTFChars(env, type_obj, 0);
 
3501
         if (type == NULL) {
 
3502
            answer_list_add(alpp, "build_field_filter: GetStringUTFChars failed. Out of the memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3503
            DRETURN(JGDI_ERROR);
 
3504
         }
 
3505
      } else {
 
3506
         answer_list_add(alpp, "build_field_filter: type_obj is NULL.", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
3507
         DRETURN(JGDI_ILLEGAL_STATE);
 
3508
      }
 
3509
      descr = get_descr(type);
 
3510
      if (descr == NULL) {
 
3511
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3512
                                 "build_field_filter: descriptor for %s not found",
 
3513
                                 type);
 
3514
      }
 
3515
      (*env)->ReleaseStringUTFChars(env, type_obj, type);
 
3516
      if (descr == NULL) {
 
3517
         DRETURN(JGDI_ERROR);
 
3518
      }
 
3519
   }
 
3520
   if (WhereClause_getPattern(env, field, &pattern_obj, alpp) != JGDI_SUCCESS) {
 
3521
      DRETURN(JGDI_ERROR);
 
3522
   }
 
3523
   
 
3524
   if (WhereClause_getField(env, field, &field_name, alpp) != JGDI_SUCCESS) {
 
3525
      DRETURN(JGDI_ERROR);
 
3526
   }
 
3527
 
 
3528
   if (Object_getClass(env, field, &field_class, alpp) != JGDI_SUCCESS) {
 
3529
      DRETURN(JGDI_ERROR);
 
3530
   }
 
3531
   string_where_class = StringWhereClause_find_class(env, alpp);
 
3532
   if (string_where_class == NULL) {
 
3533
      DRETURN(JGDI_ERROR);
 
3534
   }
 
3535
   
 
3536
   if (Class_isAssignableFrom(env, string_where_class, field_class, &is_string_field, alpp) != JGDI_SUCCESS) {
 
3537
      DRETURN(JGDI_ERROR);
 
3538
   }
 
3539
   
 
3540
   if (is_string_field) {
 
3541
      /* we have an string expression */
 
3542
      jstring value_obj = NULL;
 
3543
      const char* value = NULL;
 
3544
      const char* pattern = NULL;
 
3545
      if (StringWhereClause_getValue(env, field, &value_obj, alpp) != JGDI_SUCCESS) {
 
3546
         DRETURN(JGDI_ERROR);
 
3547
      }
 
3548
      
 
3549
      if (value_obj == NULL) {
 
3550
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3551
                                 "build_field_filter: value of filtered primary key field %d is NULL",
 
3552
                                 field_name);
 
3553
         DRETURN(JGDI_ERROR);
 
3554
      }
 
3555
      
 
3556
      value = (*env)->GetStringUTFChars(env, value_obj, 0);
 
3557
      pattern  = (*env)->GetStringUTFChars(env, pattern_obj, 0);
 
3558
      if (value == NULL || pattern == NULL) {
 
3559
         answer_list_add(alpp, "build_field_filter: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3560
         DRETURN(JGDI_ERROR);
 
3561
      }
 
3562
      
 
3563
      *where = lWhere(pattern, descr, field_name, value);
 
3564
      
 
3565
      if (value) {
 
3566
         (*env)->ReleaseStringUTFChars(env, value_obj, value);
 
3567
      }
 
3568
      if (pattern) {
 
3569
         (*env)->ReleaseStringUTFChars(env, pattern_obj, pattern);  
 
3570
      }
 
3571
      
 
3572
      DRETURN(JGDI_SUCCESS);
 
3573
      
 
3574
   } else {
 
3575
      jboolean is_int_field = false;
 
3576
      jclass  int_where_class = NULL;
 
3577
 
 
3578
      int_where_class = IntWhereClause_find_class(env, alpp);
 
3579
      if (int_where_class == NULL) {
 
3580
         DRETURN(JGDI_ERROR);
 
3581
      }
 
3582
      
 
3583
      if (Class_isAssignableFrom(env, int_where_class, field_class, &is_int_field, alpp) != JGDI_SUCCESS) {
 
3584
         DRETURN(JGDI_ERROR);
 
3585
      }
 
3586
      
 
3587
      if (is_int_field) {
 
3588
         /* we have an integer expression */
 
3589
         jint value = 0;
 
3590
         const char* pattern = NULL;
 
3591
         
 
3592
         if (IntWhereClause_getValue(env, field, &value, alpp) != JGDI_SUCCESS) {
 
3593
            DRETURN(JGDI_ERROR);
 
3594
         }
 
3595
         
 
3596
         pattern  = (*env)->GetStringUTFChars(env, pattern_obj, 0);
 
3597
         if (pattern == NULL) {
 
3598
            answer_list_add(alpp, "build_field_filter: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3599
            DRETURN(JGDI_ERROR);
 
3600
         }
 
3601
 
 
3602
         *where = lWhere(pattern, descr, field_name, value);
 
3603
         
 
3604
         (*env)->ReleaseStringUTFChars(env, pattern_obj, pattern);
 
3605
         
 
3606
         DRETURN(JGDI_SUCCESS);
 
3607
         
 
3608
      } else {
 
3609
         jstring class_name_obj = NULL;
 
3610
         const char* class_name = NULL;
 
3611
         
 
3612
         if (Class_getName(env, field_class, &class_name_obj, alpp) != JGDI_SUCCESS) {
 
3613
            DRETURN(JGDI_ERROR);
 
3614
         }                 
 
3615
         class_name =  (*env)->GetStringUTFChars(env, class_name_obj, 0);
 
3616
         if (class_name == NULL) {
 
3617
            answer_list_add(alpp, "build_field_filter: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3618
            DRETURN(JGDI_ERROR);
 
3619
         }
 
3620
         answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3621
                                 "build_field_filter: filter for class %s not implemented",
 
3622
                                 class_name);
 
3623
         (*env)->ReleaseStringUTFChars(env, class_name_obj, class_name);
 
3624
         DRETURN(JGDI_ERROR);
 
3625
      }
 
3626
   }
 
3627
}
 
3628
 
 
3629
 
 
3630
jgdi_result_t generic_fill_list(JNIEnv *env, jobject list, const char *classname, lList *lp, lList **alpp) 
 
3631
{
 
3632
   const lDescr *listdescr = NULL;
 
3633
   lListElem *ep = NULL;
 
3634
   jobject obj;
 
3635
   jclass obj_class;
 
3636
   jgdi_result_t ret = JGDI_SUCCESS;
 
3637
   int count = 0;
 
3638
 
 
3639
   DENTER(TOP_LAYER, "generic_fill_list");
 
3640
 
 
3641
   jgdi_log_printf(env, JGDI_LOGGER, FINE,
 
3642
                   "BEGIN ------------------ fill %s ---------------------", classname);
 
3643
  
 
3644
   jgdi_log_list(env, JGDI_LOGGER, FINE, lp);
 
3645
 
 
3646
   obj_class = (*env)->FindClass(env, classname);
 
3647
   if (!obj_class) {
 
3648
      answer_list_add_sprintf(alpp,
 
3649
                              STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR,
 
3650
                              "class %s not found",  classname);
 
3651
      DRETURN(JGDI_ERROR);
 
3652
   }
 
3653
 
 
3654
   listdescr = lGetListDescr(lp);
 
3655
   for_each(ep, lp) {
 
3656
      jboolean add_result = false;
 
3657
      /* convert to Java representation */
 
3658
      if ((ret = listelem_to_obj(env, ep, &obj, listdescr, obj_class, alpp)) != JGDI_SUCCESS) {
 
3659
         DRETURN(ret);
 
3660
      }
 
3661
      if ((ret=List_add(env, list, obj, &add_result, alpp)) != JGDI_SUCCESS) {
 
3662
         DRETURN(ret);
 
3663
      }
 
3664
      count++;
 
3665
   }
 
3666
   
 
3667
   jgdi_log_printf(env, JGDI_LOGGER, FINE,
 
3668
                   "END fill %s, got %d objects ", classname, count);
 
3669
 
 
3670
   DRETURN(ret);
 
3671
}                   
 
3672
 
 
3673
void jgdi_fill(JNIEnv *env, jobject jgdi, jobject list, jobject filter, const char *classname, int target_list, lDescr *descr, jobject answers) {
 
3674
 
 
3675
 
 
3676
   /* receive Cull Object */
 
3677
   lList *lp = NULL;
 
3678
   lList *alp = NULL;
 
3679
   lCondition *where = NULL;
 
3680
   lEnumeration *what  = NULL;
 
3681
   sge_gdi_ctx_class_t *ctx = NULL;
 
3682
   jgdi_result_t ret = JGDI_SUCCESS;
 
3683
   rmon_ctx_t rmon_ctx;
 
3684
 
 
3685
   DENTER(TOP_LAYER, "jgdi_fill");
 
3686
   
 
3687
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
3688
   rmon_set_thread_ctx(&rmon_ctx);
 
3689
   
 
3690
   if (filter != NULL && target_list != SGE_SHARETREE_LIST) { 
 
3691
     ret=build_filter(env, filter, &where, &alp);
 
3692
     if (ret != JGDI_SUCCESS) {
 
3693
        goto error;
 
3694
     }
 
3695
   }
 
3696
   
 
3697
   /* get context */
 
3698
   ret = getGDIContext(env, jgdi, &ctx, &alp);
 
3699
   if (ret != JGDI_SUCCESS) {
 
3700
      goto error;
 
3701
   }
 
3702
   
 
3703
   sge_gdi_set_thread_local_ctx(ctx);
 
3704
 
 
3705
   /* create what and where */
 
3706
   what = lWhat("%T(ALL)", descr);
 
3707
   
 
3708
   /* get list */
 
3709
   alp = ctx->gdi(ctx, target_list, SGE_GDI_GET, &lp, where, what);
 
3710
   if (answers != NULL) {
 
3711
      generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
3712
   }
 
3713
   if (answer_list_has_error(&alp)) {
 
3714
      ret = JGDI_ERROR;
 
3715
      goto error;
 
3716
   } else {
 
3717
      lFreeList(&alp);
 
3718
   }   
 
3719
 
 
3720
   if (target_list == SGE_SHARETREE_LIST) {
 
3721
      id_sharetree(&alp, lFirst(lp), 0, NULL);
 
3722
      if (answers != NULL) {
 
3723
         generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
3724
      }
 
3725
      if (answer_list_has_error(&alp)) {
 
3726
         ret = JGDI_ERROR;
 
3727
         goto error;
 
3728
      } else {
 
3729
         lFreeList(&alp);
 
3730
      }   
 
3731
   }
 
3732
   ret = generic_fill_list(env, list, classname, lp, &alp);
 
3733
   
 
3734
 
 
3735
error:
 
3736
 
 
3737
   /*
 
3738
   ** this must be called before throw_error_from_answer_list, otherwise there is a pending 
 
3739
   ** exception in the way
 
3740
   */
 
3741
   sge_gdi_set_thread_local_ctx(NULL);
 
3742
   rmon_set_thread_ctx(NULL);
 
3743
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
3744
 
 
3745
   /* if error throw exception */
 
3746
   if (ret != JGDI_SUCCESS) {
 
3747
      throw_error_from_answer_list(env, ret, alp);
 
3748
   }
 
3749
   
 
3750
   lFreeWhat(&what);
 
3751
   lFreeWhere(&where);
 
3752
   lFreeList(&lp);
 
3753
   lFreeList(&alp);
 
3754
   DRETURN_VOID;
 
3755
}
 
3756
 
 
3757
void jgdi_add(JNIEnv *env, jobject jgdi, jobject jobj, const char *classname, int target_list, lDescr *descr, jobject answers)
 
3758
{
 
3759
   lList *lp = NULL;
 
3760
   lList *alp = NULL;
 
3761
   lCondition *where = NULL;
 
3762
   static lEnumeration *what  = NULL;
 
3763
   lListElem *ep = NULL;
 
3764
   sge_gdi_ctx_class_t *ctx = NULL;
 
3765
   jgdi_result_t ret = JGDI_SUCCESS;
 
3766
   rmon_ctx_t rmon_ctx;
 
3767
   
 
3768
   DENTER(JGDI_LAYER, "jgdi_add");
 
3769
 
 
3770
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
3771
   rmon_set_thread_ctx(&rmon_ctx);
 
3772
   
 
3773
   /* get context */
 
3774
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
3775
      goto error;
 
3776
   }
 
3777
 
 
3778
   sge_gdi_set_thread_local_ctx(ctx);
 
3779
   
 
3780
   
 
3781
   ret = obj_to_listelem(env, jobj, &ep, descr, &alp);
 
3782
 
 
3783
   if (ret == JGDI_SUCCESS) {
 
3784
      
 
3785
      lp = lCreateList("add", descr);
 
3786
      lAppendElem(lp, ep);
 
3787
 
 
3788
      
 
3789
      jgdi_log_printf(env, JGDI_LOGGER, FINE,
 
3790
                     "BEGIN --------------- jgdi_add %s -------------------------------", classname); 
 
3791
      
 
3792
      jgdi_log_list(env, JGDI_LOGGER, FINE, lp);
 
3793
      
 
3794
      jgdi_log_printf(env, JGDI_LOGGER, FINE,
 
3795
                      "END --------------- jgdi_add %s -------------------------------", classname); 
 
3796
   
 
3797
      what = lWhat("%T(ALL)", descr);
 
3798
      
 
3799
      /* add to list */
 
3800
      if (target_list == SGE_JOB_LIST || target_list == SGE_AR_LIST) {
 
3801
         alp = ctx->gdi(ctx, target_list, SGE_GDI_ADD | SGE_GDI_RETURN_NEW_VERSION, &lp, where, what);
 
3802
         if (answer_list_has_error(&alp)) {
 
3803
            ret = JGDI_ERROR;
 
3804
            goto error;
 
3805
         }
 
3806
#if 0         
 
3807
         else {
 
3808
            lFreeList(&alp);
 
3809
         }   
 
3810
#endif
 
3811
 
 
3812
         if ((ep = lFirst(lp)) != NULL) {
 
3813
            jclass elem_class = NULL;
 
3814
            jobject obj_descr = NULL;
 
3815
            jint prop_count;
 
3816
            int i;
 
3817
            /* get jobj's class */
 
3818
            if ((ret = Object_getClass(env, jobj, &elem_class, &alp)) != JGDI_SUCCESS) {
 
3819
               goto error;
 
3820
            }
 
3821
            /* Get the descriptor class of the bean class */
 
3822
            if ((ret=Util_static_getDescriptor(env, elem_class, &obj_descr, &alp)) != JGDI_SUCCESS) {
 
3823
               goto error;
 
3824
            }
 
3825
 
 
3826
            /* get the property count */
 
3827
            if ((ret=ClassDescriptor_getPropertyCount(env, obj_descr, &prop_count, &alp)) != JGDI_SUCCESS) {
 
3828
               goto error;
 
3829
            }
 
3830
   
 
3831
            for (i = 0; i < prop_count; i++) {
 
3832
              jobject prop_descr = NULL;
 
3833
              if ((ret=ClassDescriptor_getProperty(env, obj_descr, i, &prop_descr, &alp)) != JGDI_SUCCESS) {
 
3834
                 goto error;
 
3835
              }
 
3836
              if ((ret=set_object_attribute(env, ep, descr, jobj, prop_descr, &alp)) != JGDI_SUCCESS) {
 
3837
                 goto error;
 
3838
              }
 
3839
            }
 
3840
         }   
 
3841
         lFreeList(&lp);
 
3842
      } else if (target_list == SGE_CONFIG_LIST) {
 
3843
         alp = ctx->gdi(ctx, target_list, SGE_GDI_MOD, &lp, where, what);
 
3844
         lFreeList(&lp);
 
3845
      } else {   
 
3846
         alp = ctx->gdi(ctx, target_list, SGE_GDI_ADD | SGE_GDI_SET_ALL, &lp, where, what);
 
3847
         lFreeList(&lp);
 
3848
      }
 
3849
 
 
3850
      if (answers != NULL) {
 
3851
         generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
3852
      }
 
3853
      if (answer_list_has_error(&alp)) {
 
3854
         ret = JGDI_ERROR;
 
3855
         goto error;
 
3856
      }
 
3857
      
 
3858
   }
 
3859
   
 
3860
error:
 
3861
 
 
3862
   /*
 
3863
   ** this must be called before throw_error_from_answer_list, otherwise there is a pending 
 
3864
   ** exception in the way
 
3865
   */
 
3866
   sge_gdi_set_thread_local_ctx(NULL);
 
3867
   rmon_set_thread_ctx(NULL);
 
3868
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
3869
 
 
3870
   /* if error throw exception */
 
3871
   if (ret != JGDI_SUCCESS) {
 
3872
      throw_error_from_answer_list(env, ret, alp);
 
3873
   }
 
3874
 
 
3875
   lFreeList(&alp);
 
3876
   lFreeWhat(&what);
 
3877
   DRETURN_VOID;
 
3878
}
 
3879
 
 
3880
void jgdi_delete_array(JNIEnv *env, jobject jgdi, jobjectArray obj_array, const char *classname, int target_list, lDescr *descr, jboolean force, jobject userFilter, jobject answers)
 
3881
{
 
3882
   jgdi_result_t ret = JGDI_SUCCESS;
 
3883
   rmon_ctx_t rmon_ctx;
 
3884
   lList *alp = NULL;
 
3885
   lList *ref_list = NULL;
 
3886
   
 
3887
   DENTER(TOP_LAYER, "jgdi_delete_array");
 
3888
  
 
3889
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
3890
   rmon_set_thread_ctx(&rmon_ctx);
 
3891
 
 
3892
   if (obj_array != NULL) {
 
3893
      int i;
 
3894
      jsize asize = (*env)->GetArrayLength(env, obj_array);
 
3895
      
 
3896
      for (i=0; i<asize; i++) {
 
3897
          jobject obj = (*env)->GetObjectArrayElement(env, obj_array, i);
 
3898
          if (obj) {
 
3899
             if (target_list == SGE_JOB_LIST || target_list == SGE_AR_LIST) {
 
3900
                lListElem *iep = NULL;
 
3901
                const char* name = (*env)->GetStringUTFChars(env, obj, 0);
 
3902
                if (name == NULL) {
 
3903
                   answer_list_add(&alp, "jgdi_delete_array: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
3904
                   goto error;
 
3905
                }
 
3906
                if (target_list == SGE_JOB_LIST) {
 
3907
                   if (sge_parse_jobtasks(&ref_list, &iep, name, &alp, true, NULL) == -1) {
 
3908
                      answer_list_add_sprintf(&alp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, MSG_JOB_XISINVALIDJOBTASKID_S, name);
 
3909
                   }
 
3910
                   lSetUlong(iep, ID_force, force);
 
3911
                 } else {
 
3912
                  iep = lAddElemStr(&ref_list, ID_str, name, ID_Type);
 
3913
                  lSetUlong(iep, ID_force, force);
 
3914
                }
 
3915
                if (name) {
 
3916
                  (*env)->ReleaseStringUTFChars(env, obj, name);
 
3917
                }
 
3918
             } else {   
 
3919
                lListElem *ep = NULL;
 
3920
                if ((ret = obj_to_listelem(env, obj, &ep, descr, &alp)) != JGDI_SUCCESS) {
 
3921
                   goto error;
 
3922
                }
 
3923
                if (ref_list == NULL) {
 
3924
                   ref_list = lCreateList("", descr);
 
3925
                }   
 
3926
                lAppendElem(ref_list, ep);
 
3927
             }
 
3928
          }   
 
3929
      }
 
3930
   }      
 
3931
 
 
3932
   /*
 
3933
   ** handle the userFilter for Job and AdvanceReservation in addition
 
3934
   */
 
3935
   if (userFilter != NULL && (target_list == SGE_JOB_LIST || target_list == SGE_AR_LIST)) {
 
3936
      lList *user_list = NULL;
 
3937
      if (get_string_list(env, userFilter, "getUsers", &user_list, ST_Type, ST_name, &alp) != JGDI_SUCCESS) {
 
3938
         lFreeList(&user_list);
 
3939
         goto error;
 
3940
      }
 
3941
      if (user_list) {
 
3942
         lListElem *iep;
 
3943
         if (lGetNumberOfElem(ref_list) == 0){
 
3944
            iep = lAddElemStr(&ref_list, ID_str, "0", ID_Type);
 
3945
            lSetList(iep, ID_user_list, user_list);
 
3946
            lSetUlong(iep, ID_force, force);
 
3947
         } else {
 
3948
            for_each(iep, ref_list){
 
3949
               lSetList(iep, ID_user_list, user_list);
 
3950
               lSetUlong(iep, ID_force, force);
 
3951
            }
 
3952
         }
 
3953
      }
 
3954
   }
 
3955
   
 
3956
   jgdi_log_printf(env, JGDI_LOGGER, FINER,
 
3957
                   "jgdi_delete_array: ref_list BEGIN ----------------------------------------");
 
3958
   
 
3959
   jgdi_log_list(env, JGDI_LOGGER, FINER, ref_list);
 
3960
 
 
3961
   jgdi_log_printf(env, JGDI_LOGGER, FINER,
 
3962
                   "jgdi_delete_array: ref_list END ----------------------------------------");
 
3963
      
 
3964
   if (ref_list != NULL) {      
 
3965
      sge_gdi_ctx_class_t *ctx = NULL;
 
3966
      /* get context */
 
3967
      ret = getGDIContext(env, jgdi, &ctx, &alp);
 
3968
      if (ret != JGDI_SUCCESS) {
 
3969
         goto error;
 
3970
      }
 
3971
 
 
3972
      alp = ctx->gdi(ctx, target_list, SGE_GDI_DEL, &ref_list, NULL, NULL);
 
3973
      lFreeList(&ref_list);
 
3974
      
 
3975
      if (answers != NULL) {
 
3976
         generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
3977
      }
 
3978
      if (answer_list_has_error(&alp)) {
 
3979
         ret = JGDI_ERROR;
 
3980
      }
 
3981
      
 
3982
   }
 
3983
 
 
3984
error:
 
3985
   /* if error throw exception */
 
3986
   if (ret != JGDI_SUCCESS) {
 
3987
      throw_error_from_answer_list(env, ret, alp);
 
3988
   }
 
3989
   lFreeList(&alp);
 
3990
   rmon_set_thread_ctx(NULL);
 
3991
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
3992
   
 
3993
   DRETURN_VOID;
 
3994
}
 
3995
 
 
3996
void jgdi_delete(JNIEnv *env, jobject jgdi, jobject jobj, const char* classname, int target_list, lDescr *descr, jboolean force, jobject answers)
 
3997
{
 
3998
   lList *lp = NULL;
 
3999
   lList *alp = NULL;
 
4000
   lCondition *where = NULL;
 
4001
   static lEnumeration *what  = NULL;
 
4002
   lListElem *ep = NULL;
 
4003
   sge_gdi_ctx_class_t *ctx = NULL;
 
4004
   jgdi_result_t ret = JGDI_SUCCESS;
 
4005
   rmon_ctx_t rmon_ctx;
 
4006
   lListElem *iep = NULL;
 
4007
   char id_buf[BUFSIZ];
 
4008
   
 
4009
   DENTER(TOP_LAYER, "jgdi_delete");
 
4010
   
 
4011
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4012
   rmon_set_thread_ctx(&rmon_ctx);
 
4013
 
 
4014
   /* get context */
 
4015
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
4016
      goto error;
 
4017
   }
 
4018
   
 
4019
   sge_gdi_set_thread_local_ctx(ctx);
 
4020
   
 
4021
   /* we don't have an element for SGE_SHARETREE_LIST */
 
4022
   if (target_list != SGE_SHARETREE_LIST) {
 
4023
      if ((ret = obj_to_listelem(env, jobj, &ep, descr, &alp)) != JGDI_SUCCESS) {
 
4024
         goto error;
 
4025
      }
 
4026
   }
 
4027
 
 
4028
   /*
 
4029
   ** special handling for JB_Type and AR_Type needed since 
 
4030
   ** they are using ID_Type elements to delete
 
4031
   ** TODO: not yet mapped: deletion of more than one element at once
 
4032
   **                       forced flag
 
4033
   **                       user list support
 
4034
   */
 
4035
   if (target_list == SGE_JOB_LIST) {
 
4036
      sprintf(id_buf, sge_u32, lGetUlong(ep, JB_job_number));
 
4037
      lFreeElem(&ep);
 
4038
      iep = lAddElemStr(&lp, ID_str, id_buf, ID_Type); 
 
4039
      lSetUlong(iep, ID_force, force);
 
4040
      what = lWhat("%T(ALL)", ID_Type);
 
4041
   } else if (target_list == SGE_AR_LIST) {
 
4042
      sprintf(id_buf, sge_u32, lGetUlong(ep, AR_id));
 
4043
      lFreeElem(&ep);
 
4044
      iep = lAddElemStr(&lp, ID_str, id_buf, ID_Type);
 
4045
      lSetUlong(iep, ID_force, force);
 
4046
      what = lWhat("%T(ALL)", ID_Type);
 
4047
   } else if (target_list == SGE_SHARETREE_LIST) {
 
4048
      /* special handling: lp remains NULL */
 
4049
   } else {
 
4050
      lp = lCreateList("", descr);
 
4051
      lAppendElem(lp, ep);
 
4052
      what = lWhat("%T(ALL)", descr);
 
4053
   }   
 
4054
 
 
4055
   /* delete from target_list */
 
4056
   alp = ctx->gdi(ctx, target_list, SGE_GDI_DEL, &lp, where, what);
 
4057
   lFreeList(&lp);
 
4058
 
 
4059
   if (answers != NULL) {
 
4060
      generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4061
   }
 
4062
 
 
4063
   if (answer_list_has_error(&alp)) {
 
4064
      ret = JGDI_ERROR;
 
4065
      goto error;
 
4066
   }
 
4067
   
 
4068
error:
 
4069
 
 
4070
   /*
 
4071
   ** this must be called before throw_error_from_answer_list, otherwise there is a pending 
 
4072
   ** exception in the way
 
4073
   */
 
4074
   sge_gdi_set_thread_local_ctx(NULL);
 
4075
   rmon_set_thread_ctx(NULL);
 
4076
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4077
 
 
4078
   /* if error throw exception */
 
4079
   if (ret != JGDI_SUCCESS) {
 
4080
      throw_error_from_answer_list(env, ret, alp);
 
4081
   }
 
4082
 
 
4083
   lFreeList(&alp);
 
4084
   lFreeWhat(&what);
 
4085
 
 
4086
   DRETURN_VOID;
 
4087
}
 
4088
 
 
4089
void jgdi_update(JNIEnv *env, jobject jgdi, jobject jobj, const char *classname, int target_list, lDescr *descr, jobject answers)
 
4090
{
 
4091
   lList *lp = NULL;
 
4092
   lList *alp = NULL;
 
4093
   lCondition *where = NULL;
 
4094
   static lEnumeration *what  = NULL;
 
4095
   lListElem *ep = NULL;
 
4096
   sge_gdi_ctx_class_t *ctx = NULL;
 
4097
   jgdi_result_t ret = JGDI_SUCCESS;
 
4098
   rmon_ctx_t rmon_ctx;
 
4099
   
 
4100
   DENTER(TOP_LAYER, "jgdi_update");
 
4101
 
 
4102
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4103
   rmon_set_thread_ctx(&rmon_ctx);
 
4104
   
 
4105
   /* get context */
 
4106
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
4107
      goto error;
 
4108
   }
 
4109
   
 
4110
   sge_gdi_set_thread_local_ctx(ctx);
 
4111
 
 
4112
   ret = obj_to_listelem(env, jobj, &ep, descr, &alp);
 
4113
 
 
4114
   if (ret != JGDI_SUCCESS) {
 
4115
      goto error;
 
4116
   }
 
4117
 
 
4118
   lp = lCreateList("", descr);
 
4119
   lAppendElem(lp, ep);
 
4120
   
 
4121
   jgdi_log_printf(env, JGDI_LOGGER, FINE,
 
4122
                   "BEGIN --------------- jgdi_update %s -------------------------------", classname); 
 
4123
   
 
4124
   jgdi_log_list(env, JGDI_LOGGER, FINE, lp);
 
4125
   
 
4126
   jgdi_log_printf(env, JGDI_LOGGER, FINE,
 
4127
                   "END --------------- jgdi_update %s -------------------------------", classname);
 
4128
                   
 
4129
   /* create what and where */
 
4130
   what = lWhat("%T(ALL)", descr);
 
4131
 
 
4132
   alp = ctx->gdi(ctx, target_list, SGE_GDI_MOD | SGE_GDI_SET_ALL, &lp, where, what);
 
4133
   
 
4134
   lFreeList(&lp);
 
4135
   lFreeWhat(&what);
 
4136
 
 
4137
   if (answers != NULL) {
 
4138
      generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4139
   }
 
4140
 
 
4141
   if (answer_list_has_error(&alp)) {
 
4142
      ret = JGDI_ERROR;
 
4143
      goto error;
 
4144
   }
 
4145
   
 
4146
error:
 
4147
   /* if error throw exception */
 
4148
   if (ret != JGDI_SUCCESS) {
 
4149
      throw_error_from_answer_list(env, ret, alp);
 
4150
   }
 
4151
 
 
4152
   lFreeList(&alp);
 
4153
   sge_gdi_set_thread_local_ctx(NULL);
 
4154
   rmon_set_thread_ctx(NULL);
 
4155
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4156
 
 
4157
   DRETURN_VOID;
 
4158
}
 
4159
 
 
4160
/*
 
4161
** -km
 
4162
** -ks
 
4163
** -ke host_list | all
 
4164
** -kej host_list | all
 
4165
** -kec id_list | all
 
4166
*/
 
4167
static void jgdi_kill(JNIEnv *env, jobject jgdi, lList* lp, int kill_target, jobject answers)
 
4168
{
 
4169
   lList *alp = NULL;
 
4170
   sge_gdi_ctx_class_t *ctx = NULL;
 
4171
   const char *default_cell = NULL;
 
4172
   jgdi_result_t ret = JGDI_SUCCESS;
 
4173
   rmon_ctx_t rmon_ctx;
 
4174
   
 
4175
   DENTER(TOP_LAYER, "jgdi_kill");
 
4176
   
 
4177
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4178
   rmon_set_thread_ctx(&rmon_ctx);
 
4179
   
 
4180
   /* get context */
 
4181
   ret = getGDIContext(env, jgdi, &ctx, &alp);
 
4182
 
 
4183
   if (ret == JGDI_SUCCESS) {
 
4184
      default_cell = ctx->get_default_cell(ctx);
 
4185
      alp = ctx->kill(ctx, lp, default_cell, 0, kill_target);
 
4186
      
 
4187
      /* if error throw exception */
 
4188
      if (answers != NULL) {
 
4189
         generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4190
      }
 
4191
      if (answer_list_has_error(&alp)) {
 
4192
         ret = JGDI_ERROR;
 
4193
      }
 
4194
   }
 
4195
   
 
4196
   if (ret != JGDI_SUCCESS) {
 
4197
      throw_error_from_answer_list(env, ret, alp);
 
4198
   }
 
4199
 
 
4200
   lFreeList(&alp);
 
4201
   rmon_set_thread_ctx(NULL);
 
4202
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4203
 
 
4204
   DRETURN_VOID;
 
4205
}
 
4206
 
 
4207
/*
 
4208
** qconf -clearusage
 
4209
** TODO: this operation should be done by qmaster in one sweep,
 
4210
**       implement via SGE_GDI_TRIGGER operation
 
4211
**       otherwise use gdi_multi
 
4212
*/
 
4213
static void jgdi_clearusage(JNIEnv *env, jobject jgdi, jobject answers)
 
4214
{
 
4215
   lList *alp = NULL;
 
4216
   lList *lp = NULL;
 
4217
   lList *lp2 = NULL;
 
4218
   lListElem *ep = NULL;
 
4219
   static lEnumeration *what = NULL;
 
4220
   sge_gdi_ctx_class_t *ctx = NULL;
 
4221
   jgdi_result_t ret = JGDI_SUCCESS;
 
4222
   rmon_ctx_t rmon_ctx;
 
4223
   
 
4224
   DENTER(TOP_LAYER, "jgdi_clearusage");
 
4225
 
 
4226
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4227
   rmon_set_thread_ctx(&rmon_ctx);
 
4228
   
 
4229
   /* get context */
 
4230
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
4231
      goto error;
 
4232
   }
 
4233
 
 
4234
   what = lWhat("%T(ALL)", STN_Type);
 
4235
 
 
4236
   alp = ctx->gdi(ctx, SGE_USER_LIST, SGE_GDI_GET, &lp, NULL, what);
 
4237
   
 
4238
   /* if error throw exception */
 
4239
   if (answer_list_has_error(&alp)) {
 
4240
      ret = JGDI_ERROR;
 
4241
      goto error;
 
4242
   }
 
4243
   lFreeList(&alp);
 
4244
 
 
4245
   alp = ctx->gdi(ctx, SGE_PROJECT_LIST, SGE_GDI_GET, &lp2, NULL, what);
 
4246
 
 
4247
   /* if error throw exception */
 
4248
   if (answer_list_has_error(&alp)) {
 
4249
      ret = JGDI_ERROR;
 
4250
      goto error;
 
4251
   }
 
4252
   lFreeList(&alp);
 
4253
 
 
4254
   /* clear user usage */
 
4255
   for_each(ep, lp) {
 
4256
      lSetList(ep, UU_usage, NULL);
 
4257
      lSetList(ep, UU_project, NULL);
 
4258
   }
 
4259
 
 
4260
   /* clear project usage */
 
4261
   for_each(ep, lp2) {
 
4262
      lSetList(ep, PR_usage, NULL);
 
4263
      lSetList(ep, PR_project, NULL);
 
4264
   }
 
4265
   /* update user usage */
 
4266
   if (lp && lGetNumberOfElem(lp) > 0) {
 
4267
      alp = ctx->gdi(ctx, SGE_USER_LIST, SGE_GDI_MOD, &lp, NULL, NULL);
 
4268
   }
 
4269
 
 
4270
   /* if error throw exception */
 
4271
   if (answers != NULL) {
 
4272
      generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4273
   }
 
4274
   if (answer_list_has_error(&alp)) {
 
4275
      ret = JGDI_ERROR;
 
4276
      goto error;
 
4277
   }
 
4278
   lFreeList(&alp);
 
4279
   
 
4280
   /* update project usage */
 
4281
   if (lp2 && lGetNumberOfElem(lp2) > 0) {
 
4282
      alp = ctx->gdi(ctx, SGE_PROJECT_LIST, SGE_GDI_MOD, &lp2, NULL, NULL);
 
4283
   }
 
4284
 
 
4285
   if (answers != NULL) {
 
4286
      generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4287
   }
 
4288
 
 
4289
error:
 
4290
   /* if error throw exception */
 
4291
   if (ret != JGDI_SUCCESS) {
 
4292
      throw_error_from_answer_list(env, ret, alp);
 
4293
   }
 
4294
 
 
4295
   lFreeList(&alp);
 
4296
   lFreeList(&lp);
 
4297
   lFreeList(&lp2);
 
4298
   rmon_set_thread_ctx(NULL);
 
4299
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4300
 
 
4301
   DRETURN_VOID;
 
4302
}
 
4303
 
 
4304
 
 
4305
/*
 
4306
     qmod [ options ] [ wc_job_range_list | wc_queue_list ]
 
4307
 
 
4308
DESCRIPTION
 
4309
     Qmod enables users classified as owners  (see  queue_conf(5)
 
4310
     for  details)  of  a workstation to modify the state of Grid
 
4311
     Engine queues for his/her machine as well as  the  state  of
 
4312
     his/her  own  jobs.   A manager/operator or root can execute
 
4313
     qmod for any queue and job in  a  cluster.  Find  additional
 
4314
     information  concerning  wc_queue_list  and  wc_job_list  in
 
4315
     sge_types(1).
 
4316
 
 
4317
OPTIONS
 
4318
     -c   Clears   the   error    state    of    the    specified
 
4319
          jobs(s)/queue(s).   Do not use this switch anymore, use
 
4320
          -cj / -cq instead.
 
4321
 
 
4322
     -cj  Clears the error state of the specified jobs(s).
 
4323
 
 
4324
     -cq  Clears the error state of the specified queue(s).
 
4325
 
 
4326
     -d   Disables  the  queue(s),  i.e.  no  further  jobs   are
 
4327
          dispatched  to  disabled queues while jobs already exe-
 
4328
          cuting in these queues are allowed to finish.
 
4329
 
 
4330
     -e   Enables the queue(s).
 
4331
 
 
4332
     -f   Force the modification action for the queue despite the
 
4333
          apparent  current  state of the queue. For example if a
 
4334
          queue appears to be suspended  but  the  job  execution
 
4335
          seems to be continuing the manager/operator can force a
 
4336
          suspend operation which will  send  a  SIGSTOP  to  the
 
4337
          jobs.  In any case, the queue or job status will be set
 
4338
          even if the sge_execd(8)  controlling  the  queues/jobs
 
4339
          cannot    be    reached.    Requires   manager/operator
 
4340
          privileges.
 
4341
 
 
4342
     -r   If applied to queues, reschedules  all  jobs  currently
 
4343
          running  in  this  queue.   If applied to running jobs,
 
4344
          reschedules  the  jobs.  Requires   root   or   manager
 
4345
          privileges.  Do not use this switch anymore, use -rj /-
 
4346
          rq instead.
 
4347
 
 
4348
     -rj  If applied  to  running  jobs,  reschedules  the  jobs.
 
4349
          Requires root or manager privileges.
 
4350
 
 
4351
     -rq  If applied to queues, reschedules  all  jobs  currently
 
4352
          running  in  this  queue.   Requires  root  or  manager
 
4353
          privileges.
 
4354
 
 
4355
     -s   If applied to queues, suspends the queues and any  jobs
 
4356
          which  might  be  active.  If  applied to running jobs,
 
4357
          suspends the jobs. Do not use this switch anymore,  use
 
4358
          -sj / -sq instead.
 
4359
 
 
4360
     -sj  If applied to running jobs, suspends the jobs. If a job
 
4361
          is  both suspended explicitly and via suspension of its
 
4362
          queue, a following unsuspend  of  the  queue  will  not
 
4363
          release the suspension state on the job.
 
4364
 
 
4365
     -sq  If applied to queues, suspends the queues and any  jobs
 
4366
          which might be active.
 
4367
 
 
4368
     -us  If applied to queues, unsuspends  the  queues  and  any
 
4369
          jobs  which  might  be  active.  If  applied  to  jobs,
 
4370
          unsuspends the jobs. Do not use  this  switch  anymore,
 
4371
          use -usj / -usq instead.
 
4372
 
 
4373
     -usj If applied to jobs, unsuspends the jobs. If  a  job  is
 
4374
          both  suspended  explicitly  and  via suspension of its
 
4375
          queue, a following unsuspend  of  the  queue  will  not
 
4376
          release the suspension state on the job.
 
4377
 
 
4378
     -usq If applied to queues, unsuspends  the  queues  and  any
 
4379
          jobs which might be active.
 
4380
 
 
4381
   qconf -cq wc_queue_list             <clean queue>
 
4382
     Cleans queue from jobs which haven't been reaped.  Primarily a
 
4383
     development tool. Requires root/manager/operator privileges.
 
4384
     Find a description of wc_queue_list in sge_types(1).
 
4385
 
 
4386
*/
 
4387
static void jgdi_qmod(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, u_long32 transition, u_long32 option, jobject answers)
 
4388
{
 
4389
   jgdi_result_t ret = JGDI_SUCCESS;
 
4390
   rmon_ctx_t rmon_ctx;
 
4391
   lList *alp = NULL;
 
4392
   
 
4393
   DENTER(TOP_LAYER, "jgdi_qmod");
 
4394
  
 
4395
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4396
   rmon_set_thread_ctx(&rmon_ctx);
 
4397
 
 
4398
   if (obj_array != NULL) {
 
4399
      
 
4400
      sge_gdi_ctx_class_t *ctx = NULL;
 
4401
      int i;
 
4402
      lList *ref_list = NULL;
 
4403
      jsize asize = (*env)->GetArrayLength(env, obj_array);
 
4404
      
 
4405
      if (transition != QI_DO_CLEAN) {
 
4406
         if (!transition_is_valid_for_qinstance(transition, &alp)) {
 
4407
            ret = JGDI_ERROR;
 
4408
            goto error;
 
4409
         }
 
4410
      }
 
4411
      
 
4412
      if (!transition_option_is_valid_for_qinstance(option, &alp)) {
 
4413
         ret = JGDI_ERROR;
 
4414
         goto error;
 
4415
      }
 
4416
      
 
4417
      for (i=0; i<asize; i++) {
 
4418
          jobject obj = (*env)->GetObjectArrayElement(env, obj_array, i);
 
4419
          if (obj) {
 
4420
             lListElem *idep = NULL;
 
4421
             const char* name = (*env)->GetStringUTFChars(env, obj, 0);
 
4422
             if (name == NULL) {
 
4423
                answer_list_add(&alp, "jgdi_qmod: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
4424
                ret = JGDI_ERROR;
 
4425
                goto error;
 
4426
             }
 
4427
             idep = lAddElemStr(&ref_list, ID_str, name, ID_Type);
 
4428
             lSetUlong(idep, ID_action, transition);
 
4429
             lSetUlong(idep, ID_force, option);
 
4430
             if (name) {
 
4431
               (*env)->ReleaseStringUTFChars(env, obj, name);
 
4432
             }
 
4433
          }
 
4434
      }
 
4435
      
 
4436
      jgdi_log_printf(env, JGDI_LOGGER, FINER,
 
4437
                      "jgdi_mod: ref_list BEGIN ----------------------------------------");
 
4438
      
 
4439
      jgdi_log_list(env, JGDI_LOGGER, FINER, ref_list);
 
4440
 
 
4441
      jgdi_log_printf(env, JGDI_LOGGER, FINER,
 
4442
                      "jgdi_mod: ref_list END ----------------------------------------");
 
4443
      
 
4444
      /* get context */
 
4445
      ret = getGDIContext(env, jgdi, &ctx, &alp);
 
4446
      if (ret != JGDI_SUCCESS) {
 
4447
         goto error;
 
4448
      }
 
4449
 
 
4450
      alp = ctx->gdi(ctx, SGE_CQUEUE_LIST, SGE_GDI_TRIGGER, &ref_list, NULL, NULL);
 
4451
      lFreeList(&ref_list);
 
4452
      
 
4453
      if (answers != NULL) {
 
4454
         generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4455
      }
 
4456
      if (answer_list_has_error(&alp)) {
 
4457
         ret = JGDI_ERROR;
 
4458
      }
 
4459
      
 
4460
   }
 
4461
 
 
4462
error:
 
4463
   /* if error throw exception */
 
4464
   if (ret != JGDI_SUCCESS) {
 
4465
      throw_error_from_answer_list(env, ret, alp);
 
4466
   }
 
4467
   lFreeList(&alp);
 
4468
   rmon_set_thread_ctx(NULL);
 
4469
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4470
   
 
4471
   DRETURN_VOID;
 
4472
}
 
4473
 
 
4474
static void jgdi_detached_settings(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jstring *jdetachedStrPtr, jobject answers) {
 
4475
   jgdi_result_t ret = JGDI_SUCCESS;
 
4476
   rmon_ctx_t rmon_ctx;
 
4477
   lList *lp = NULL;
 
4478
   lList *hgroup_list = NULL;
 
4479
   lList *cqueue_list = NULL;
 
4480
   sge_gdi_ctx_class_t *ctx = NULL;
 
4481
   lList *alp =NULL;
 
4482
   jstring jdetachedStr = NULL;
 
4483
   
 
4484
   lEnumeration *hgrp_what = NULL; 
 
4485
   lEnumeration *cqueue_what = NULL;
 
4486
   int hgrp_id = 0; 
 
4487
   int cq_id = 0;
 
4488
   lList *local_answer_list = NULL;
 
4489
   lList *multi_answer_list = NULL;
 
4490
   state_gdi_multi state = STATE_GDI_MULTI_INIT;
 
4491
 
 
4492
   DENTER(TOP_LAYER, "jgdi_detached_settings");
 
4493
 
 
4494
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4495
   rmon_set_thread_ctx(&rmon_ctx);
 
4496
   
 
4497
   if (obj_array != NULL) {
 
4498
      int i;
 
4499
      jsize asize = (*env)->GetArrayLength(env, obj_array);
 
4500
      for (i=0; i<asize; i++) {
 
4501
         jobject obj = (*env)->GetObjectArrayElement(env, obj_array, i);
 
4502
         if (obj) {
 
4503
            const char* queuename = (*env)->GetStringUTFChars(env, obj, 0);
 
4504
            if (queuename == NULL) {
 
4505
               answer_list_add(&alp, "jgdi_detached_settings: GetStringUTFChars failed. Out of memory.", STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
4506
               ret = JGDI_ERROR;
 
4507
               goto error;
 
4508
            }
 
4509
            DPRINTF(("queuename: %s\n", queuename));
 
4510
            lAddElemStr(&lp, CQ_name, queuename, CQ_Type);
 
4511
            (*env)->ReleaseStringUTFChars(env, obj, queuename);
 
4512
         }
 
4513
      }
 
4514
      jgdi_log_printf(env, JGDI_LOGGER, FINER,
 
4515
      "jgdi_show_detached_settings: lp BEGIN ----------------------------------------");
 
4516
      
 
4517
      jgdi_log_list(env, JGDI_LOGGER, FINER, lp);
 
4518
      
 
4519
      jgdi_log_printf(env, JGDI_LOGGER, FINER,
 
4520
      "jgdi_show_detached_settings: lp END ----------------------------------------");
 
4521
      
 
4522
   }
 
4523
   
 
4524
   /* get context */
 
4525
   ret = getGDIContext(env, jgdi, &ctx, &alp);
 
4526
   if (ret != JGDI_SUCCESS) {
 
4527
      goto error;
 
4528
   }
 
4529
   
 
4530
   /* HGRP */
 
4531
   hgrp_what = lWhat("%T(ALL)", HGRP_Type);
 
4532
   hgrp_id = ctx->gdi_multi(ctx, &alp, SGE_GDI_RECORD, SGE_HGROUP_LIST,
 
4533
                           SGE_GDI_GET, NULL, NULL, hgrp_what, &state, true);
 
4534
   lFreeWhat(&hgrp_what);
 
4535
 
 
4536
   /* CQ */
 
4537
   cqueue_what = lWhat("%T(ALL)", CQ_Type);
 
4538
   cq_id = ctx->gdi_multi(ctx, &alp, SGE_GDI_SEND, SGE_CQUEUE_LIST,
 
4539
                         SGE_GDI_GET, NULL, NULL, cqueue_what,
 
4540
                         &state, true);
 
4541
   lFreeWhat(&cqueue_what);
 
4542
   ctx->gdi_wait(ctx, &alp, &multi_answer_list, &state);
 
4543
 
 
4544
   /* HGRP */
 
4545
   sge_gdi_extract_answer(&local_answer_list, SGE_GDI_GET,
 
4546
                   SGE_HGROUP_LIST, hgrp_id, multi_answer_list, &hgroup_list);
 
4547
   if (local_answer_list != NULL) {
 
4548
      lListElem *answer = lFirst(local_answer_list);
 
4549
 
 
4550
      if (lGetUlong(answer, AN_status) != STATUS_OK) {
 
4551
         lDechainElem(local_answer_list, answer);
 
4552
         answer_list_add_elem(&alp, answer);
 
4553
      }
 
4554
   }
 
4555
   lFreeList(&local_answer_list);
 
4556
   
 
4557
   /* CQ */   
 
4558
   sge_gdi_extract_answer(&local_answer_list, SGE_GDI_GET, 
 
4559
                SGE_CQUEUE_LIST, cq_id, multi_answer_list, &cqueue_list);
 
4560
   if (local_answer_list != NULL) {
 
4561
      lListElem *answer = lFirst(local_answer_list);
 
4562
 
 
4563
      if (lGetUlong(answer, AN_status) != STATUS_OK) {
 
4564
         lDechainElem(local_answer_list, answer);
 
4565
         answer_list_add_elem(&alp, answer);
 
4566
      }
 
4567
   } 
 
4568
   lFreeList(&local_answer_list);
 
4569
   lFreeList(&multi_answer_list);
 
4570
      
 
4571
   if (answers != NULL) {
 
4572
      generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4573
   }
 
4574
   if (answer_list_has_error(&alp)) {
 
4575
      ret = JGDI_ERROR;
 
4576
   } else {
 
4577
      jgdi_log_answer_list(env, JGDI_LOGGER, alp);
 
4578
   }
 
4579
   
 
4580
   if (ret != JGDI_ERROR) {
 
4581
      dstring ds = DSTRING_INIT;
 
4582
      lListElem *cqueue = NULL;
 
4583
      
 
4584
      for_each(cqueue, cqueue_list) {
 
4585
         cqueue_sick(cqueue, &alp, hgroup_list, &ds);
 
4586
      }
 
4587
      if (sge_dstring_get_string(&ds)) {
 
4588
         const char *detached_str = sge_dstring_get_string(&ds);
 
4589
         jdetachedStr = (*env)->NewStringUTF(env, detached_str);
 
4590
         sge_dstring_free(&ds);
 
4591
      }
 
4592
   }
 
4593
   *jdetachedStrPtr = jdetachedStr;
 
4594
   
 
4595
error:
 
4596
   /* if error throw exception */
 
4597
   if (ret != JGDI_SUCCESS) {
 
4598
      throw_error_from_answer_list(env, ret, alp);
 
4599
   }
 
4600
   
 
4601
   lFreeList(&alp);
 
4602
   lFreeList(&lp);
 
4603
   rmon_set_thread_ctx(NULL);
 
4604
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4605
 
 
4606
   DRETURN_VOID;
 
4607
}
 
4608
 
 
4609
 
 
4610
/*
 
4611
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4612
 * Method:    nativeKillAllExecdsWithAnswer
 
4613
 * Signature: (ZLjava/util/List;)V
 
4614
 */
 
4615
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillAllExecdsWithAnswer(JNIEnv *env, jobject jgdi, jboolean terminate_jobs, jobject answers)
 
4616
{
 
4617
   int kill_target = EXECD_KILL;
 
4618
   
 
4619
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillAllExecdsWithAnswer");
 
4620
  
 
4621
   if (terminate_jobs) {
 
4622
      kill_target |= JOB_KILL;
 
4623
   }
 
4624
   jgdi_kill(env, jgdi, NULL, kill_target, answers);
 
4625
 
 
4626
   DRETURN_VOID;
 
4627
}
 
4628
 
 
4629
/*
 
4630
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4631
 * Method:    nativeKillExecdWithAnswer
 
4632
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4633
 */
 
4634
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillExecdWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean terminate_jobs, jobject answers)
 
4635
{
 
4636
   lList *lp = NULL;
 
4637
   int kill_target = EXECD_KILL;
 
4638
   
 
4639
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillExecdWithAnswer");
 
4640
  
 
4641
   if (obj_array != NULL) {
 
4642
      int i;
 
4643
      jsize asize = (*env)->GetArrayLength(env, obj_array);
 
4644
      for (i=0; i<asize; i++) {
 
4645
         jobject obj = (*env)->GetObjectArrayElement(env, obj_array, i);
 
4646
         if (obj) {
 
4647
            const char* hostname = (*env)->GetStringUTFChars(env, obj, 0);
 
4648
            if (hostname == NULL) {
 
4649
               return;  /*LP Out of memoery is already thrown in JVM, just return*/
 
4650
            }
 
4651
            DPRINTF(("hostname: %s\n", hostname));
 
4652
            lAddElemHost(&lp, EH_name, hostname, EH_Type);
 
4653
            (*env)->ReleaseStringUTFChars(env, obj, hostname);
 
4654
         }
 
4655
      }
 
4656
   
 
4657
      if (terminate_jobs) {
 
4658
         kill_target |= JOB_KILL;
 
4659
      }
 
4660
      jgdi_kill(env, jgdi, lp, kill_target, answers);
 
4661
      lFreeList(&lp);
 
4662
   }
 
4663
 
 
4664
   DRETURN_VOID;
 
4665
}
 
4666
 
 
4667
/*
 
4668
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4669
 * Method:    nativeKillEventClientsWithAnswer
 
4670
 * Signature: ([ILjava/util/List;)V
 
4671
 */
 
4672
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillEventClientsWithAnswer(JNIEnv *env, jobject jgdi, jintArray iarray, jobject answers)
 
4673
{
 
4674
   jsize length = 0;
 
4675
   jint *ibuf = NULL;
 
4676
   int i;
 
4677
   lList *lp = NULL;
 
4678
 
 
4679
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillEventClientsWithAnswer");
 
4680
 
 
4681
   if (iarray == NULL) {
 
4682
      DEXIT;
 
4683
      return;
 
4684
   }
 
4685
 
 
4686
   length = (*env)->GetArrayLength(env, iarray);
 
4687
 
 
4688
   if (length <= 0) {
 
4689
      DEXIT;
 
4690
      return;
 
4691
   }
 
4692
 
 
4693
   ibuf = (jint *) malloc(sizeof(jint)*length);
 
4694
   
 
4695
   (*env)->GetIntArrayRegion(env, iarray, 0, length, ibuf);
 
4696
   for (i=0; i<length; i++) {
 
4697
      char buffer[BUFSIZ];
 
4698
      sprintf(buffer, "%d", (int) ibuf[i]);
 
4699
      DPRINTF(("ec: %s\n", buffer));
 
4700
      lAddElemStr(&lp, ID_str, buffer, ID_Type);
 
4701
   }
 
4702
   FREE(ibuf);
 
4703
   jgdi_kill(env, jgdi, lp, EVENTCLIENT_KILL, answers);
 
4704
   lFreeList(&lp);
 
4705
 
 
4706
   DRETURN_VOID;
 
4707
}
 
4708
 
 
4709
/*
 
4710
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4711
 * Method:    nativeTriggerSchedulerMonitoringWithAnswer
 
4712
 * Signature: (Ljava/util/List;)V
 
4713
 */
 
4714
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeTriggerSchedulerMonitoringWithAnswer(JNIEnv *env, jobject jgdi, jobject answers)
 
4715
{
 
4716
   lList *alp = NULL;
 
4717
   sge_gdi_ctx_class_t *ctx = NULL;
 
4718
   jgdi_result_t ret = JGDI_SUCCESS;
 
4719
   rmon_ctx_t rmon_ctx;
 
4720
   
 
4721
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeTriggerSchedulerMonitoringWithAnswer");
 
4722
  
 
4723
   jgdi_init_rmon_ctx(env, JGDI_LOGGER, &rmon_ctx);
 
4724
   rmon_set_thread_ctx(&rmon_ctx);
 
4725
   
 
4726
 
 
4727
   /* get context */
 
4728
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) == JGDI_SUCCESS) {
 
4729
      alp = ctx->tsm(ctx, NULL, NULL);
 
4730
      if (answer_list_has_error(&alp)) {
 
4731
         ret = JGDI_ERROR;
 
4732
      }
 
4733
 
 
4734
      if (answers != NULL) {
 
4735
         generic_fill_list(env, answers, "com/sun/grid/jgdi/configuration/JGDIAnswer", alp, NULL);
 
4736
      }
 
4737
   }
 
4738
   
 
4739
   /* if error throw exception */
 
4740
   if (ret != JGDI_SUCCESS) {
 
4741
      throw_error_from_answer_list(env, ret, alp);
 
4742
   }
 
4743
 
 
4744
   lFreeList(&alp);
 
4745
 
 
4746
   rmon_set_thread_ctx(NULL);
 
4747
   jgdi_destroy_rmon_ctx(&rmon_ctx);
 
4748
 
 
4749
   DRETURN_VOID;
 
4750
}
 
4751
 
 
4752
/*
 
4753
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4754
 * Method:    nativeKillAllEventClientsWithAnswer
 
4755
 * Signature: (Ljava/util/List;)V
 
4756
 */
 
4757
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillAllEventClients(JNIEnv *env, jobject jgdi, jobject answers)
 
4758
{
 
4759
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillAllEventClientsWithAnswer");
 
4760
 
 
4761
   jgdi_kill(env, jgdi, NULL, EVENTCLIENT_KILL, answers);
 
4762
 
 
4763
   DRETURN_VOID;
 
4764
}
 
4765
/*
 
4766
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4767
 * Method:    nativeKillMasterWithAnswer
 
4768
 * Signature: (Ljava/util/List;)V
 
4769
 */
 
4770
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillMasterWithAnswer(JNIEnv *env, jobject jgdi, jobject answers)
 
4771
{
 
4772
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillMasterWithAnswer");
 
4773
   
 
4774
   jgdi_kill(env, jgdi, NULL, MASTER_KILL, answers);
 
4775
 
 
4776
   DRETURN_VOID;
 
4777
}
 
4778
/*
 
4779
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4780
 * Method:    nativeKillSchedulerWithAnswer
 
4781
 * Signature: (Ljava/util/List;)V
 
4782
 */
 
4783
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillSchedulerWithAnswer(JNIEnv *env, jobject jgdi, jobject answers)
 
4784
{
 
4785
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeKillSchedulerWithAnswer");
 
4786
 
 
4787
   jgdi_kill(env, jgdi, NULL, SCHEDD_KILL, answers);
 
4788
 
 
4789
   DRETURN_VOID;
 
4790
}
 
4791
 
 
4792
/*
 
4793
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4794
 * Method:    nativeStartSchedulerWithAnswer
 
4795
 * Signature: (Ljava/util/List;)V
 
4796
 */
 
4797
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeStartSchedulerWithAnswer(JNIEnv *env, jobject jgdi, jobject answers)
 
4798
{
 
4799
   lList *lp = NULL;
 
4800
   lListElem *ep = NULL;
 
4801
 
 
4802
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeStartSchedulerWithAnswer");
 
4803
 
 
4804
   ep = lAddElemStr(&lp, ID_str, "scheduler", ID_Type);
 
4805
   lSetUlong(ep, ID_action, SGE_THREAD_TRIGGER_START); 
 
4806
   jgdi_kill(env, jgdi, lp, THREAD_START, answers);
 
4807
   lFreeList(&lp);
 
4808
 
 
4809
   DRETURN_VOID;
 
4810
}
 
4811
 
 
4812
/*
 
4813
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4814
 * Method:    nativeCleanQueuesWithAnswer
 
4815
 * Signature: ([Ljava/lang/String;Ljava/util/List;)V
 
4816
 */
 
4817
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeCleanQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jobject answers)
 
4818
{
 
4819
   u_long32 transition = QI_DO_CLEAN;
 
4820
   u_long32 option = false;
 
4821
   jboolean force = false;
 
4822
 
 
4823
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeCleanQueuesWithAnswer");
 
4824
 
 
4825
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4826
 
 
4827
   DRETURN_VOID;
 
4828
}
 
4829
 
 
4830
/*
 
4831
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4832
 * Method:    nativeUnsuspendWithAnswer
 
4833
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4834
 */
 
4835
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeUnsuspendWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers) 
 
4836
{
 
4837
   u_long32 transition = QI_DO_UNSUSPEND;
 
4838
   u_long32 option = force;
 
4839
 
 
4840
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeUnsuspendWithAnswer");
 
4841
 
 
4842
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4843
 
 
4844
   DRETURN_VOID;
 
4845
}
 
4846
 
 
4847
/*
 
4848
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4849
 * Method:    nativeUnsuspendQueuesWithAnswer
 
4850
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4851
 */
 
4852
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeUnsuspendQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers) 
 
4853
{
 
4854
   u_long32 transition = QI_DO_UNSUSPEND | QUEUE_DO_ACTION;
 
4855
   u_long32 option = force;
 
4856
 
 
4857
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeUnsuspendQueuesWithAnswer");
 
4858
 
 
4859
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4860
 
 
4861
   DRETURN_VOID;
 
4862
}
 
4863
 
 
4864
/*
 
4865
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4866
 * Method:    nativeUnsuspendJobsWithAnswer
 
4867
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4868
 */
 
4869
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeUnsuspendJobsWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4870
{
 
4871
   u_long32 transition = QI_DO_UNSUSPEND | JOB_DO_ACTION;
 
4872
   u_long32 option = force;
 
4873
 
 
4874
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeUnsuspendJobs");
 
4875
 
 
4876
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4877
 
 
4878
   DRETURN_VOID;
 
4879
}
 
4880
 
 
4881
/*
 
4882
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4883
 * Method:    nativeSuspendWithAnswer
 
4884
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4885
 */
 
4886
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeSuspendWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4887
{
 
4888
   u_long32 transition = QI_DO_SUSPEND;
 
4889
   u_long32 option = force;
 
4890
 
 
4891
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeSuspendWithAnswer");
 
4892
 
 
4893
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4894
 
 
4895
   DRETURN_VOID;
 
4896
}
 
4897
 
 
4898
/*
 
4899
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4900
 * Method:    nativeSuspendQueuesWithAnswer
 
4901
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4902
 */
 
4903
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeSuspendQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4904
{
 
4905
   u_long32 transition = QI_DO_SUSPEND | QUEUE_DO_ACTION;
 
4906
   u_long32 option = force;
 
4907
 
 
4908
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeSuspendQueuesWithAnswer");
 
4909
 
 
4910
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4911
 
 
4912
   DRETURN_VOID;
 
4913
}
 
4914
 
 
4915
/*
 
4916
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4917
 * Method:    nativeSuspendJobsWithAnswer
 
4918
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4919
 */
 
4920
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeSuspendJobsWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4921
{
 
4922
   u_long32 transition = QI_DO_SUSPEND | JOB_DO_ACTION;
 
4923
   u_long32 option = force;
 
4924
 
 
4925
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeSuspendJobsWithAnswer");
 
4926
 
 
4927
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4928
 
 
4929
   DRETURN_VOID;
 
4930
}
 
4931
 
 
4932
/*
 
4933
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4934
 * Method:    nativeRescheduleJobsWithAnswer
 
4935
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4936
 */
 
4937
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeRescheduleJobsWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4938
{
 
4939
   u_long32 transition = QI_DO_RESCHEDULE | JOB_DO_ACTION;
 
4940
   u_long32 option = force;
 
4941
 
 
4942
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeRescheduleJobsWithAnswer");
 
4943
 
 
4944
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4945
 
 
4946
   DRETURN_VOID;
 
4947
}
 
4948
 
 
4949
/*
 
4950
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4951
 * Method:    nativeRescheduleWithAnswer
 
4952
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4953
 */
 
4954
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeRescheduleWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4955
{
 
4956
   u_long32 transition = QI_DO_RESCHEDULE;
 
4957
   u_long32 option = force;
 
4958
 
 
4959
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeRescheduleWithAnswer");
 
4960
 
 
4961
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4962
 
 
4963
   DRETURN_VOID;
 
4964
}
 
4965
 
 
4966
/*
 
4967
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4968
 * Method:    nativeRescheduleQueuesWithAnswer
 
4969
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4970
 */
 
4971
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeRescheduleQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4972
{
 
4973
   u_long32 transition = QI_DO_RESCHEDULE | QUEUE_DO_ACTION;
 
4974
   u_long32 option = force;
 
4975
 
 
4976
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeRescheduleQueuesWithAnswer");
 
4977
 
 
4978
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4979
 
 
4980
   DRETURN_VOID;
 
4981
}
 
4982
 
 
4983
/*
 
4984
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
4985
 * Method:    nativeClearJobsWithAnswer
 
4986
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
4987
 */
 
4988
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClearJobsWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
4989
{
 
4990
   u_long32 transition = QI_DO_CLEARERROR | JOB_DO_ACTION;
 
4991
   u_long32 option = force;
 
4992
 
 
4993
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClearJobsWithAnswer");
 
4994
 
 
4995
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
4996
 
 
4997
   DRETURN_VOID;
 
4998
}
 
4999
 
 
5000
/*
 
5001
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5002
 * Method:    nativeClearQueuesWithAnswer
 
5003
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
5004
 */
 
5005
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClearQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
5006
{
 
5007
   u_long32 transition = QI_DO_CLEARERROR | QUEUE_DO_ACTION;
 
5008
   u_long32 option = force;
 
5009
 
 
5010
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClearQueuesWithAnswer");
 
5011
 
 
5012
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
5013
 
 
5014
   DRETURN_VOID;
 
5015
}
 
5016
 
 
5017
/*
 
5018
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5019
 * Method:    nativeDisableQueuesWithAnswer
 
5020
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
5021
 */
 
5022
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeDisableQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
5023
{
 
5024
   u_long32 transition = QI_DO_DISABLE | QUEUE_DO_ACTION;
 
5025
   u_long32 option = force;
 
5026
 
 
5027
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeDisableQueuesWithAnswer");
 
5028
 
 
5029
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
5030
 
 
5031
   DRETURN_VOID;
 
5032
}
 
5033
 
 
5034
/*
 
5035
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5036
 * Method:    nativeEnableQueuesWithAnswer
 
5037
 * Signature: ([Ljava/lang/String;ZLjava/util/List;)V
 
5038
 */
 
5039
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeEnableQueuesWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jboolean force, jobject answers)
 
5040
{
 
5041
   u_long32 transition = QI_DO_ENABLE | QUEUE_DO_ACTION;
 
5042
   u_long32 option = force;
 
5043
 
 
5044
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeEnableQueuesWithAnswer");
 
5045
 
 
5046
   jgdi_qmod(env, jgdi, obj_array, force, transition, option, answers);
 
5047
 
 
5048
   DRETURN_VOID;
 
5049
}
 
5050
 
 
5051
/*
 
5052
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5053
 * Method:    nativeClearShareTreeUsageWithAnswer
 
5054
 * Signature: (Ljava/util/List;)V
 
5055
 */
 
5056
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClearShareTreeUsageWithAnswer(JNIEnv *env, jobject jgdi, jobject answers)
 
5057
{
 
5058
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeClearShareTreeUsageWithAnswer");
 
5059
 
 
5060
   jgdi_clearusage(env, jgdi, answers);
 
5061
   
 
5062
   DRETURN_VOID;
 
5063
}
 
5064
 
 
5065
/*
 
5066
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5067
 * Method:    nativeShowDetachedSettingsAllWithAnswer
 
5068
 * Signature: (Ljava/util/List;)Ljava/lang/String
 
5069
 */
 
5070
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeShowDetachedSettingsAllWithAnswer(JNIEnv *env, jobject jgdi, jobject answers) {
 
5071
   
 
5072
   jstring jdetachedStr = NULL;
 
5073
   
 
5074
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeShowDetachedSettingsAllWithAnswer");
 
5075
   
 
5076
   jgdi_detached_settings(env, jgdi, NULL, &jdetachedStr, answers);
 
5077
   
 
5078
   DRETURN(jdetachedStr);
 
5079
}
 
5080
 
 
5081
/*
 
5082
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5083
 * Method:    nativeShowDetachedSettingsWithAnswer
 
5084
 * Signature: ([Ljava/lang/String;Ljava/util/List)Ljava/lang/String
 
5085
 */
 
5086
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeShowDetachedSettingsWithAnswer(JNIEnv *env, jobject jgdi, jobjectArray obj_array, jobject answers) {
 
5087
   
 
5088
   jstring jdetachedStr = NULL;
 
5089
   
 
5090
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeShowDetachedSettingsWithAnswer");
 
5091
   
 
5092
   jgdi_detached_settings(env, jgdi, obj_array, &jdetachedStr, answers);
 
5093
   
 
5094
   DRETURN(jdetachedStr);
 
5095
}
 
5096
 
 
5097
/*
 
5098
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5099
 * Method:    nativeGetSchedulerHost
 
5100
 * Signature: ()Ljava/lang/String;
 
5101
 */
 
5102
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetSchedulerHost(JNIEnv *env, jobject jgdi)
 
5103
{
 
5104
   jstring jschedd_host = NULL;
 
5105
   lList *lp = NULL;
 
5106
   lList *alp = NULL;
 
5107
   static lCondition *where = NULL;
 
5108
   static lEnumeration *what = NULL;
 
5109
   jgdi_result_t ret = JGDI_SUCCESS;
 
5110
   sge_gdi_ctx_class_t *ctx = NULL;
 
5111
   
 
5112
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeGetSchedulerHost");
 
5113
 
 
5114
   /* get context */
 
5115
   if ((ret = getGDIContext(env, jgdi, &ctx, &alp)) != JGDI_SUCCESS) {
 
5116
      goto error;
 
5117
   }
 
5118
 
 
5119
   what = lWhat("%T(%I)", EV_Type, EV_host);
 
5120
   where = lWhere("%T(%I==%u))", EV_Type, EV_id, EV_ID_SCHEDD);
 
5121
 
 
5122
   /* get list */
 
5123
   alp = ctx->gdi(ctx, SGE_EVENT_LIST, SGE_GDI_GET, &lp, where, what);
 
5124
   
 
5125
   lFreeWhat(&what);
 
5126
   lFreeWhere(&where);
 
5127
 
 
5128
   /* if error throw exception */
 
5129
   if (answer_list_has_error(&alp)) {
 
5130
      ret = JGDI_ERROR;
 
5131
      goto error;
 
5132
   }
 
5133
 
 
5134
   if (lp) {
 
5135
      const char *schedd_host = lGetHost(lFirst(lp), EV_host);
 
5136
      if (schedd_host) {
 
5137
         jschedd_host = (*env)->NewStringUTF(env, schedd_host);
 
5138
      }
 
5139
   }
 
5140
   
 
5141
error:
 
5142
 
 
5143
   /* if error throw exception */
 
5144
   if (ret != JGDI_SUCCESS) {
 
5145
      throw_error_from_answer_list(env, ret, alp);
 
5146
   }
 
5147
 
 
5148
   lFreeList(&alp);
 
5149
   lFreeList(&lp);
 
5150
 
 
5151
   DRETURN(jschedd_host);
 
5152
}
 
5153
 
 
5154
/*
 
5155
 * Class:     com_sun_grid_jgdi_JGDIFactory
 
5156
 * Method:    nativeSetJGDIVersion
 
5157
 * Signature: ()Ljava/lang/String;
 
5158
 */
 
5159
JNIEXPORT jstring JNICALL Java_com_sun_grid_jgdi_JGDIFactory_nativeSetJGDIVersion(JNIEnv *env, jclass jgdi_factory)
 
5160
{
 
5161
   char version_string[BUFSIZ];
 
5162
 
 
5163
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_JGDIFactory_nativeSetJGDIVersion");
 
5164
   sprintf(version_string, "%s %s", GE_SHORTNAME, GDI_VERSION);
 
5165
   DRETURN((*env)->NewStringUTF(env, version_string));
 
5166
}
 
5167
 
 
5168
 
 
5169
/*
 
5170
 * Class:     com_sun_grid_jgdi_util_shell_editor_EditorUtil
 
5171
 * Method:    nativeSgeEdit
 
5172
 * Signature: (Ljava/lang/String;)I
 
5173
 */
 
5174
JNIEXPORT jint JNICALL Java_com_sun_grid_jgdi_util_shell_editor_EditorUtil_nativeSgeEdit(JNIEnv *env, jclass clazz, jstring path) {
 
5175
   jint ret = 0;
 
5176
   uid_t uid = getuid();
 
5177
   uid_t gid = getgid();
 
5178
   const char *strpath = NULL;
 
5179
 
 
5180
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_util_shell_editor_EditorUtil_nativeSgeEdit");
 
5181
 
 
5182
   strpath = (*env)->GetStringUTFChars(env, path, 0);
 
5183
   ret = sge_edit(strpath, uid, gid);
 
5184
   if (strpath) { 
 
5185
      (*env)->ReleaseStringUTFChars(env, path, strpath);
 
5186
   }
 
5187
 
 
5188
   DRETURN(ret);
 
5189
}
 
5190
 
 
5191
 
 
5192
/*
 
5193
 * Class:     com_sun_grid_jgdi_jni_JGDIBaseImpl
 
5194
 * Method:    nativeDeleteShareTreeWithAnswer
 
5195
 * Signature: (Ljava/util/List;)V
 
5196
 */
 
5197
JNIEXPORT void JNICALL Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeDeleteShareTreeWithAnswer(JNIEnv *env, jobject jgdi, jobject answers)
 
5198
{
 
5199
   DENTER(TOP_LAYER, "Java_com_sun_grid_jgdi_jni_JGDIBaseImpl_nativeDeleteShareTreeWithAnswer");
 
5200
   
 
5201
   jgdi_delete(env, jgdi, NULL, "com/sun/grid/jgdi/configuration/ShareTree", SGE_SHARETREE_LIST, STN_Type, false, answers);
 
5202
 
 
5203
   DRETURN_VOID;
 
5204
}
 
5205
 
 
5206
/*-------------------------------------------------------------------------*
 
5207
 * NAME
 
5208
 *   calendar_to_elem - Converts a java.util.Calendar object into
 
5209
 *                      a cull object of type TM_Type
 
5210
 * PARAMETER
 
5211
 *  thiz - the object mapping
 
5212
 *  env  - JNI environment
 
5213
 *  obj  - the java.util.Calendar object
 
5214
 *  elem - the TM_Type object
 
5215
 *  alpp - answer list for error reporting
 
5216
 *
 
5217
 * RETURN
 
5218
 *
 
5219
 *  JGDI_SUCCESS - if the java.util.Calendar object has been successfully
 
5220
 *                 converted into a TM_Type cull object
 
5221
 *
 
5222
 *  JGDI_ERROR   - on error (reason has been reported in alpp)
 
5223
 *
 
5224
 *-------------------------------------------------------------------------*/
 
5225
static jgdi_result_t calendar_to_elem(object_mapping_t *thiz, JNIEnv *env, jobject obj, lListElem *elem, lList **alpp) {
 
5226
   jlong  time = 0;
 
5227
   time_t clock = 0;
 
5228
   struct tm time_str;
 
5229
 
 
5230
   DENTER(JGDI_LAYER, "calendar_to_elem");
 
5231
   
 
5232
   if (Calendar_getTimeInMillis(env, obj, &time, alpp) != JGDI_SUCCESS) {
 
5233
      DRETURN(JGDI_ERROR);
 
5234
   }
 
5235
   memset(&time_str, 0, sizeof(struct tm));
 
5236
   
 
5237
   clock = (time_t)time;
 
5238
   
 
5239
   gmtime_r(&clock, &time_str);
 
5240
   
 
5241
   cullify_tm(elem, &time_str);
 
5242
   
 
5243
   DRETURN(JGDI_SUCCESS);
 
5244
}
 
5245
 
 
5246
 
 
5247
/*-------------------------------------------------------------------------*
 
5248
 * NAME
 
5249
 *   elem_to_calendar - Convert a cull object of type TM_Type into
 
5250
 *                      a java.util.Calendar object
 
5251
 * PARAMETER
 
5252
 *  thiz - the object mapping
 
5253
 *  env  - the JNI environment
 
5254
 *  elem - the cull object
 
5255
 *  obj  - pointer to the java object reference
 
5256
 *  alpp - answer list for error reporting
 
5257
 *
 
5258
 * RETURN
 
5259
 *  JGDI_SUCCESS - if the cull object has been successfully converted
 
5260
 *                 into a java.util.Calendar object
 
5261
 *
 
5262
 *  JGDI_ERROR   - on error (reason has been reported in alpp)
 
5263
 *
 
5264
 *-------------------------------------------------------------------------*/
 
5265
static jgdi_result_t elem_to_calendar(object_mapping_t *thiz, JNIEnv *env, lListElem *elem, jobject* obj, lList **alpp) {
 
5266
   
 
5267
   jlong  time = 0;
 
5268
   struct tm time_str;
 
5269
   
 
5270
   DENTER(JGDI_LAYER, "calendar_to_elem");
 
5271
   
 
5272
   memset(&time_str, 0, sizeof(struct tm));
 
5273
   
 
5274
   uncullify_tm(elem, &time_str);
 
5275
   
 
5276
   time = (jlong)mktime(&time_str);
 
5277
   
 
5278
   if (Calendar_static_getInstance(env, obj, alpp) != JGDI_SUCCESS) {
 
5279
      DRETURN(JGDI_ERROR);
 
5280
   }
 
5281
   
 
5282
   if (Calendar_setTimeInMillis(env, *obj, time, alpp) != JGDI_SUCCESS) {
 
5283
      DRETURN(JGDI_ERROR);
 
5284
   }
 
5285
   
 
5286
   DRETURN(JGDI_SUCCESS);
 
5287
}
 
5288
 
 
5289
 
 
5290
/*-------------------------------------------------------------------------*
 
5291
 * NAME
 
5292
 *   get_object_mapping - Get a object mapping for a cull descriptor
 
5293
 * PARAMETER
 
5294
 *  descr - the cull descriptor
 
5295
 *
 
5296
 * RETURN
 
5297
 *
 
5298
 *  The object mapping of null.
 
5299
 *
 
5300
 * EXTERNAL
 
5301
 *
 
5302
 * DESCRIPTION
 
5303
 *-------------------------------------------------------------------------*/
 
5304
static object_mapping_t* get_object_mapping(const lDescr *descr) {
 
5305
 
 
5306
   int i = 0;
 
5307
   object_mapping_t *mapping = NULL;
 
5308
   
 
5309
   DENTER(JGDI_LAYER, "get_object_mapping");
 
5310
   
 
5311
   for (mapping = OBJECT_MAPPINGS; mapping->descr != NULL; mapping++) {
 
5312
      for(i = lCountDescr(mapping->descr)-1; i >= 0; i--) {
 
5313
         int name = lGetPosName(mapping->descr, i);
 
5314
         if (lGetPosInDescr(descr, name) >= 0) {
 
5315
            DEXIT;
 
5316
            DRETURN(mapping);
 
5317
         }
 
5318
      }
 
5319
   }
 
5320
 
 
5321
   DRETURN(NULL);
 
5322
}
 
5323