/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 *
 */

#include "config.h"
#include "qpidd.h"
#include "qpid/Exception.h"
#include "qpid/broker/Broker.h"
#include "qpid/broker/Daemon.h"
#include "qpid/broker/SignalHandler.h"
#include "qpid/log/Logger.h"

#include <iostream>
#include <fstream>
#include <signal.h>
#include <unistd.h>
#include <sys/utsname.h>

using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;

namespace qpid {
namespace broker {

BootstrapOptions::BootstrapOptions(const char* argv0)
    : qpid::Options("Options"),
      common("", QPIDD_CONF_FILE, QPIDC_CONF_FILE),
      module(QPIDD_MODULE_DIR),
      log(argv0)
{
    add(common);
    add(module);
    add(log);
}

void BootstrapOptions::usage() const {
    cout << "Usage: qpidd [OPTIONS]" << endl << endl << *this << endl;
}

namespace {
const std::string TCP = "tcp";
}

struct DaemonOptions : public qpid::Options {
    bool daemon;
    bool quit;
    bool kill;
    bool check;
    std::vector<int> closeFd;
    int wait;
    std::string piddir;
    std::string pidfile;
    std::string transport;

    DaemonOptions() : qpid::Options("Daemon options"), daemon(false), quit(false), kill(false), check(false), wait(600), transport(TCP)
    {
        char *home = ::getenv("HOME");

        if (home == 0)
            piddir += "/tmp";
        else
            piddir += home;
        piddir += "/.qpidd";

        addOptions()
            ("daemon,d", pure_switch(daemon), "Run as a daemon. Logs to syslog by default in this mode.")
            ("transport", optValue(transport, "TRANSPORT"), "The transport for which to return the port")
            ("pid-dir", optValue(piddir, "DIR"), "Directory where port-specific PID file is stored")
            ("pidfile", optValue(pidfile, "FILE"), "File name to store the PID in daemon mode. Used as-is, no directory or suffixes added.")
            ("close-fd", optValue(closeFd, "FD"), "File descriptors that the daemon should close")
            ("wait,w", optValue(wait, "SECONDS"), "Sets the maximum wait time to initialize or shutdown the daemon. If the daemon fails to initialize/shutdown, prints an error and returns 1")
            ("check,c", pure_switch(check), "Prints the daemon's process ID to stdout and returns 0 if the daemon is running, otherwise returns 1")
            ("quit,q", pure_switch(quit), "Tells the daemon to shut down with an INT signal")
            ("kill,k", pure_switch(kill), "Kill the daemon with a KILL signal.");
    }
};

struct QpiddPosixOptions : public QpiddOptionsPrivate {
    DaemonOptions daemon;
    QpiddOptions *parent;

    QpiddPosixOptions(QpiddOptions *parent_) : parent(parent_) {
        parent->add(daemon);
    }
};

QpiddOptions::QpiddOptions(const char* argv0)
    : qpid::Options("Options"),
      common("", QPIDD_CONF_FILE, QPIDC_CONF_FILE),
      module(QPIDD_MODULE_DIR),
      log(argv0)
{
    add(common);
    add(module);
    add(broker);
    add(log);

    platform.reset(new QpiddPosixOptions(this));
    qpid::Plugin::addOptions(*this);
}

void QpiddOptions::usage() const {
    cout << "Usage: qpidd [OPTIONS]" << endl << endl << *this << endl;
}

// Set the broker pointer on the signal handler, then reset at end of scope.
// This is to ensure that the signal handler doesn't keep a broker
// reference after main() has returned.
//
struct ScopedSetBroker {
    ScopedSetBroker(const boost::intrusive_ptr<Broker>& broker) {
        qpid::broker::SignalHandler::setBroker(broker.get());
    }
    ~ScopedSetBroker() { qpid::broker::SignalHandler::setBroker(0); }
};

namespace {

/// Write a pid file if requested
void writePid(const std::string& filename) {
    if (!filename.empty()) {
        ofstream pidfile(filename.c_str());
        pidfile << ::getpid() << endl;
        pidfile.close();
    }
}
}

struct QpiddDaemon : public Daemon {
    QpiddPosixOptions *options;

    QpiddDaemon(std::string pidDir, QpiddPosixOptions *opts)
        : Daemon(pidDir), options(opts) {}

    /** Code for parent process */
    void parent() {
        uint16_t port = wait(options->daemon.wait);
        if (options->parent->broker.port == 0)
            cout << port << endl;
    }

    /** Code for forked child process */
    void child() {
        // Close extra FDs requested in options.
        for (size_t i = 0; i < options->daemon.closeFd.size(); ++i)
            ::close(options->daemon.closeFd[i]);
        boost::intrusive_ptr<Broker> brokerPtr(new Broker(options->parent->broker));
        ScopedSetBroker ssb(brokerPtr);
        brokerPtr->accept();
        uint16_t port=brokerPtr->getPort(options->daemon.transport);
        ready(port);            // Notify parent.
        if (options->parent->broker.enableMgmt && (options->parent->broker.port == 0 || options->daemon.transport != TCP)) {
            boost::dynamic_pointer_cast<qmf::org::apache::qpid::broker::Broker>(brokerPtr->GetManagementObject())->set_port(port);
        }
        writePid(options->daemon.pidfile);
        brokerPtr->run();
    }
};

int QpiddBroker::execute (QpiddOptions *options) {
    // Options that affect a running daemon.
    QpiddPosixOptions *myOptions =
        static_cast<QpiddPosixOptions *>(options->platform.get());
    if (myOptions == 0)
        throw Exception("Internal error obtaining platform options");

    if (myOptions->daemon.check || myOptions->daemon.quit || myOptions->daemon.kill) {
        pid_t pid = 0;
        if (!myOptions->daemon.pidfile.empty()) {
            ifstream pidfile(myOptions->daemon.pidfile.c_str());
            pidfile >> pid;
            pidfile.close();
        }
        if (pid == 0) {
            try {
                pid = Daemon::getPid(myOptions->daemon.piddir, options->broker.port);
            } catch (const Exception& e) {
                // This is not a critical error, usually means broker is not running
                QPID_LOG(notice, "Broker is not running: " << e.what());
                return 1;
            }
        }
        if (pid < 0)
            return 1;
        if (myOptions->daemon.check)
            cout << pid << endl;
        if (myOptions->daemon.quit || myOptions->daemon.kill) {
            int signal = myOptions->daemon.kill ? SIGKILL : SIGINT;
            if (kill(pid, signal) < 0)
                throw Exception("Failed to stop daemon: " + qpid::sys::strError(errno));
            // Wait for the process to die before returning
            int retry=myOptions->daemon.wait*1000;    // Try up to "--wait N" seconds, do retry every millisecond
            while (kill(pid,0) == 0 && --retry)
                sys::usleep(1000);
            if (retry == 0)
                throw Exception("Gave up waiting for daemon process to exit");
        }
        return 0;
    }

    // Starting the broker.
    if (myOptions->daemon.daemon) {
        // For daemon mode replace default stderr with syslog.
        options->log.sinkOptions->detached();
        qpid::log::Logger::instance().configure(options->log);
        // Fork the daemon
        QpiddDaemon d(myOptions->daemon.piddir, myOptions);
        d.fork();           // Broker is stared in QpiddDaemon::child()
    }
    else {                  // Non-daemon broker.
        boost::intrusive_ptr<Broker> brokerPtr(new Broker(options->broker));
        ScopedSetBroker ssb(brokerPtr);
        brokerPtr->accept();
        if (options->broker.port == 0) {
            uint16_t port = brokerPtr->getPort(myOptions->daemon.transport);
            cout << port << endl;
            if (options->broker.enableMgmt) {
                boost::dynamic_pointer_cast<qmf::org::apache::qpid::broker::Broker>(brokerPtr->GetManagementObject())->set_port(port);
            }
        }
        writePid(myOptions->daemon.pidfile);
        brokerPtr->run();
    }
    return 0;
}

}} // namespace qpid::Broker

int main(int argc, char* argv[])
{
    return qpid::broker::run_broker(argc, argv);
}