jk_worker_jni.c

Tomcat 4.1与WebServer集成组件的源代码包.

    if(jniWorker->stderr_name) {
        stderr_name = (*jniEnv)->NewStringUTF(jniEnv, jniWorker->stderr_name);
    }
    
    jniWorker->jk_java_bridge_class =
        (*jniEnv)->FindClass(jniEnv, jniWorker->className );

    if( jniWorker->jk_java_bridge_class == NULL ) {
        int i;
        for( i=0;i<4; i++ ) {
            if( jniWorker->classNameOptions[i] != NULL ) {
                env->l->jkLog(env, env->l, JK_LOG_INFO,
                              "jni.validate() try %s \n",
                              jniWorker->classNameOptions[i]);
                jniWorker->jk_java_bridge_class =
                    (*jniEnv)->FindClass(jniEnv, jniWorker->classNameOptions[i] );
                if(jniWorker->jk_java_bridge_class != NULL )
                    break;
            }
        }
    }
    
    if( jniWorker->jk_java_bridge_class == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "Can't find class %s\n", jniWorker->className );
        /* [V] the detach here may segfault on 1.1 JVM... */
        vm->detach(env, vm);
        return JK_ERR;
    }
    
    env->l->jkLog(env, env->l, JK_LOG_INFO,
                  "Loaded %s\n", jniWorker->className);

/* Instead of loading mod_jk2.so from java, use the JNI RegisterGlobals.
 * XXX Need the way to customize JAVA_BRIDGE_CLASS_APRI, but since
 * it's hardcoded in JniHandler.java doesn't matter for now.
 */
    jniWorker->jk_java_bridge_apri_class =
        (*jniEnv)->FindClass(jniEnv, JAVA_BRIDGE_CLASS_APRI );

    if( jniWorker->jk_java_bridge_apri_class == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "Can't find class %s\n", JAVA_BRIDGE_CLASS_APRI );
        /* [V] the detach here may segfault on 1.1 JVM... */
        vm->detach(env, vm);
        return JK_ERR;
    }

    if (jniWorker->hook == JK2_WORKER_HOOK_STARTUP) {
        rc = jk_jni_aprImpl_registerNatives( jniEnv, jniWorker->jk_java_bridge_apri_class);
        if( rc != 0) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "Can't register native functions for %s \n", JAVA_BRIDGE_CLASS_APRI ); 
            vm->detach(env, vm);
            return JK_ERR;
        }
    }

    rc=jk2_get_method_ids(env, jniWorker, jniEnv);
    if( rc!=JK_OK ) {
        env->l->jkLog(env, env->l, JK_LOG_EMERG,
                      "jniWorker: Fail-> can't get method ids\n");
        /* [V] the detach here may segfault on 1.1 JVM... */
        vm->detach(env, vm);
        return rc;
    }
    /* Set out and err stadard files */ 
    if (jniWorker->stdout_name && jniWorker->jk_setout_method) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.init() setting stdout=%s...\n",jniWorker->stdout_name);
        (*jniEnv)->CallStaticVoidMethod(jniEnv,
                                        jniWorker->jk_java_bridge_apri_class,
                                        jniWorker->jk_setout_method,
                                        stdout_name);
    }
    
    if (jniWorker->stderr_name && jniWorker->jk_seterr_method) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.init() setting stderr=%s...\n",jniWorker->stderr_name);
        (*jniEnv)->CallStaticVoidMethod(jniEnv,
                                        jniWorker->jk_java_bridge_apri_class,
                                        jniWorker->jk_seterr_method,
                                        stderr_name);
    }
    
    if (jniWorker->hook < JK2_WORKER_HOOK_CLOSE) {
        jstringClass=(*jniEnv)->FindClass(jniEnv, "java/lang/String" );

        jargs=(*jniEnv)->NewObjectArray(jniEnv, jniWorker->nArgs, jstringClass, NULL);

        for( i=0; i<jniWorker->nArgs; i++ ) {
            jstring arg=NULL;
            if( jniWorker->args[i] != NULL ) {
                arg=(*jniEnv)->NewStringUTF(jniEnv, jniWorker->args[i] );
                env->l->jkLog(env, env->l, JK_LOG_INFO,
                              "jni.init() ARG %s\n", jniWorker->args[i]);
            }
            (*jniEnv)->SetObjectArrayElement(jniEnv, jargs, i, arg );        
        }
    
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.init() calling main()...\n");
        (*jniEnv)->CallStaticVoidMethod(jniEnv,
                                        jniWorker->jk_java_bridge_class,
                                        jniWorker->jk_main_method,
                                        jargs);
    }
    else {
        /* XXX Is it right thing to disable all non init hooks 
         * or make that customizable.
         */
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.init() disabling the non init hook worker\n");
        _this->lb_disabled = JK_TRUE;
    }
#if 0
    vm->detach(env, vm);
#endif
    /* XXX create a jni channel */
    return JK_OK;
}

static int JK_METHOD jk2_jni_worker_destroy(jk_env_t *env, jk_bean_t *bean)
{
    jk_worker_t *_this=bean->object;
    jni_worker_data_t *jniWorker;
    jk_vm_t *vm;
    JNIEnv *jniEnv;
    jstring cmd_line = NULL;
    jstring stdout_name = NULL;
    jstring stderr_name = NULL;
    jclass jstringClass;
    jarray jargs;
    jstring arg=NULL;

    if(!_this  || ! _this->worker_private) {
        env->l->jkLog(env, env->l, JK_LOG_EMERG,
                      "In destroy, assert failed - invalid parameters\n");
        return JK_ERR;
    }
    vm = _this->workerEnv->vm;
    
    if( vm == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "jni.destroy() No VM found\n");
        return JK_ERR;
    }
    
    jniWorker = _this->worker_private;
    
    if (jniWorker->hook < JK2_WORKER_HOOK_CLOSE) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                       "jni.destroy(), done...worker is not hooked for close\n");
        return JK_OK;
    }
    if (jniWorker->jk_java_bridge_class == NULL ||
        jniWorker->jk_main_method == NULL) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                       "jni.destroy(), done...worker does not have java methods\n");
        return JK_OK;
    }
    if((jniEnv = vm->attach(env, vm))) {
        int i;
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                       "jni.destroy(), shutting down Tomcat...\n");

        jstringClass=(*jniEnv)->FindClass(jniEnv, "java/lang/String" );
        jargs=(*jniEnv)->NewObjectArray(jniEnv, jniWorker->nArgs, jstringClass, NULL);
        for( i=0; i<jniWorker->nArgs; i++ ) {
            jstring arg=NULL;
            if( jniWorker->args[i] != NULL ) {
                arg=(*jniEnv)->NewStringUTF(jniEnv, jniWorker->args[i] );
                env->l->jkLog(env, env->l, JK_LOG_INFO,
                                "jni.init() ARG %s\n", jniWorker->args[i]);
            }
            (*jniEnv)->SetObjectArrayElement(jniEnv, jargs, i, arg );        
        }

        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.destroy() calling main()...\n");

        jk_jni_status_code =0;
        (*jniEnv)->CallStaticVoidMethod(jniEnv,
                                    jniWorker->jk_java_bridge_class,
                                    jniWorker->jk_main_method,
                                    jargs);
        if (jniWorker->hook == JK2_WORKER_HOOK_SHUTDOWN) {
#if APR_HAS_THREADS
            while (jk_jni_status_code != 2) {
                apr_thread_yield();
            }
#endif
            vm->detach(env, vm);
        }
    }
    env->l->jkLog(env, env->l, JK_LOG_INFO, "jni.destroy() done\n");

    return JK_OK;
}

int JK_METHOD jk2_worker_jni_factory(jk_env_t *env, jk_pool_t *pool,
                                     jk_bean_t *result,
                                     const char *type, const char *name)
{
    jk_worker_t *_this;
    jni_worker_data_t *jniData;
    jk_workerEnv_t *wEnv;

    if(name==NULL) {
        env->l->jkLog(env, env->l, JK_LOG_EMERG, 
                      "jni.factory() NullPointerException name==null\n");
        return JK_ERR;
    }

    wEnv = env->getByName( env, "workerEnv" );

    /* No singleton - you can have multiple jni workers,
     running different bridges or starting different programs inprocess*/

    _this=(jk_worker_t *)pool->calloc(env, pool, sizeof(jk_worker_t));
    
    jniData = (jni_worker_data_t *)pool->calloc(env, pool,
                                                sizeof(jni_worker_data_t ));
    if(_this==NULL || jniData==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "jni.factory() OutOfMemoryException \n");
        return JK_ERR;
    }

    _this->worker_private=jniData;

    jniData->jk_java_bridge_class  = NULL;
    jniData->classNameOptions=(char **)pool->calloc(env, pool, 4 * sizeof(char *));

    jniData->args = pool->calloc( env, pool, 64 * sizeof( char *));
    jniData->nArgs =0;
    jniData->stdout_name= NULL;
    jniData->stderr_name= NULL;

    result->init           = jk2_jni_worker_init;
    result->destroy        = jk2_jni_worker_destroy;
    _this->service = jk2_jni_worker_service;

    result->object = _this;
    result->setAttribute = jk2_jni_worker_setProperty;
    _this->mbean=result;

    _this->workerEnv = wEnv;
    _this->workerEnv->addWorker( env, _this->workerEnv, _this );

    return JK_OK;
}
#else

int JK_METHOD jk2_worker_jni_factory(jk_env_t *env, jk_pool_t *pool,
                                     jk_bean_t *result,
                                     const char *type, const char *name)
{
    result->disabled=1;
    
    return JK_OK;
}
     
#endif