/*
 *  Copyright 1999-2004 The Apache Software Foundation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/***************************************************************************
 * Description: Workers controller header file                             *
 * Author:      Gal Shachor <shachor@il.ibm.com>                           * 
 * Version:     $Revision$                                           *
 ***************************************************************************/

#ifndef JK_WORKERENV_H
#define JK_WORKERENV_H

#include "jk_logger.h"
#include "jk_endpoint.h"
#include "jk_config.h"
#include "jk_worker.h"
#include "jk_map.h"
#include "jk_uriMap.h"
#include "jk_uriEnv.h"
#include "jk_handler.h"
#include "jk_service.h"
#include "jk_shm.h"
#include "jk_vm.h"

#ifdef __cplusplus
extern "C"
{
#endif                          /* __cplusplus */

    struct jk_worker;
    struct jk_channel;
    struct jk_endpoint;
    struct jk_env;
    struct jk_config;
    struct jk_uriMap;
    struct jk_uriEnv;
    struct jk_map;
    struct jk_logger;
    struct jk_handler;
    struct jk_ws_service;

/* Temporary hardcoded handler IDs. Will be replaced with a name based dynamic mechanism */

/* Write a body chunk from the servlet container to the web server */
#define JK_HANDLE_AJP13_SEND_BODY_CHUNK    3

/* Send response headers from the servlet container to the web server. */
#define JK_HANDLE_AJP13_SEND_HEADERS       4

/* Marks the end of response. */
#define JK_HANDLE_AJP13_GET_BODY_CHUNK     6

/*  Marks the end of response. */
#define JK_HANDLE_AJP13_END_RESPONSE       5

/* Get a PONG reply from the servlet container. */
#define JK_HANDLE_AJP13_PONG_REPLY       9

/* Second Login Phase (servlet engine -> web server), md5 seed is received */
#define JK_HANDLE_LOGON_SEED	0x11

/* Login Accepted (servlet engine -> web server) */
#define JK_HANDLE_LOGON_OK	0x13

/* Login Rejected (servlet engine -> web server) */
#define JK_HANDLE_LOGON_ERR	0x14

/* Dispatcher for jni channel ( java->C ) */
#define JK_HANDLE_JNI_DISPATCH 0x15

/* Dispatcher for shm object ( java->C) */
#define JK_HANDLE_SHM_DISPATCH 0x16

/* Dispatcher for channel components ( java->C )*/
#define JK_HANDLE_CH_DISPATCH 0x17

/* Dispatcher for mutex object  ( java->C ) */
#define JK_HANDLE_MUTEX_DISPATCH 0x18


/*
 * Jk configuration and global methods. 
 * 
 * Env Information to be provided to worker at init time
 * With AJP14 support we need to have access to many informations
 * about web-server, uri to worker map....
 */
    struct jk_workerEnv
    {
        struct jk_bean *mbean;

        /* Use this pool for all global settings
         */
        struct jk_pool *pool;

        /* Active workers hashtable. 
         */
        struct jk_map *worker_map;

        /* Channels
         */
        struct jk_map *channel_map;

        struct jk_map *endpointMap;

        /* In a multi-process server, like Apache, stores the child
           id in the scoreboard ( if the scoreboard is used ).
           This in turn is used in the jk scoreboard to store informations
           about each instance.
           If -1 - shm is disabled.
         */
        int childId;
        int childProcessId;
        /* maximum configured number of child processes */
        int maxDaemons;

        struct jk_env *globalEnv;

    /** Worker that will be used by default, if no other
        worker is specified. Usefull for SetHandler or
        to avoid the lookup
        XXX no need - lb is the default, easy to get it.
    */
        struct jk_worker *defaultWorker;

        /* Web-Server we're running on (Apache/IIS/NES).
         */
        char *server_name;

        /* XXX Virtual server handled - "*" is all virtual
         */
        char *virtual;

    /** Initialization properties, set via native options or workers.properties.
     */
        /* XXX renamed from init_data to force all code to use setProperty
           This is private property !
         */
        struct jk_map *initData;

        /*
         * Log options. XXX move it to uriEnv, make it configurable per webapp.
         * XXX What about apache native logger ?
         */
        char *logger_name;

        struct jk_uriMap *uriMap;

        int was_initialized;

        /*
         * SSL Support
         */
        int ssl_enable;
        char *https_indicator;
        char *certs_indicator;
        char *cipher_indicator;
        char *session_indicator;        /* Servlet API 2.3 requirement */
        char *key_size_indicator;       /* Servlet API 2.3 requirement */

        /*
         * Jk Options
         */
        int options;

    /** Old REUSE_WORKER define. Instead of using an object pool, use
        thread data to recycle the connection. */
        int perThreadWorker;

        /*
         * Environment variables support
         */
        int envvars_in_use;
        struct jk_map *envvars;

        struct jk_config *config;

        struct jk_shm *shm;

        /* Slot for endpoint stats
         */
        struct jk_shm_slot *epStat;

        /* Handlers. This is a dispatch table for messages, for
         * each message id we have an entry containing the jk_handler_t.
         * lastMessageId is the size of the table.
         */
        struct jk_handler **handlerTable;
        int lastMessageId;

        /* The vm - we support a single instance per process
         * ( i.e can't have both jdk1.1 and jdk1.2 at the same time,
         *  or 2 instances of the same vm. )
         */
        struct jk_vm *vm;

    /** Private data, associated with the 'real' server
     *  server_rec * in apache
     */
        void *_private;

        struct jk_mutex *cs;

        /* Global setting to enable counters on all requests.
         *  That adds about 2-3 ms per request ( at least on linux ),
         *  and will store average and max processing time per endpoint
         *  ( that can be agregated per worker or per server ).
         * Note that we can't collect per request times - it's not
         * thread safe and sync is expensive. As workaround you
         * can enable timers only on a specific request and/or
         * use a dedicated worker/channel for that request.
         */
        int timing;

        /* -------------------- Methods -------------------- */

        /* Register a callback handler, for methods from java to C
         */
        int (*registerHandler) (struct jk_env * env,
                                struct jk_workerEnv * _this,
                                const char *type, const char *name, int id,
                                jk_handler_callback callback,
                                char *signature);


        int (*addWorker) (struct jk_env * env,
                          struct jk_workerEnv * _this, struct jk_worker * w);

        int (*addChannel) (struct jk_env * env,
                           struct jk_workerEnv * _this,
                           struct jk_channel * w);

    /** Add an endpoint. Endpoints are long lived and used to store
        statistics. The endpoint can be in used in only one thread
        at a time, it's a good way to avoid synchronization.
     */
        int (*addEndpoint) (struct jk_env * env, struct jk_workerEnv * wEnv,
                            struct jk_endpoint * ep);

        int (*initChannel) (struct jk_env * env,
                            struct jk_workerEnv * wEnv,
                            struct jk_channel * ch);

    /** Call the handler associated with the message type.
     */
        int (*dispatch) (struct jk_env * env, struct jk_workerEnv * _this,
                         void *target, struct jk_endpoint * ep, int code,
                         struct jk_msg * msg);

    /** Utility method for stream-based workers. It'll read
     *  messages, dispatch, send the response if any until
     *  done. This assumes one native server thread talking
     *  with a different client thread ( on the java side ).
     *  It does not work for jni or doors or other transports
     *  where a single thread is used for the whole processing.
     */
        int (*processCallbacks) (struct jk_env * env,
                                 struct jk_workerEnv * _this,
                                 struct jk_endpoint * e,
                                 struct jk_ws_service * r);

    /**
     * Special init function to be called from the parent process
     * ( with root privs ? ).
     * Used to create the scoreboard ( workaround required at least for HPUX )
     *
     * init() will be called for each child, parentInit() only once.
     */
        int (*parentInit) (struct jk_env * env, struct jk_workerEnv * _this);

    /**
     *  Init the workers, prepare the worker environment. Will read
     *  all properties and set the jk acordignly.
     * 
     *  Replaces wc_open
     */
        int (*init) (struct jk_env * env, struct jk_workerEnv * _this);

    /** Close all workers, clean up
     *
     */
        void (*close) (struct jk_env * env, struct jk_workerEnv * _this);
    };


    typedef struct jk_workerEnv jk_workerEnv_t;


#ifdef __cplusplus
}
#endif                          /* __cplusplus */

#endif                          /* JK_WORKERENV_H */