main.cpp

#include <crow.h>
#include <odb/database.hxx>
#include <odb/session.hxx>
#include <scs/api.hpp>
#include <scs/config.hpp>
#include <scs/test_data_generator.hpp>
#include <unistd.h>

class Publisher;
class GoogleAuthenticator;
class SymlessAuthenticator;

static void
init_api (std::shared_ptr<odb::database> db, Config config,
          uint16_t const num_threads, GoogleAuthenticator& login_with_google,
          SymlessAuthenticator& login_with_symless, Publisher& publisher) {
    crow::SimpleApp app;

    CROW_ROUTE (app, "/support/<int>")
        .methods ("GET"_method) (
            [db](crow::request const& request, int64_t user_id) {
                odb::session session;
                return user_supportid (std::move (db), request, user_id);
            });

    CROW_ROUTE (app, "/status")
        .methods ("GET"_method) (
            [db](crow::request const& request) { return "thisisfine"; });

    CROW_ROUTE (app, "/login")
        .methods ("POST"_method) ([db](crow::request const& request) {
            odb::session session;
            return login (std::move (db), request);
        });

    CROW_ROUTE (app, "/login/with-google")
        .methods ("GET"_method) (
            [db, &login_with_google](crow::request const& request) {
                odb::session session;
                return login_with_auth_code (
                    std::move (db), request, login_with_google);
            });

    CROW_ROUTE (app, "/login/with-symless")
        .methods ("GET"_method) (
            [db, &login_with_symless](crow::request const& request) {
                odb::session session;
                return login_with_auth_code (
                    std::move (db), request, login_with_symless);
            });

    CROW_ROUTE (app, "/user/identify")
        .methods ("GET"_method) ([db](crow::request const& request) {
            odb::session session;
            return user_identify (std::move (db), request);
        });

    CROW_ROUTE (app, "/user/screens")
        .methods ("GET"_method) ([db](crow::request const& request) {
            odb::session session;
            return user_screens (std::move (db), request);
        });

    CROW_ROUTE (app, "/user/profiles")
        .methods ("GET"_method) ([db](crow::request const& request) {
            odb::session session;
            return user_profiles (std::move (db), request);
        });

    CROW_ROUTE (app, "/profile/<uint>/screens")
        .methods ("GET"_method) (
            [db](crow::request const& request, uint64_t profile_id) {
                odb::session session;
                return profile_screens (std::move (db), request, profile_id);
            });

    CROW_ROUTE (app, "/profile/switch")
        .methods ("POST"_method) ([db](crow::request const& request) {
            odb::session session;
            return switch_profile (std::move (db), request);
        });

    CROW_ROUTE (app, "/profile/update")
        .methods ("POST"_method) (
            [db, &publisher](crow::request const& request) {
                odb::session session;
                return update_profile (std::move (db), request, publisher);
            });

    /* TODO: rename to 'leave'
     * Conditions:
     *  - Don't allow a screen to leave its only profile.
     *  - Afterwards, if no other screens are in the profile, delete it.
     */
    CROW_ROUTE (app, "/profile/unsub")
        .methods ("POST"_method) (
            [db, &publisher](crow::request const& request) {
                odb::session session;
                return unsubscribe_profile (std::move (db), request, publisher);
            });

    CROW_ROUTE (app, "/profile/server/claim")
        .methods ("POST"_method) (
            [db, &publisher](crow::request const& request) {
                return claim_server (std::move (db), request, publisher);
            });

    /* TODO: probably should be renamed to /screen/status */
    CROW_ROUTE (app, "/screen/update")
        .methods ("POST"_method) (
            [db, &publisher](crow::request const& request) {
                return update_screen (std::move (db), request, publisher);
            });
    CROW_ROUTE (app, "/screen/status/update")
        .methods (
            "POST"_method) ([db, &publisher](crow::request const& request) {
            return update_screen_status (std::move (db), request, publisher);
        });

    CROW_ROUTE (app, "/screen/error/update")
        .methods ("POST"_method) (
            [db, &publisher](crow::request const& request) {
                return update_screen_error (std::move (db), request, publisher);
            });

    CROW_ROUTE (app, "/report")
        .methods ("POST"_method) ([db](crow::request const& request) {
            odb::session session;
            return report (std::move (db), request);
        });

    CROW_ROUTE (app, "/version")
        .methods ("GET"_method) ([&config](crow::request const& request) {
            odb::session session;
            return latest_version (request, config);
        });

    CROW_ROUTE (app, "/update")
        .methods ("POST"_method) ([&config](crow::request const& request) {
            odb::session session;
            return update_check (request, config);
        });

    CROW_ROUTE (app, "/stats/connectivity")
        .methods ("GET"_method) ([db](crow::request const& request) {
            odb::session session;
            return connectivity_stats (std::move (db), request);
        });

    CROW_ROUTE (app, "/nchan/authorize")
        .methods ("GET"_method) (
            [db, &publisher, &config](crow::request const& request) {
                return nchan_auth (db, request, publisher, config);
            });

    CROW_ROUTE (app, "/nchan/unsubscribe")
        .methods ("GET"_method) (
            [db, &publisher, &config](crow::request const& request) {
                odb::session session;
                return nchan_unsubscribe (
                    std::move (db), request, publisher, config);
            });

    CROW_ROUTE (app, "/test/claim")
        .methods ("POST"_method) (
            [db, &publisher, &config](crow::request const& request) {
                odb::session session;
                return test_claim (std::move (db), request, publisher, config);
            });

    CROW_ROUTE (app, "/slack/event")
        .methods ("POST"_method) ([db, &config](crow::request const& request) {
            return slack_event (std::move (db), request, config);
        });

    CROW_ROUTE (app, "/dummy/screen/status/update")
        .methods ("POST"_method) (
            [db](crow::request const&) { return crow::response (); });

    app.port (8080).concurrency (num_threads).run ();
}

#include <cstring>
#include <cxxopts.hpp>
#include <odb/pgsql/connection-factory.hxx>
#include <odb/pgsql/database.hxx>
#include <odb/schema-catalog.hxx>
#include <scs/google_authenticator.hpp>
#include <scs/pubsub/publisher.hpp>
#include <scs/symless_authenticator.hpp>

static bool
init_database (std::shared_ptr<odb::database> db, Config dbcfg) {
    std::cout << " *!* ***************************************** *!*\n"
                 " *!*    You are about to *WIPE* the database   *!*\n"
                 " *!*         ALL USER DATA WILL BE LOST        *!*\n"
                 " *!* ***************************************** *!*\n";

    std::string response;
    boost::system::error_code ec;
    boost::asio::ip::address::from_string (
        dbcfg.get_value<std::string> ("host"), ec);
    if (!ec) {
        std::cout
            << "\n *!* The database hostname is set to an IP address."
               "\n *?* Are you sure you know what server you are wiping?\n";
    }

    std::cout << "\n *!* Type the database hostname address to confirm"
                 "\n > ";
    std::getline (std::cin, response);
    boost::algorithm::to_lower (response);
    if (response != boost::algorithm::to_lower_copy (
                        dbcfg.get_value<std::string> ("host"))) {
        return false;
    }

    std::cout << "\n *!* Destroying data in..."
                 "\n *!* "
              << std::flush;
    for (auto i = 10; i >= 1; --i) {
        std::cout << i << ".. " << std::flush;
        sleep (1);
    }
    std::cout << "0\n" << std::endl;

    odb::transaction t (db->begin ());
    odb::schema_catalog::create_schema (*db, "scs");
    t.commit ();
    return true;
}

static auto
connect_to_database (Config config) {
    std::unique_ptr<odb::pgsql::connection_factory> connection_factory =
        std::make_unique<odb::pgsql::connection_pool_factory> (
            config.get_value_or<int64_t> ("max-connections", 80),
            config.get_value_or<int64_t> ("min-connections", 10));

    std::shared_ptr<odb::database> db = std::make_shared<odb::pgsql::database> (
        config.get_value<std::string> ("username"),
        config.get_value<std::string> ("password"),
        config.get_value<std::string> ("database"),
        config.get_value<std::string> ("host"),
        config.get_value_or<uint16_t> ("port", 0),
        config.get_value_or<std::string> ("extra-conninfo", "sslmode=require"),
        std::move (connection_factory));

    return db;
}

int
main (int argc, char* argv[]) {
    std::ios::sync_with_stdio (false);

    /* clang-format off */
    cxxopts::Options options ("scs", "Synergy Cloud Server");
    options.add_options ()
        ("c,config", "Config file path", cxxopts::value<std::string> ()->default_value ("scs.cfg"))
        ("init", "Wipe and reinitialize the database")
        ("init-test", "Wipe and reinitialize the database, and fill it with test data");
    /* clang-format on */

    /* Parse command line arguments */
    auto const args   = options.parse (argc, argv);
    auto const config = Config::parse_file (args["config"].as<std::string> ());
    auto const db_config = config.get_section ("db.postgres");
    auto const db        = connect_to_database (db_config);

    /* Initialize the database, wiping all data */
    if (args["init"].count () || args["init-test"].count ()) {
        if (!init_database (db, db_config)) {
            return EXIT_FAILURE;
        }
    }

    /* Initialize test data */
    if (args["init-test"].count ()) {
        auto test_data_config = config.get_section ("test.data");
        TestDataGenerator generator (test_data_config);
        generator.create (db);
    }

    /* Initialize OAuth providers */
    auto login_service = std::make_shared<boost::asio::io_service> ();
    GoogleAuthenticator login_with_google (login_service,
                                           config.get_section ("auth.google"));
    SymlessAuthenticator login_with_symless (
        login_service, config.get_section ("auth.symless"));
    std::thread login_thread ([&]() { login_service->run (); });

    /* Initialize the publisher on its own thread for pushing config updates
     * to users */
    auto publisher_service = std::make_shared<boost::asio::io_service> ();
    Publisher publisher (publisher_service, config.get_section ("pubsub"));
    std::thread publisher_thread ([&]() { publisher_service->run (); });

    /* Initialize the API */
    auto const num_threads =
        db_config.get_value_or<uint16_t> ("min-connections", 1);
    init_api (db,
              config,
              num_threads,
              login_with_google,
              login_with_symless,
              publisher);

    /* Shutdown all services */
    publisher.stop ();
    login_with_google.stop ();
    login_with_symless.stop ();

    /* Join all threads */
    publisher_thread.join ();
    login_thread.join ();
}