// USR2 signal: reopen log file
static void sigusr2_cb (G_GNUC_UNUSED evutil_socket_t sig, G_GNUC_UNUSED short events, G_GNUC_UNUSED void *user_data)
{
Application *app = _app;
// just flush, if log file name is not specified
if (!app->log_file_name || !app->f_log) {
fflush (app->f_log);
return;
}
LOG_msg (APP_LOG, "Reopening log file: %s !", app->log_file_name);
fflush (app->f_log);
fclose (app->f_log);
app->f_log = fopen (app->log_file_name, "a+");
if (!app->f_log) {
LOG_err (APP_LOG, "Failed to open log file: %s, output goes to stdout. Error: %s", app->log_file_name, strerror (errno));
// XXX: set output to stdout
logger_set_file (stdout);
return;
}
logger_set_file (app->f_log);
}
/**
* Knowing the user's home directory, TGDB can initialize the m_logger interface
*
* \param tgdb
* The tgdb context.
*
* \param config_dir
* The path to the user's config directory
*
* \return
* -1 on error, or 0 on success
*/
int Ctgdb::Initialize_logger_interface(char *config_dir)
{
/* Get the home directory */
const char *tgdb_log_file = "tgdb_log.txt";
char tgdb_log_path[FSUTIL_PATH_MAX];
fs_util_get_path (config_dir, tgdb_log_file, tgdb_log_path);
/* Initialize the logger */
if (num_loggers == 0)
{
m_logger = logger_create ();
if (!m_logger)
{
printf ("Error: Could not create log file\n");
return -1;
}
}
++num_loggers;
if (logger_set_file (m_logger, tgdb_log_path) == -1)
{
printf ("Error: Could not open log file\n");
return -1;
}
return 0;
}
/**
* @brief Initialize the NSSI RPC mechanism.
*
* This implementation of \b nssi_rpc_init initializes the
* Portals library and interface so that we can use Portals
* as the underlying communication protocol.
*
* @param pid @input The ID to use for this process.
*/
int nssi_rpc_init(
const nssi_rpc_transport rpc_transport,
const nssi_rpc_encode rpc_encode,
const char *url)
{
int rc;
NNTI_transport_id_t transport_id;
log_debug(rpc_debug_level, "************************************************************ entered");
if (rpc_initialized) return NSSI_OK;
/* check to see if logging is enabled */
if (logger_not_initialized()) {
logger_set_file(stderr);
}
/* make sure the timer works properly */
// rc = nssi_timer_test();
// if (rc != NSSI_OK) {
// log_fatal(rpc_debug_level, "nssi_timer_test() failed");
// return rc;
// }
/* stash the transport and encoding types so we know how to cleanup on exit */
// transport = rpc_transport;
encoding = rpc_encode;
/* initialize the transport mechanism */
switch (rpc_transport) {
case NSSI_RPC_PTL:
transport_id=NNTI_TRANSPORT_PORTALS;
break;
case NSSI_RPC_IB:
transport_id=NNTI_TRANSPORT_IB;
break;
case NSSI_RPC_LUC:
transport_id=NNTI_TRANSPORT_LUC;
break;
case NSSI_RPC_GEMINI:
transport_id=NNTI_TRANSPORT_GEMINI;
break;
case NSSI_RPC_MPI:
transport_id=NNTI_TRANSPORT_MPI;
break;
default:
rc = NSSI_ENOENT;
log_error(rpc_debug_level, "the transport scheme %d does not exist", rpc_transport);
return rc;
}
rc = NNTI_init(
transport_id,
url,
&transports[rpc_transport]);
if (rc != NNTI_OK) {
log_fatal(rpc_debug_level,"failed");
return rc;
}
/* initialize the xdr-encoding mechanism */
switch (rpc_encode) {
case NSSI_RPC_XDR:
rc = nssi_xdr_init();
if (rc != NSSI_OK) {
log_fatal(rpc_debug_level,"failed, %d", rc);
return rc;
}
break;
default:
rc = NSSI_ENOENT;
log_error(rpc_debug_level, "the transport scheme "
"does not exist");
return rc;
}
config_init(&nssi_config);
config_get_from_env(&nssi_config);
if (nssi_config.use_buffer_queue) {
trios_buffer_queue_init(
&send_bq,
nssi_config.buffer_queue_initial_size,
nssi_config.buffer_queue_max_size,
nssi_config.buffer_queue_create_if_empty,
&transports[rpc_transport],
NNTI_SEND_SRC,
NSSI_SHORT_REQUEST_SIZE);
trios_buffer_queue_init(
&recv_bq,
nssi_config.buffer_queue_initial_size,
nssi_config.buffer_queue_max_size,
nssi_config.buffer_queue_create_if_empty,
&transports[rpc_transport],
NNTI_RECV_DST,
NSSI_SHORT_RESULT_SIZE);
trios_buffer_queue_init(
&rdma_target_bq,
nssi_config.rdma_buffer_queue_initial_size,
nssi_config.rdma_buffer_queue_max_size,
nssi_config.rdma_buffer_queue_create_if_empty,
&transports[rpc_transport],
(NNTI_buf_ops_t)(NNTI_GET_SRC|NNTI_PUT_DST),
nssi_config.rdma_buffer_queue_buffer_size);
trios_buffer_queue_init(
&rdma_get_bq,
nssi_config.rdma_buffer_queue_initial_size,
nssi_config.rdma_buffer_queue_max_size,
nssi_config.rdma_buffer_queue_create_if_empty,
&transports[rpc_transport],
NNTI_GET_DST,
nssi_config.rdma_buffer_queue_buffer_size);
trios_buffer_queue_init(
&rdma_put_bq,
nssi_config.rdma_buffer_queue_initial_size,
nssi_config.rdma_buffer_queue_max_size,
nssi_config.rdma_buffer_queue_create_if_empty,
&transports[rpc_transport],
NNTI_PUT_SRC,
nssi_config.rdma_buffer_queue_buffer_size);
}
rpc_initialized = true;
if (logging_debug(rpc_debug_level)) {
fprint_NNTI_peer(logger_get_file(), "transports[rpc_transport].me",
"end of nssi_rpc_init", &transports[rpc_transport].me);
}
log_debug(rpc_debug_level, "************************************************************ exit");
return NSSI_OK;
}
/*{{{ main */
int main (int argc, char *argv[])
{
Application *app;
gboolean verbose = FALSE;
gboolean version = FALSE;
GError *error = NULL;
GOptionContext *context;
gchar **s_params = NULL;
gchar **s_config = NULL;
gboolean foreground = FALSE;
gchar conf_str[1023];
struct stat st;
gchar **cache_dir = NULL;
gchar **s_fuse_opts = NULL;
gchar **s_log_file = NULL;
guint32 part_size = 0;
gboolean disable_syslog = FALSE;
gboolean disable_stats = FALSE;
gboolean force_head_requests = FALSE;
gint uid = -1;
gint gid = -1;
gint fmode = -1;
gint dmode = -1;
struct event_config *ev_config;
srand (time (NULL));
app = g_new0 (Application, 1);
app->conf_path = g_build_filename (SYSCONFDIR, "riofs.conf.xml", NULL);
g_snprintf (conf_str, sizeof (conf_str), "Path to configuration file. Default: %s", app->conf_path);
GOptionEntry entries[] = {
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &s_params, NULL, NULL },
{ "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &s_config, conf_str, NULL},
{ "uid", 0, 0, G_OPTION_ARG_INT, &uid, "Set UID of filesystem owner.", NULL },
{ "gid", 0, 0, G_OPTION_ARG_INT, &gid, "Set GID of filesystem owner.", NULL },
{ "fmode", 0, 0, G_OPTION_ARG_INT, &fmode, "Set mode for all files.", NULL },
{ "dmode", 0, 0, G_OPTION_ARG_INT, &dmode, "Set mode for all directories.", NULL },
{ "foreground", 'f', 0, G_OPTION_ARG_NONE, &foreground, "Flag. Do not daemonize process.", NULL },
{ "cache-dir", 0, 0, G_OPTION_ARG_STRING_ARRAY, &cache_dir, "Set cache directory.", NULL },
{ "fuse-options", 'o', 0, G_OPTION_ARG_STRING_ARRAY, &s_fuse_opts, "Fuse options.", "\"opt[,opt...]\"" },
{ "disable-syslog", 0, 0, G_OPTION_ARG_NONE, &disable_syslog, "Flag. Disable logging to syslog.", NULL },
{ "disable-stats", 0, 0, G_OPTION_ARG_NONE, &disable_stats, "Flag. Disable Statistics HTTP interface.", NULL },
{ "part-size", 0, 0, G_OPTION_ARG_INT, &part_size, "Set file part size (in bytes).", NULL },
{ "log-file", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &s_log_file, "File to write output.", NULL },
{ "force-head-requests", 0, 0, G_OPTION_ARG_NONE, &force_head_requests, "Flag. Send HEAD request for each file.", NULL },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Verbose output.", NULL },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &version, "Show application version and exit.", NULL },
{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
// init libraries
CRYPTO_set_mem_functions (g_malloc0, g_realloc, g_free);
ENGINE_load_builtin_engines ();
ENGINE_register_all_complete ();
ERR_load_crypto_strings ();
OpenSSL_add_all_algorithms ();
#ifdef SSL_ENABLED
SSL_load_error_strings ();
SSL_library_init ();
#endif
g_random_set_seed (time (NULL));
// init main app structure
ev_config = event_config_new ();
#if defined(__APPLE__)
// method select is the preferred method on OS X. kqueue and poll are not supported.
event_config_avoid_method (ev_config, "kqueue");
event_config_avoid_method (ev_config, "poll");
#endif
app->evbase = event_base_new_with_config (ev_config);
event_config_free (ev_config);
if (!app->evbase) {
LOG_err (APP_LOG, "Failed to create event base !");
application_destroy (app);
return -1;
}
app->dns_base = evdns_base_new (app->evbase, 1);
if (!app->dns_base) {
LOG_err (APP_LOG, "Failed to create DNS base !");
application_destroy (app);
return -1;
}
app->f_log = NULL;
app->log_file_name = NULL;
/*{{{ cmd line args */
// parse command line options
context = g_option_context_new ("[bucketname] [mountpoint]");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context, "Please set both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables!");
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_fprintf (stderr, "Failed to parse command line options: %s\n", error->message);
application_destroy (app);
g_option_context_free (context);
return -1;
}
g_option_context_free (context);
// check if --version is specified
if (version) {
g_fprintf (stdout, "RioFS File System v%s\n", VERSION);
g_fprintf (stdout, "Copyright (C) 2012-2014 Paul Ionkin <*****@*****.**>\n");
g_fprintf (stdout, "Copyright (C) 2012-2014 Skoobe GmbH. All rights reserved.\n");
g_fprintf (stdout, "Libraries:\n");
g_fprintf (stdout, " GLib: %d.%d.%d libevent: %s fuse: %d.%d",
GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION,
LIBEVENT_VERSION,
FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION
);
#if defined(__APPLE__) || defined(__FreeBSD__) || !defined(__GLIBC__)
g_fprintf (stdout, "\n");
#else
g_fprintf (stdout, " glibc: %s\n", gnu_get_libc_version ());
#endif
g_fprintf (stdout, "Features:\n");
g_fprintf (stdout, " libevent backend method: %s\n", event_base_get_method(app->evbase));
#ifdef SSL_ENABLED
g_fprintf (stdout, " SSL enabled\n");
#endif
/*
{
int i;
const char **methods = event_get_supported_methods ();
g_fprintf (stdout, " Available libevent backend methods:\n");
for (i = 0; methods[i] != NULL; ++i) {
g_fprintf (stdout, " %s\n", methods[i]);
}
}
*/
return 0;
}
if (!s_params || g_strv_length (s_params) != 2) {
LOG_err (APP_LOG, "Wrong number of provided arguments!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
if (verbose)
log_level = LOG_debug;
else
log_level = LOG_msg;
/*}}}*/
/*{{{ parse config file */
// user provided alternative config path
if (s_config && g_strv_length (s_config) > 0) {
g_free (app->conf_path);
app->conf_path = g_strdup (s_config[0]);
g_strfreev (s_config);
}
app->conf = conf_create ();
if (access (app->conf_path, R_OK) == 0) {
LOG_debug (APP_LOG, "Using config file: %s", app->conf_path);
if (!conf_parse_file (app->conf, app->conf_path)) {
LOG_err (APP_LOG, "Failed to parse configuration file: %s", app->conf_path);
application_destroy (app);
return -1;
}
} else {
LOG_err (APP_LOG, "Configuration file is not found !");
application_destroy (app);
return -1;
}
if (!conf_check_keys (app->conf, conf_keys_str, conf_keys_len)) {
LOG_err (APP_LOG, "Configuration file is missing keys, please re-check your configuration file: %s", app->conf_path);
application_destroy (app);
return -1;
}
if (disable_syslog) {
conf_set_boolean (app->conf, "log.use_syslog", FALSE);
}
// update logging settings
logger_set_syslog (conf_get_boolean (app->conf, "log.use_syslog"));
logger_set_color (conf_get_boolean (app->conf, "log.use_color"));
if (cache_dir && g_strv_length (cache_dir) > 0) {
conf_set_string (app->conf, "filesystem.cache_dir", cache_dir[0]);
g_strfreev (cache_dir);
}
if (!verbose)
log_level = conf_get_int (app->conf, "log.level");
if (uid >= 0)
conf_set_int (app->conf, "filesystem.uid", uid);
if (gid >= 0)
conf_set_int (app->conf, "filesystem.gid", gid);
if (fmode >= 0)
conf_set_int (app->conf, "filesystem.file_mode", fmode);
if (dmode >= 0)
conf_set_int (app->conf, "filesystem.dir_mode", dmode);
/*}}}*/
// try to get access parameters from the environment
if (getenv ("AWS_ACCESS_KEY_ID")) {
conf_set_string (app->conf, "s3.access_key_id", getenv ("AWS_ACCESS_KEY_ID"));
// else check if it's set it the config file
} else {
if (!conf_node_exists (app->conf, "s3.access_key_id")) {
LOG_err (APP_LOG, "Environment variables are not set!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
}
if (getenv ("AWS_SECRET_ACCESS_KEY")) {
conf_set_string (app->conf, "s3.secret_access_key", getenv ("AWS_SECRET_ACCESS_KEY"));
} else {
if (!conf_node_exists (app->conf, "s3.secret_access_key")) {
LOG_err (APP_LOG, "Environment variables are not set!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
}
// check if both strings are set
if (!conf_get_string (app->conf, "s3.access_key_id") || !conf_get_string (app->conf, "s3.secret_access_key")) {
LOG_err (APP_LOG, "Environment variables are not set!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
// foreground is set
if (foreground)
conf_set_boolean (app->conf, "app.foreground", foreground);
if (part_size)
conf_set_uint (app->conf, "s3.part_size", part_size);
if (disable_stats)
conf_set_boolean (app->conf, "statistics.enabled", FALSE);
if (force_head_requests)
conf_set_boolean (app->conf, "s3.force_head_requests_on_lookup", TRUE);
else
conf_set_boolean (app->conf, "s3.force_head_requests_on_lookup", FALSE);
conf_set_string (app->conf, "s3.bucket_name", s_params[0]);
if (!application_set_url (app, conf_get_string (app->conf, "s3.endpoint"))) {
application_destroy (app);
return -1;
}
if (s_fuse_opts && g_strv_length (s_fuse_opts) > 0) {
app->fuse_opts = g_strdup (s_fuse_opts[0]);
g_strfreev (s_fuse_opts);
}
if (s_log_file && g_strv_length (s_log_file) > 0) {
app->log_file_name = g_strdup (s_log_file[0]);
app->f_log = fopen (s_log_file[0], "a+");
if (!app->f_log) {
LOG_err (APP_LOG, "Failed to open log file: %s Error: %s", s_log_file[0], strerror (errno));
application_destroy (app);
return -1;
}
LOG_debug (APP_LOG, "Using %s for storing application logs.", s_log_file[0]);
logger_set_file (app->f_log);
g_strfreev (s_log_file);
}
conf_set_string (app->conf, "app.mountpoint", s_params[1]);
// check if directory exists
if (stat (conf_get_string (app->conf, "app.mountpoint"), &st) == -1) {
LOG_err (APP_LOG, "Mountpoint %s does not exist! Please check directory permissions!",
conf_get_string (app->conf, "app.mountpoint"));
application_destroy (app);
return -1;
}
// check if it's a directory
if (!S_ISDIR (st.st_mode)) {
LOG_err (APP_LOG, "Mountpoint %s is not a directory!", conf_get_string (app->conf, "app.mountpoint"));
application_destroy (app);
return -1;
}
g_strfreev (s_params);
#ifdef SSL_ENABLED
app->ssl_ctx = SSL_CTX_new (SSLv23_client_method ());
if (!app->ssl_ctx) {
LOG_err (APP_LOG, "Failed to initialize SSL engine !");
application_exit (app);
return -1;
}
SSL_CTX_set_options (app->ssl_ctx, SSL_OP_ALL);
#endif
#ifdef MAGIC_ENABLED
app->magic_ctx = magic_open(MAGIC_MIME_TYPE);
if (!app->magic_ctx) {
LOG_err(APP_LOG, "Failed to initialize magic library\n");
return -1;
}
if (magic_load(app->magic_ctx, NULL)) {
LOG_err(APP_LOG, "Failed to load magic database: %s\n", magic_error(app->magic_ctx));
magic_close(app->magic_ctx);
return -1;
}
#endif
app->stat_srv = stat_srv_create (app);
if (!app->stat_srv) {
application_exit (app);
return -1;
}
// perform the initial request to get bucket ACL (handles redirect as well)
app->service_con = http_connection_create (app);
if (!app->service_con) {
application_destroy (app);
return -1;
}
bucket_client_get (app->service_con, "/?acl", application_on_bucket_acl_cb, app);
// start the loop
event_base_dispatch (app->evbase);
application_destroy (app);
return 0;
}
