Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* |
2 | * Copyright (c) 2001-2002 International Business Machines Corp. | |
3 | * All rights reserved. | |
4 | * | |
5 | * This software has been released under the terms of the IBM Public | |
6 | * License. For details, see the LICENSE file in the top-level source | |
7 | * directory or online at http://www.openafs.org/dl/license10.html | |
8 | * | |
9 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
10 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
11 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
12 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR | |
13 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
14 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
15 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
16 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
17 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
18 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
19 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
20 | */ | |
21 | ||
22 | #include "Internal.h" | |
23 | #include "org_openafs_jafs_Process.h" | |
24 | ||
25 | #include <afs_bosAdmin.h> | |
26 | ||
27 | ///// definitions in Internal.c //////////////////// | |
28 | ||
29 | extern jclass processCls; | |
30 | extern jfieldID process_nameField; | |
31 | extern jfieldID process_typeField; | |
32 | extern jfieldID process_stateField; | |
33 | extern jfieldID process_goalField; | |
34 | extern jfieldID process_startTimeField; | |
35 | extern jfieldID process_numberStartsField; | |
36 | extern jfieldID process_exitTimeField; | |
37 | extern jfieldID process_exitErrorTimeField; | |
38 | extern jfieldID process_errorCodeField; | |
39 | extern jfieldID process_errorSignalField; | |
40 | extern jfieldID process_stateOkField; | |
41 | extern jfieldID process_stateTooManyErrorsField; | |
42 | extern jfieldID process_stateBadFileAccessField; | |
43 | ||
44 | ////////////////////////////////////////////////////////////////// | |
45 | ||
46 | /** | |
47 | * Retrieve the information for the specified process and populate the | |
48 | * given object | |
49 | * | |
50 | * env the Java environment | |
51 | * serverHandle the bos handle of the server on which the process resides | |
52 | * processName the name of the process for which to get the info | |
53 | * process the Process object to populate with the info | |
54 | */ | |
55 | void getProcessInfoChar( JNIEnv *env, void *serverHandle, | |
56 | const char *processName, jobject process ) { | |
57 | ||
58 | afs_status_t ast; | |
59 | bos_ProcessType_t type; | |
60 | bos_ProcessInfo_t infoEntry; | |
61 | bos_ProcessExecutionState_t state; | |
62 | char *auxStatus; | |
63 | ||
64 | // get class fields if need be | |
65 | if( processCls == 0 ) { | |
66 | internal_getProcessClass( env, process ); | |
67 | } | |
68 | ||
69 | if( !bos_ProcessInfoGet( serverHandle, processName, &type, | |
70 | &infoEntry, &ast ) ) { | |
71 | throwAFSException( env, ast ); | |
72 | return; | |
73 | } | |
74 | ||
75 | // set type variable | |
76 | switch( type ) { | |
77 | case BOS_PROCESS_SIMPLE : | |
78 | (*env)->SetIntField(env, process, process_typeField, | |
79 | org_openafs_jafs_Process_SIMPLE_PROCESS); | |
80 | break; | |
81 | case BOS_PROCESS_FS : | |
82 | (*env)->SetIntField(env, process, process_typeField, | |
83 | org_openafs_jafs_Process_FS_PROCESS); | |
84 | break; | |
85 | case BOS_PROCESS_CRON : | |
86 | (*env)->SetIntField(env, process, process_typeField, | |
87 | org_openafs_jafs_Process_CRON_PROCESS); | |
88 | break; | |
89 | default: | |
90 | throwAFSException( env, type ); | |
91 | return; | |
92 | } | |
93 | ||
94 | // set goal variable | |
95 | switch( infoEntry.processGoal ) { | |
96 | case BOS_PROCESS_STOPPED : | |
97 | (*env)->SetIntField(env, process, process_goalField, | |
98 | org_openafs_jafs_Process_STOPPED); | |
99 | break; | |
100 | case BOS_PROCESS_RUNNING : | |
101 | (*env)->SetIntField(env, process, process_goalField, | |
102 | org_openafs_jafs_Process_RUNNING); | |
103 | break; | |
104 | case BOS_PROCESS_STOPPING : | |
105 | (*env)->SetIntField(env, process, process_goalField, | |
106 | org_openafs_jafs_Process_STOPPING); | |
107 | break; | |
108 | case BOS_PROCESS_STARTING : | |
109 | (*env)->SetIntField(env, process, process_goalField, | |
110 | org_openafs_jafs_Process_STARTING); | |
111 | break; | |
112 | default: | |
113 | throwAFSException( env, infoEntry.processGoal ); | |
114 | return; | |
115 | } | |
116 | ||
117 | // set state variable | |
118 | auxStatus = malloc( sizeof(char)*BOS_MAX_NAME_LEN ); | |
119 | if( !auxStatus ) { | |
120 | throwAFSException( env, JAFSADMNOMEM ); | |
121 | return; | |
122 | } | |
123 | if( !bos_ProcessExecutionStateGet( (void *) serverHandle, processName, | |
124 | &state, auxStatus, &ast ) ) { | |
125 | free( auxStatus ); | |
126 | throwAFSException( env, ast ); | |
127 | return; | |
128 | } | |
129 | free( auxStatus ); | |
130 | switch( state ) { | |
131 | case BOS_PROCESS_STOPPED : | |
132 | (*env)->SetIntField(env, process, process_stateField, | |
133 | org_openafs_jafs_Process_STOPPED); | |
134 | break; | |
135 | case BOS_PROCESS_RUNNING : | |
136 | (*env)->SetIntField(env, process, process_stateField, | |
137 | org_openafs_jafs_Process_RUNNING); | |
138 | break; | |
139 | case BOS_PROCESS_STOPPING : | |
140 | (*env)->SetIntField(env, process, process_stateField, | |
141 | org_openafs_jafs_Process_STOPPING); | |
142 | break; | |
143 | case BOS_PROCESS_STARTING : | |
144 | (*env)->SetIntField(env, process, process_stateField, | |
145 | org_openafs_jafs_Process_STARTING); | |
146 | break; | |
147 | default: | |
148 | throwAFSException( env, state ); | |
149 | return; | |
150 | } | |
151 | ||
152 | // set longs | |
153 | (*env)->SetLongField(env, process, process_startTimeField, | |
154 | infoEntry.processStartTime ); | |
155 | (*env)->SetLongField(env, process, process_numberStartsField, | |
156 | infoEntry.numberProcessStarts ); | |
157 | (*env)->SetLongField(env, process, process_exitTimeField, | |
158 | infoEntry.processExitTime ); | |
159 | (*env)->SetLongField(env, process, process_exitErrorTimeField, | |
160 | infoEntry.processExitErrorTime ); | |
161 | (*env)->SetLongField(env, process, process_errorCodeField, | |
162 | infoEntry.processErrorCode ); | |
163 | (*env)->SetLongField(env, process, process_errorSignalField, | |
164 | infoEntry.processErrorSignal ); | |
165 | ||
166 | // set stateOk to true if no core dump | |
167 | if( infoEntry.state & BOS_PROCESS_CORE_DUMPED ) { | |
168 | (*env)->SetBooleanField(env, process, process_stateOkField, FALSE ); | |
169 | } else { | |
170 | (*env)->SetBooleanField(env, process, process_stateOkField, TRUE ); | |
171 | } | |
172 | ||
173 | // set stateTooManyErrors | |
174 | if( infoEntry.state & BOS_PROCESS_TOO_MANY_ERRORS ) { | |
175 | (*env)->SetBooleanField(env, process, | |
176 | process_stateTooManyErrorsField, TRUE ); | |
177 | } else { | |
178 | (*env)->SetBooleanField(env, process, | |
179 | process_stateTooManyErrorsField, FALSE ); | |
180 | } | |
181 | ||
182 | // set stateBadFileAccess | |
183 | if( infoEntry.state & BOS_PROCESS_BAD_FILE_ACCESS ) { | |
184 | (*env)->SetBooleanField(env, process, | |
185 | process_stateBadFileAccessField, TRUE ); | |
186 | } else { | |
187 | (*env)->SetBooleanField(env, process, | |
188 | process_stateBadFileAccessField, FALSE ); | |
189 | } | |
190 | ||
191 | } | |
192 | ||
193 | /** | |
194 | * Fills in the information fields of the provided Process. | |
195 | * | |
196 | * env the Java environment | |
197 | * cls the current Java class | |
198 | * cellHandle the handle of the cell to which the process belongs | |
199 | * jname the instance name of the process for which to get | |
200 | * the information | |
201 | * process the Process object in which to fill | |
202 | * in the information | |
203 | */ | |
204 | JNIEXPORT void JNICALL | |
205 | Java_org_openafs_jafs_Process_getProcessInfo (JNIEnv *env, jclass cls, | |
206 | jlong serverHandle, | |
207 | jstring jname, | |
208 | jobject process) { | |
209 | ||
210 | const char *name; | |
211 | ||
212 | if( jname != NULL ) { | |
213 | name = (*env)->GetStringUTFChars(env, jname, 0); | |
214 | if( !name ) { | |
215 | throwAFSException( env, JAFSADMNOMEM ); | |
216 | return; | |
217 | } | |
218 | } else { | |
219 | name = NULL; | |
220 | } | |
221 | ||
222 | getProcessInfoChar( env, (void *) serverHandle, name, process ); | |
223 | ||
224 | // set name in case blank object | |
225 | if( name != NULL ) { | |
226 | if( processCls == 0 ) { | |
227 | internal_getProcessClass( env, process ); | |
228 | } | |
229 | (*env)->SetObjectField(env, process, process_nameField, jname); | |
230 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
231 | } | |
232 | ||
233 | } | |
234 | ||
235 | /** | |
236 | * Creates a process on a server. | |
237 | * | |
238 | * env the Java environment | |
239 | * cls the current Java class | |
240 | * serverHandle the bos handle of the server to which the key will | |
241 | * belong | |
242 | * jname the instance name to give the process. See AFS | |
243 | * documentation for a standard list of instance names | |
244 | * jtype the type of process this will be. | |
245 | * Acceptable values are: | |
246 | * org_openafs_jafs_Process_SIMPLE_PROCESS | |
247 | * org_openafs_jafs_Process_FS_PROCESS | |
248 | * org_openafs_jafs_Process_CRON_PROCESS | |
249 | * jpath the execution path process to create | |
250 | * jcronTime a String representing the time a cron process is to | |
251 | * be run. Acceptable formats are: | |
252 | * for daily restarts: "23:10" or "11:10 pm" | |
253 | * for weekly restarts: "sunday 11:10pm" or | |
254 | * "sun 11:10pm" | |
255 | * Can be null for non-cron processes. | |
256 | * jnotifier the execution path to a notifier program that should | |
257 | * be called when the process terminates. Can be | |
258 | * null | |
259 | */ | |
260 | JNIEXPORT void JNICALL | |
261 | Java_org_openafs_jafs_Process_create (JNIEnv *env, jclass cls, | |
262 | jlong serverHandle, jstring jname, | |
263 | jint jtype, jstring jpath, | |
264 | jstring jcronTime, | |
265 | jstring jnotifier) { | |
266 | ||
267 | afs_status_t ast; | |
268 | bos_ProcessType_t type; | |
269 | const char *name; | |
270 | const char *path; | |
271 | const char *cronTime; | |
272 | const char *notifier; | |
273 | ||
274 | if( jname != NULL ) { | |
275 | name = (*env)->GetStringUTFChars(env, jname, 0); | |
276 | if( !name ) { | |
277 | throwAFSException( env, JAFSADMNOMEM ); | |
278 | return; | |
279 | } | |
280 | } else { | |
281 | name = NULL; | |
282 | } | |
283 | ||
284 | if( jpath != NULL ) { | |
285 | path = (*env)->GetStringUTFChars(env, jpath, 0); | |
286 | if( !path ) { | |
287 | if( name != NULL ) { | |
288 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
289 | } | |
290 | throwAFSException( env, JAFSADMNOMEM ); | |
291 | return; | |
292 | } | |
293 | } else { | |
294 | path = NULL; | |
295 | } | |
296 | ||
297 | switch( jtype ) { | |
298 | case org_openafs_jafs_Process_SIMPLE_PROCESS: | |
299 | type = BOS_PROCESS_SIMPLE; | |
300 | break; | |
301 | case org_openafs_jafs_Process_FS_PROCESS: | |
302 | type = BOS_PROCESS_FS; | |
303 | break; | |
304 | case org_openafs_jafs_Process_CRON_PROCESS: | |
305 | type = BOS_PROCESS_CRON; | |
306 | break; | |
307 | default: | |
308 | if( name != NULL ) { | |
309 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
310 | } | |
311 | if( path != NULL ) { | |
312 | (*env)->ReleaseStringUTFChars(env, jpath, path); | |
313 | } | |
314 | throwAFSException( env, jtype ); | |
315 | return; | |
316 | } | |
317 | ||
318 | if( jcronTime != NULL ) { | |
319 | cronTime = (*env)->GetStringUTFChars(env, jcronTime, 0); | |
320 | if( !cronTime ) { | |
321 | if( name != NULL ) { | |
322 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
323 | } | |
324 | if( path != NULL ) { | |
325 | (*env)->ReleaseStringUTFChars(env, jpath, path); | |
326 | } | |
327 | throwAFSException( env, JAFSADMNOMEM ); | |
328 | return; | |
329 | } | |
330 | } else { | |
331 | cronTime = NULL; | |
332 | } | |
333 | ||
334 | if( jnotifier != NULL ) { | |
335 | notifier = (*env)->GetStringUTFChars(env, jnotifier, 0); | |
336 | if( !notifier ) { | |
337 | if( name != NULL ) { | |
338 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
339 | } | |
340 | if( path != NULL ) { | |
341 | (*env)->ReleaseStringUTFChars(env, jpath, path); | |
342 | } | |
343 | if( cronTime != NULL ) { | |
344 | (*env)->ReleaseStringUTFChars(env, jcronTime, cronTime); | |
345 | } | |
346 | throwAFSException( env, JAFSADMNOMEM ); | |
347 | return; | |
348 | } | |
349 | } else { | |
350 | notifier = NULL; | |
351 | } | |
352 | ||
353 | if( !bos_ProcessCreate( (void *) serverHandle, name, type, path, | |
354 | cronTime, notifier, &ast ) ) { | |
355 | // release strings | |
356 | if( cronTime != NULL ) { | |
357 | (*env)->ReleaseStringUTFChars(env, jcronTime, cronTime); | |
358 | } | |
359 | if( notifier != NULL ) { | |
360 | (*env)->ReleaseStringUTFChars(env, jnotifier, notifier); | |
361 | } | |
362 | if( name != NULL ) { | |
363 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
364 | } | |
365 | if( path != NULL ) { | |
366 | (*env)->ReleaseStringUTFChars(env, jpath, path); | |
367 | } | |
368 | throwAFSException( env, ast ); | |
369 | return; | |
370 | } | |
371 | ||
372 | ||
373 | // release strings | |
374 | if( cronTime != NULL ) { | |
375 | (*env)->ReleaseStringUTFChars(env, jcronTime, cronTime); | |
376 | } | |
377 | if( notifier != NULL ) { | |
378 | (*env)->ReleaseStringUTFChars(env, jnotifier, notifier); | |
379 | } | |
380 | if( name != NULL ) { | |
381 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
382 | } | |
383 | if( path != NULL ) { | |
384 | (*env)->ReleaseStringUTFChars(env, jpath, path); | |
385 | } | |
386 | ||
387 | } | |
388 | ||
389 | /** | |
390 | * Removes a process from a server. | |
391 | * | |
392 | * env the Java environment | |
393 | * cls the current Java class | |
394 | * serverHandle the bos handle of the server to which the process | |
395 | * belongs | |
396 | * jname the name of the process to remove | |
397 | */ | |
398 | JNIEXPORT void JNICALL | |
399 | Java_org_openafs_jafs_Process_delete (JNIEnv *env, jclass cls, | |
400 | jlong serverHandle, jstring jname) { | |
401 | ||
402 | afs_status_t ast; | |
403 | const char *name; | |
404 | ||
405 | if( jname != NULL ) { | |
406 | name = (*env)->GetStringUTFChars(env, jname, 0); | |
407 | if( !name ) { | |
408 | throwAFSException( env, JAFSADMNOMEM ); | |
409 | return; | |
410 | } | |
411 | } else { | |
412 | name = NULL; | |
413 | } | |
414 | ||
415 | if( !bos_ProcessDelete( (void *) serverHandle, name, &ast ) ) { | |
416 | if( name != NULL ) { | |
417 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
418 | } | |
419 | throwAFSException( env, ast ); | |
420 | return; | |
421 | } | |
422 | ||
423 | if( name != NULL ) { | |
424 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
425 | } | |
426 | ||
427 | } | |
428 | ||
429 | /** | |
430 | * Stop this process. | |
431 | * | |
432 | * env the Java environment | |
433 | * cls the current Java class | |
434 | * serverHandle the bos handle of the server to which the process | |
435 | * belongs | |
436 | * jname the name of the process to stop | |
437 | */ | |
438 | JNIEXPORT void JNICALL | |
439 | Java_org_openafs_jafs_Process_stop (JNIEnv *env, jclass cls, | |
440 | jlong serverHandle, jstring jname) { | |
441 | ||
442 | afs_status_t ast; | |
443 | const char *name; | |
444 | ||
445 | if( jname != NULL ) { | |
446 | name = (*env)->GetStringUTFChars(env, jname, 0); | |
447 | if( !name ) { | |
448 | throwAFSException( env, JAFSADMNOMEM ); | |
449 | return; | |
450 | } | |
451 | } else { | |
452 | name = NULL; | |
453 | } | |
454 | ||
455 | if( !bos_ProcessExecutionStateSet( (void *) serverHandle, name, | |
456 | BOS_PROCESS_STOPPED, &ast ) ) { | |
457 | if( name != NULL ) { | |
458 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
459 | } | |
460 | throwAFSException( env, ast ); | |
461 | return; | |
462 | } | |
463 | ||
464 | if( name != NULL ) { | |
465 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
466 | } | |
467 | ||
468 | } | |
469 | ||
470 | /** | |
471 | * Start this process. | |
472 | * | |
473 | * env the Java environment | |
474 | * cls the current Java class | |
475 | * serverHandle the bos handle of the server to which the process | |
476 | * belongs | |
477 | * jname the name of the process to start | |
478 | */ | |
479 | JNIEXPORT void JNICALL | |
480 | Java_org_openafs_jafs_Process_start (JNIEnv *env, jclass cls, | |
481 | jlong serverHandle, jstring jname) { | |
482 | ||
483 | afs_status_t ast; | |
484 | const char *name; | |
485 | ||
486 | if( jname != NULL ) { | |
487 | name = (*env)->GetStringUTFChars(env, jname, 0); | |
488 | if( !name ) { | |
489 | throwAFSException( env, JAFSADMNOMEM ); | |
490 | return; | |
491 | } | |
492 | } else { | |
493 | name = NULL; | |
494 | } | |
495 | ||
496 | if( !bos_ProcessExecutionStateSet( (void *) serverHandle, name, | |
497 | BOS_PROCESS_RUNNING, &ast ) ) { | |
498 | if( name != NULL ) { | |
499 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
500 | } | |
501 | throwAFSException( env, ast ); | |
502 | return; | |
503 | } | |
504 | ||
505 | if( name != NULL ) { | |
506 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
507 | } | |
508 | ||
509 | } | |
510 | ||
511 | /** | |
512 | * Retart this process. | |
513 | * | |
514 | * env the Java environment | |
515 | * cls the current Java class | |
516 | * serverHandle the bos handle of the server to which the process | |
517 | * belongs | |
518 | * jname the name of the process to restart | |
519 | */ | |
520 | JNIEXPORT void JNICALL | |
521 | Java_org_openafs_jafs_Process_restart (JNIEnv *env, jclass cls, | |
522 | jlong serverHandle, jstring jname) { | |
523 | ||
524 | afs_status_t ast; | |
525 | const char *name; | |
526 | ||
527 | if( jname != NULL ) { | |
528 | name = (*env)->GetStringUTFChars(env, jname, 0); | |
529 | if( !name ) { | |
530 | throwAFSException( env, JAFSADMNOMEM ); | |
531 | return; | |
532 | } | |
533 | } else { | |
534 | name = NULL; | |
535 | } | |
536 | ||
537 | if( !bos_ProcessRestart( (void *) serverHandle, name, &ast ) ) { | |
538 | if( name != NULL ) { | |
539 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
540 | } | |
541 | throwAFSException( env, ast ); | |
542 | return; | |
543 | } | |
544 | ||
545 | if( name != NULL ) { | |
546 | (*env)->ReleaseStringUTFChars(env, jname, name); | |
547 | } | |
548 | ||
549 | } | |
550 | ||
551 | // reclaim global memory being used by this portion | |
552 | JNIEXPORT void JNICALL | |
553 | Java_org_openafs_jafs_Process_reclaimProcessMemory (JNIEnv *env, | |
554 | jclass cls) { | |
555 | ||
556 | if( processCls ) { | |
557 | (*env)->DeleteGlobalRef(env, processCls); | |
558 | processCls = 0; | |
559 | } | |
560 | ||
561 | } | |
562 | ||
563 | ||
564 | ||
565 | ||
566 | ||
567 |