jk_worker_ajp13.c

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

            /* The maximum number of connections is reached */
            ajp13->in_max_epcount = JK_TRUE;
            if( ajp13->cs != NULL ) 
                ajp13->cs->unLock( env, ajp13->cs );
            if( ajp13->mbean->debug > 0 )
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "ajp13.getEndpoint(): maximum %d endpoints for %s reached\n",
                              ajp13->maxEndpoints, 
                              ajp13->mbean->name);
            return JK_ERR;
        }
        ajp13->in_max_epcount = JK_FALSE;

        jkb=env->createBean2( env, ajp13->mbean->pool,  "endpoint", NULL );
        if( jkb==NULL ) {
            if( ajp13->cs != NULL ) 
                ajp13->cs->unLock( env, ajp13->cs );
            return JK_ERR;
        }
    
        e = (jk_endpoint_t *)jkb->object;
        e->worker = ajp13;
        e->sd=-1;

        ajp13->endpointMap->add( env, ajp13->endpointMap, jkb->localName, jkb );
                                 
        *eP = e;

        ret = ajp13->workerEnv->addEndpoint( env, ajp13->workerEnv, e );
    }
    if( ajp13->cs != NULL ) 
        ajp13->cs->unLock( env, ajp13->cs );
        
    if( ajp13->mbean->debug > 0 ) {
        if (ret==JK_OK)
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "ajp13.getEndpoint(): Created endpoint %s %s \n",
                      ajp13->mbean->name, jkb->name);
        else
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "ajp13.getEndpoint(): endpoint creation %s %s failed\n",
                      ajp13->mbean->name, jkb->name);
    }
    
    return ret;
}

/*
 * Serve the request, using AJP13/AJP13
 */
static int JK_METHOD
jk2_worker_ajp13_service(jk_env_t *env, jk_worker_t *w,
                        jk_ws_service_t *s)
{
    int err;
    jk_endpoint_t   *e;

    /* Get endpoint from the pool */
    err=jk2_worker_ajp13_getEndpoint( env, w, &e );
    if  (err!=JK_OK)
      return err;

    if (w->channel->status) {
        err = w->channel->status(env, w, w->channel); 
        if  (err!=JK_OK) {
            jk2_worker_ajp13_done( env, w, e);
            return err;
        }
    }

#ifdef HAS_APR
    if( s->uriEnv!=NULL && s->uriEnv->timing == JK_TRUE ) {
        e->stats->startTime=s->startTime;
        e->stats->jkStartTime=e->stats->connectedTime=apr_time_now();
        if(e->stats->startTime==0)
            e->stats->startTime=e->stats->jkStartTime;
    }
#endif
    e->stats->workerId=w->mbean->id;
    
    err=jk2_worker_ajp13_service1( env, w, s, e );

    /* One error doesn't mean the whole worker is in error state.
     */
    if( err==JK_OK ) {
        e->stats->reqCnt++;
    } else {
        e->stats->errCnt++;
    }

#ifdef HAS_APR
    if( s->uriEnv!=NULL && s->uriEnv->timing == JK_TRUE ) {
        apr_time_t reqTime;

        e->stats->endTime=apr_time_now();
        reqTime=e->stats->endTime - e->stats->startTime;
    
        e->stats->totalTime += reqTime;
        if( e->stats->maxTime < reqTime )
            e->stats->maxTime=reqTime;
    }
#endif
    jk2_worker_ajp13_done( env, w, e);
    return err;
}


static int JK_METHOD
jk2_worker_ajp13_init(jk_env_t *env, jk_bean_t *bean )
{
    jk_worker_t *ajp13=bean->object;
    int  rc;
    int size;
    int i;

    if(ajp13->channel != NULL &&
       ajp13->channel->mbean->debug > 0 ) {
        ajp13->mbean->debug = ajp13->channel->mbean->debug;
    }

    if(ajp13->channel != NULL &&
       ajp13->channel->mbean->disabled  )
        ajp13->mbean->disabled = JK_TRUE;
    
    ajp13->endpointCache=jk2_objCache_create( env, ajp13->mbean->pool  );
        
    if( ajp13->endpointCache == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "ajp13.init(): error creating endpoint cache\n");
        return JK_ERR;
    }
    
    /* Will grow */
    rc=ajp13->endpointCache->init( env, ajp13->endpointCache, -1 );
    if( rc!= JK_OK ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "ajp13.init(): error creating endpoint cache\n");
        return JK_ERR;
    }

    if( ajp13->channel == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "ajp13.init(): No channel %s\n", ajp13->mbean->localName);
        return JK_ERR;
    }

    
    /* Find the groups we are member on and add ourself in
     */
    size=ajp13->groups->size( env, ajp13->groups );
    if( size==0 ) {
        /* No explicit groups, it'll go to default lb */
        jk_worker_t *lb=ajp13->workerEnv->defaultWorker;
        
        lb->mbean->setAttribute(env, lb->mbean, "worker",
                                ajp13->mbean->name);
        if( ajp13->mbean->debug > 0 ) 
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "ajp13.init(): Adding %s to default lb\n", ajp13->mbean->localName);
    } else {
        for( i=0; i<size; i++ ) {
            char *name= ajp13->groups->nameAt( env, ajp13->groups, i );
            jk_worker_t *lb;

            if( ajp13->mbean->debug > 0 )
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "ajp13.init(): Adding %s to %s\n",
                              ajp13->mbean->localName, name);
            if (strncmp(name, "lb:", 3) == 0) {
                lb= env->getByName( env, name );
                if( lb==NULL ) {
                    /* Create the lb group */
                    if( ajp13->mbean->debug > 0 ) 
                        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                                      "ajp13.init(): Automatically creating the group %s\n",
                                      name);
                    env->createBean( env, ajp13->workerEnv->mbean->pool, name );
                    lb= env->getByName( env, name );
                    if( lb==NULL ) {
                        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                                      "ajp13.init(): Failed to create %s\n", name);
                        return JK_ERR;
                    }
                }
            }
            else {
                lb= env->getByName2( env, "lb", name );
                if( lb==NULL ) {
                    /* Create the lb group */
                    if( ajp13->mbean->debug > 0 ) 
                        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                                      "ajp13.init(): Automatically creating the group %s\n",
                                      name);
                    env->createBean2( env, ajp13->workerEnv->mbean->pool, "lb", name );
                    lb= env->getByName2( env, "lb", name );
                    if( lb==NULL ) {
                        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                                      "ajp13.init(): Failed to create %s\n", name);
                        return JK_ERR;
                    }
                }
            }
            lb->mbean->setAttribute(env, lb->mbean, "worker",
                                    ajp13->mbean->name);
        }

    }
    
    /* XXX Find any 'group' property - find or create an lb for that
       and register it
    */
    return JK_OK;
}


static int JK_METHOD
jk2_worker_ajp13_destroy(jk_env_t *env, jk_bean_t *bean)
{
    jk_worker_t *ajp13=bean->object;
    int i;

    if( ajp13->mbean->debug > 0 ) 
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "ajp13.destroy()\n");
    
    if( ajp13->endpointCache != NULL ) {
        jk_endpoint_t *e;
        i=ajp13->endpointCache->count;
        while( ajp13->endpointCache->count > 0 ) {
            
            e= ajp13->endpointCache->get( env, ajp13->endpointCache );
            
            if( e==NULL ) {
                /* we finished all endpoints in the cache */
                break;
            }
            
            
            jk2_close_endpoint(env, e);
        }
        ajp13->endpointCache->destroy( env, ajp13->endpointCache );

        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "ajp13.destroy() closed %d cached endpoints\n",
                      i);
    }

    return JK_OK;
}

int JK_METHOD jk2_worker_ajp13_factory( jk_env_t *env, jk_pool_t *pool,
                                        jk_bean_t *result,
                                        const char *type, const char *name)
{
    jk_worker_t *w=(jk_worker_t *)pool->calloc(env, pool, sizeof(jk_worker_t));
    jk_bean_t *jkb;

    if (name == NULL || w == NULL) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "ajp13.factory() NullPointerException\n");
        return JK_ERR;
    }

    jk2_map_default_create(env, &w->groups, pool);
    jk2_map_default_create(env, &w->endpointMap, pool);

    jkb=env->createBean2(env, pool,"threadMutex", NULL);
    if( jkb != NULL ) {
        w->cs=jkb->object;
        jkb->init(env, jkb );
    }
    
    w->endpointCache= NULL;

    w->channel= NULL;
    w->secret= NULL;

    w->lb_factor=1;
    w->service = jk2_worker_ajp13_service;

    result->setAttribute= jk2_worker_ajp13_setAttribute;
    result->getAttribute= jk2_worker_ajp13_getAttribute;
    result->init= jk2_worker_ajp13_init;
    result->destroy=jk2_worker_ajp13_destroy;

    result->getAttributeInfo=jk2_worker_ajp13_getAttributeInfo;
    result->multiValueInfo=jk2_worker_ajp13_multiValueInfo;
    result->setAttributeInfo=jk2_worker_ajp13_setAttributeInfo;

    result->object = w;
    w->mbean=result;

    w->workerEnv=env->getByName( env, "workerEnv" );
    w->workerEnv->addWorker( env, w->workerEnv, w );

    return JK_OK;
}