metaproxy_prog.cpp File Reference

#include "config.hpp"
#include <yaz/log.h>
#include <yaz/options.h>
#include <yaz/daemon.h>
#include <yaz/sc.h>
#include <yaz/backtrace.h>
#include <iostream>
#include <stdexcept>
#include <libxml/xinclude.h>
#include <metaproxy/filter.hpp>
#include <metaproxy/package.hpp>
#include <metaproxy/util.hpp>
#include <metaproxy/router_xml.hpp>
#include <stdlib.h>
#include <signal.h>

Include dependency graph for metaproxy_prog.cpp:

Go to the source code of this file.

Functions
static void	set_log_prefix (void)
static void	work_common (void *data)
static void	work_debug (void *data)
static void	work_normal (void *data)
static int	sc_main (yaz_sc_t s, int argc, char **argv)
static void	sc_stop (yaz_sc_t s)
int	main (int argc, char **argv)

Variables
mp::RouterXML *	routerp = 0

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 327 of file metaproxy_prog.cpp.

{
    int ret;
    yaz_sc_t s = yaz_sc_create("metaproxy", "metaproxy");
 
    ret = yaz_sc_program(s, argc, argv, sc_main, sc_stop);
 
    yaz_sc_destroy(&s);
    exit(ret);
}

References sc_main(), and sc_stop().

Here is the call graph for this function:

sc_main()

static int sc_main ( yaz_sc_t  s, int  argc, char **  argv  )

static

Definition at line 120 of file metaproxy_prog.cpp.

{
    bool test_config = false;
    const char *fname = 0;
    int ret;
    char *arg;
    unsigned mode = 0;
    const char *pidfile = 0;
    const char *uid = 0;
#if HAVE_GETRLIMIT
    const char *socket_limit = 0;
#endif
 
    yaz_enable_panic_backtrace(argv[0]);
    set_log_prefix();
 
    while ((ret = options("c{config}:Dh{help}l:m:p:s:tu:v:V{version}w:X",
                          argv, argc, &arg)) != -2)
    {
        switch (ret)
        {
        case 'c':
            fname = arg;
            break;
        case 'D':
            mode = YAZ_DAEMON_FORK|YAZ_DAEMON_KEEPALIVE;
            break;
        case 'h':
            std::cerr << "metaproxy\n"
                " -h|--help     help\n"
                " -V|--version  version\n"
                " -v level\n"
                " -c|--config f config filename\n"
                " -D            daemon and keepalive operation\n"
                " -l f          log file f\n"
                " -m logformat  log time format (strftime)\n"
                " -p f          pid file f\n"
                " -s n          socket limit\n"
                " -t            test configuration\n"
                " -u id         change uid to id\n"
                " -w dir        changes working directory to dir\n"
                " -X            debug mode (no fork/daemon mode)\n"
#ifdef WIN32
                " -install      install windows service\n"
                " -remove       remove windows service\n"
#endif
 
                      << std::endl;
            break;
        case 'l':
            yaz_log_init_file(arg);
            break;
        case 'm':
            yaz_log_time_format(arg);
            break;
        case 'p':
            pidfile = arg;
            break;
        case 's':
#if HAVE_GETRLIMIT
            socket_limit = arg;
#else
            yaz_log(YLOG_WARN, "Option -s unsuppoted on this platform");
#endif
            break;
        case 't':
            test_config = true;
            break;
        case 'u':
            uid = arg;
            break;
        case 'v':
            yaz_log_init_level(yaz_log_mask_str(arg));
            break;
        case 'V':
            std::cout << VERSION;
#ifdef VERSION_SHA1
            std::cout << " " VERSION_SHA1;
#endif
            std::cout << "\n";
            return 0;
            break;
        case 'w':
            if (
#ifdef WIN32
                _chdir(arg)
#else
                chdir(arg)
#endif
                )
            {
                std::cerr << "chdir " << arg << " failed" << std::endl;
                return 1;
            }
        case 'X':
            mode = YAZ_DAEMON_DEBUG;
            break;
        case -1:
            std::cerr << "bad option: " << arg << std::endl;
            return 1;
        }
    }
    if (!fname)
    {
        std::cerr << "No configuration given; use -h for help\n";
        return 1;
    }
 
    yaz_log(YLOG_LOG, "metaproxy %s " VERSION
#ifdef VERSION_SHA1
                " " VERSION_SHA1
#endif
        , test_config ? "test" : "start"
            );
 
    char yaz_version_str[20];
    char yaz_sha1_str[41];
    yaz_version(yaz_version_str, yaz_sha1_str);
    yaz_log(YLOG_LOG, "YAZ %s %s", yaz_version_str, yaz_sha1_str);
 
    xmlInitParser();
    LIBXML_TEST_VERSION
 
    yaz_log_xml_errors(0, YLOG_LOG);
    xmlDocPtr doc = xmlReadFile(fname,
                                NULL,
                                XML_PARSE_XINCLUDE + XML_PARSE_NOBLANKS
                                + XML_PARSE_NSCLEAN + XML_PARSE_NONET );
 
    if (!doc)
    {
        yaz_log(YLOG_FATAL,"XML parsing failed");
        return 1;
    }
    // and perform Xinclude then
    int r = xmlXIncludeProcess(doc);
    if (r == -1)
    {
        yaz_log(YLOG_FATAL, "XInclude processing failed");
        return 1;
    }
    mp::wrbuf base_path;
    const char *last_p = strrchr(fname,
#ifdef WIN32
                                 '\\'
#else
                                 '/'
#endif
        );
    if (last_p)
        wrbuf_write(base_path, fname, last_p - fname);
    else
        wrbuf_puts(base_path, ".");
    ret = 0;
    try {
        mp::RouterXML *router =
            new mp::RouterXML(doc, test_config, wrbuf_cstr(base_path));
        if (!test_config)
        {
#if HAVE_GETRLIMIT
            if (socket_limit)
            {
                struct rlimit limit_data;
                limit_data.rlim_cur = atoi(socket_limit);
                limit_data.rlim_max = atoi(socket_limit);
                int r = setrlimit(RLIMIT_NOFILE, &limit_data);
                if (r)
                {
                    yaz_log(YLOG_FATAL,"setrlimit: %s", strerror(errno));
                    return 1;
                }
 
            }
#endif
            yaz_sc_running(s);
 
            yaz_daemon("metaproxy", mode | YAZ_DAEMON_LOG_REOPEN,
                       (mode & YAZ_DAEMON_FORK) ? work_normal : work_debug,
                       router, pidfile, uid);
        }
        delete router;
    }
    catch (std::logic_error &e) {
        yaz_log(YLOG_FATAL,"std::logic error: %s" , e.what() );
        ret = 1;
    }
    catch (std::runtime_error &e) {
        yaz_log(YLOG_FATAL, "std::runtime error: %s" , e.what() );
        ret = 1;
    }
    catch ( ... ) {
        yaz_log(YLOG_FATAL, "Unknown Exception");
        ret = 1;
    }
    xmlFreeDoc(doc);
    if (test_config)
        yaz_log(YLOG_LOG, "metaproxy test exit code %d", ret);
    return ret;
}

References set_log_prefix(), VERSION, VERSION_SHA1, work_debug(), and work_normal().

Referenced by main().

Here is the call graph for this function:

sc_stop()

static void sc_stop ( yaz_sc_t  s )

static

Definition at line 322 of file metaproxy_prog.cpp.

{
    return;
}

Referenced by main().

set_log_prefix()

static void set_log_prefix ( void  )

static

Definition at line 55 of file metaproxy_prog.cpp.

{
#if HAVE_UNISTD_H
    char str[80];
 
    sprintf(str, "%lld", (long long) getpid());
    yaz_log_init_prefix(str);
#endif
}

Referenced by sc_main(), and work_common().

work_common()

static void work_common ( void *  data )

static

Definition at line 85 of file metaproxy_prog.cpp.

{
    set_log_prefix();
#if HAVE_UNISTD_H
    process_group = getpgid(0); // save process group ID
    my_pid = getpid();
 
    signal(SIGTERM, sig_x_handler);
    signal(SIGUSR1, sig_x_handler);
#endif
    routerp = (mp::RouterXML*) data;
    routerp->start();
 
    mp::Package pack;
    pack.router(*routerp).move();
    yaz_log(YLOG_LOG, "metaproxy stop");
    delete routerp;
    routerp = 0;
    _exit(0);
}

References routerp, and set_log_prefix().

Referenced by work_debug(), and work_normal().

Here is the call graph for this function:

work_debug()

static void work_debug ( void *  data )

static

Definition at line 106 of file metaproxy_prog.cpp.

{
    work_common(data);
}

References work_common().

Referenced by sc_main().

Here is the call graph for this function:

work_normal()

static void work_normal ( void *  data )

static

Definition at line 111 of file metaproxy_prog.cpp.

{
#if HAVE_UNISTD_H
    /* make the current working process group leader */
    setpgid(0, 0);
#endif
    work_common(data);
}

References work_common().

Referenced by sc_main().

Here is the call graph for this function:

Variable Documentation

routerp

mp::RouterXML* routerp = 0

Definition at line 53 of file metaproxy_prog.cpp.

Referenced by work_common().