path: root/src/biruda.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
#define WIN32_MEAN_AND_LEAN
#include <windows.h>
#else
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#endif

// command line parser
#include "biruda_cmdline.h"

// configuration parser

#include "confuse.h"

// daemonizing
#ifndef _WIN32
#include "libdaemon/daemon.h"
#endif

#include "master.h"
#include "worker.h"
#include "coordinator.h"

// for integrated webserver
#ifndef _WIN32
#include "webserver.h"
#endif

// for cli/interactive biruda client
#ifndef _WIN32
#include <strings.h>
#include <ctype.h>
#include <stdarg.h>
#include "linenoise.h"
#include "http_lib.h"
#endif

#include "port.h"

static const char *DEFAULT_CONFIG_FILE = "/etc/biruda/biruda.conf";
static const unsigned int DEFAULT_WEBSERVER_PORT = 8080;
static const char *DEFAULT_WEBSERVER_HOST = "localhost";
static const unsigned int DEFAULT_WEBSERVER_THREADS = 4;

static int parse_options_and_arguments( int argc, char *argv[], struct gengetopt_args_info *args_info )
{
	struct cmdline_parser_params params;

	cmdline_parser_params_init( &params );

        cmdline_parser_init( args_info );

        if( cmdline_parser_ext( argc, argv, args_info, &params ) != 0 ) {
        	cmdline_parser_free( args_info );
        	return 1;
        }

        return 0;
}

static int test_config( const struct gengetopt_args_info *args_info )
{
	return 0;
}

static int read_config( const char *filename, cfg_t **cfg )
{
	cfg_opt_t opts_master[] = {
		CFG_STR( "control", 0, CFGF_NODEFAULT ),
		CFG_END( )
	};

	cfg_opt_t opts_coordinator[] = {
		CFG_STR( "control", 0, CFGF_NODEFAULT ),
		CFG_END( )
	};

	cfg_opt_t opts_worker[] = {
		CFG_STR( "control", 0, CFGF_NODEFAULT ),
		CFG_END( )
	};

#ifndef _WIN32	
	cfg_opt_t opts_webserver[] = {
		CFG_STR( "host", (char *)DEFAULT_WEBSERVER_HOST, CFGF_NONE ),
		CFG_INT( "port", DEFAULT_WEBSERVER_PORT, CFGF_NONE ),
		CFG_INT( "threads", DEFAULT_WEBSERVER_THREADS, CFGF_NONE ),
		CFG_END( )
	};
#endif
	
	cfg_opt_t opts[] = {
		CFG_SEC( "master", opts_master, CFGF_MULTI ),
		CFG_SEC( "coordinator", opts_coordinator, CFGF_MULTI ),
		CFG_SEC( "worker", opts_worker, CFGF_MULTI | CFGF_TITLE ),
#ifndef _WIN32
		CFG_SEC( "webserver", opts_webserver, CFGF_MULTI ),
#endif
		CFG_END( )
	};
	
	*cfg = cfg_init( opts, CFGF_NONE );
	
	switch( cfg_parse( *cfg, filename ) ) {
		case CFG_FILE_ERROR:
			fprintf( stderr, "ERROR: configuration file '%s' could not be read: %s\n",
				filename, strerror( errno ) );
			return 1;

		case CFG_PARSE_ERROR:
			return 1;
			
		case CFG_SUCCESS:
			break;
	}
			
	return 0;
}

static void print_config( struct gengetopt_args_info *args_info, cfg_t *cfg )
{
	cfg_t *master_cfg = cfg_getnsec( cfg, "master", 0 );
	unsigned int has_master = cfg_size( cfg, "master" );
	if( has_master ) {
		puts( "Master:" );
		printf( "  Control channel: %s\n", cfg_getstr( master_cfg, "control" ) );
		puts( "" );
	}
	
	cfg_t *coordinator_cfg = cfg_getnsec( cfg, "coordinator", 0 );
	unsigned int has_coordinator = cfg_size( cfg, "coordinator" );
	if( has_coordinator ) {
		puts( "Coordinator:" );
		printf( "  Control channel: %s\n", cfg_getstr( coordinator_cfg, "control" ) );
		puts( "" );
	}
	
	unsigned int nof_workers = cfg_size( cfg, "worker" );
	if( nof_workers > 0 ) {
		printf( "Workers:\n" );
		for( unsigned int i = 0; i < nof_workers; i++ ) {
			cfg_t *worker_cfg = cfg_getnsec( cfg, "worker", i );
			
			printf( "  Worker %s:\n", cfg_title( worker_cfg ) );
			printf( "    Control channel: %s\n", cfg_getstr( worker_cfg, "control" ) );
		}
		puts( "" );
	}

#ifndef _WIN32	
	cfg_t *webserver_cfg = cfg_getnsec( cfg, "webserver", 0 );
	unsigned int has_webserver = cfg_size( cfg, "webserver" );	
	if( has_webserver > 0 ) {
		printf( "Webserver:\n" );
		printf( "  Host: %s\n", cfg_getstr( webserver_cfg, "host" ) );
		printf( "  Port: %ld\n", cfg_getint( webserver_cfg, "port" ) );
		printf( "  Number of threads: %ld\n", cfg_getint( webserver_cfg, "threads" ) );
		puts( "" );
	}
#endif
}

static int create_master( cfg_t *cfg )
{
	cfg_t *master_cfg = cfg_getnsec( cfg, "master", 0 );
	char *control = cfg_getstr( master_cfg, "control" );
	
	return master_init( control );
}

static int create_coordinator( cfg_t *cfg )
{
	cfg_t *master_cfg = cfg_getnsec( cfg, "coordinator", 0 );
	char *control = cfg_getstr( master_cfg, "control" );
	
	return coordinator_init( control );
}

#ifndef _WIN32
static int create_webserver( cfg_t *cfg )
{
	cfg_t *webserver_cfg = cfg_getnsec( cfg, "webserver", 0 );
	unsigned int port = cfg_getint( webserver_cfg, "port" );
	
	return webserver_init( port );
}
#endif

static volatile int got_terminate = 0;

#ifdef _WIN32
BOOL WINAPI terminate_foreground_func( DWORD ctrlType )
{
	switch( ctrlType ) {
		case CTRL_C_EVENT:
		case CTRL_BREAK_EVENT:
		case CTRL_CLOSE_EVENT:
		case CTRL_LOGOFF_EVENT:
		case CTRL_SHUTDOWN_EVENT:
			got_terminate = 1;
			return TRUE;
		default:
			return FALSE;
	}
}
#else
static void terminate_foreground_func( int sig ) 
{
	got_terminate = 1;
}
#endif

#ifndef _WIN32

#define HISTORY_FILE ".biruda_history"

static char *commands[] = {
	"help", "quit", "status", NULL
};

static bool print_colors = false;

static bool is_interactive = false;

static void completion_func( const char *buf, linenoiseCompletions *lc )
{
	unsigned int i;
	size_t len = strlen( buf );

	for (i = 0; commands[i]; ++i) {
		char *cmd = commands[i];
		if( strlen( cmd ) < len ) continue;
		if( strncasecmp( buf, cmd, len ) == 0 ) {
			linenoiseAddCompletion( lc, cmd );
		}
	}
}

static void print_help( )
{
	puts( "\n"
		"   help - show this help page\n"
		"   quit - quit the client\n"
		"   status - status of the biruda network\n"
	);
}

static void print_colored( const char *fmt, int color, va_list ap )
{
	char buf[1024];
	
	(void)vsnprintf( buf, sizeof( buf ), fmt, ap );
	
	if( print_colors ) {
		printf( "%c[9%dm%s%c[0m\n", 27, color, buf, 27 );
	} else {
		puts( buf );
	}
}
	
static void print_error( const char *fmt, ... )
{
	va_list ap;
	va_start( ap, fmt );
	print_colored( fmt, 1, ap );
	va_end( ap );
}

static void print_answer( const char *fmt, ... )
{
	va_list ap;
	va_start( ap, fmt );
	print_colored( fmt, 2, ap );
	va_end( ap );
}

static void print_status( )
{
	http_server = "localhost";
	http_port = 8080;
	char *url = "status";
	char *data = NULL;
	int len;
	http_retcode ret = http_get( url, &data, &len, NULL );
	if( ret == 200 ) {
		if( strlen( data ) > 0 && data[strlen( data )-1] == '\n' ) {
			data[strlen( data )-1] = '\0';
		}
		if( strlen( data ) > 0 && data[strlen( data )-1] == '\r' ) {
			data[strlen( data )-1] = '\0';
		}
		print_answer( data );
	} else {
		print_error( "ERROR: HTTP error %d", ret );
	}
	free( data );
}

static int start_interactive( bool colors )
{
	char history_filename[1024];
	
	is_interactive = isatty( fileno( stdin ) );
	print_colors = is_interactive ? colors : false;

	if( is_interactive ) {
		char *home = getenv( "HOME" );
		if( home != NULL ) {
			snprintf( history_filename, sizeof( history_filename ), "%s/%s", home, HISTORY_FILE );
			linenoiseHistoryLoad( history_filename );
			linenoiseSetCompletionCallback( completion_func );
		}
	}
	
	char *context = "biruda";
	for( ;; ) {
		char buf[4096];
		char *line;

		if( is_interactive ) {
			snprintf( buf, sizeof( buf ), "%s> ", context );
			if( ( line = linenoise( buf ) ) == NULL ) {
				break;
			}
		} else {
			fgets( buf, sizeof( buf ), stdin );
			line = buf;
		}
		
		if( strlen( line ) > 1 ) {
			if( line[strlen( line )-1] == '\n' ) {
				line[strlen( line )-1] = '\0';
			}
		}
		
		if( is_interactive ) {
			linenoiseHistoryAdd( line );
		}
				
		if( strncasecmp( line, "quit", 4 ) == 0 ) {
			if( is_interactive ) {
				linenoiseHistorySave( history_filename );
			}
			return EXIT_SUCCESS;
		} else if( strncasecmp( line, "help", 4 ) == 0 ) {
			print_help( );
		} else if( strncasecmp( line, "status", 6 ) == 0 ) {
			print_status( );
		} else {
			print_error( "Bad command." );
		}
	}

	return EXIT_SUCCESS;
}
#endif

int main( int argc, char *argv[] )
{
	struct gengetopt_args_info args_info;
	cfg_t *cfg;

	if( parse_options_and_arguments( argc, argv, &args_info ) ) {
		exit( EXIT_FAILURE );
	}

	if( read_config( args_info.config_file_given ?
		args_info.config_file_arg : DEFAULT_CONFIG_FILE, &cfg ) ) {
		cfg_free( cfg );
		cmdline_parser_free( &args_info );
		return 1;
	}

	if( args_info.test_given ) {
		cfg_free( cfg );
		cmdline_parser_free( &args_info );
		return( ( test_config( &args_info ) == 0 ) ? EXIT_SUCCESS : EXIT_FAILURE );
	}

	if( args_info.print_given ) {
		print_config( &args_info, cfg );
		cfg_free( cfg );
		cmdline_parser_free( &args_info );
		return( ( test_config( &args_info ) == 0 ) ? EXIT_SUCCESS : EXIT_FAILURE );
	}

	if( args_info.cli_given ) {
		int ret = start_interactive( !args_info.no_colors_given );
		cfg_free( cfg );
		cmdline_parser_free( &args_info );
		return( ( ret == 0 ) ? EXIT_SUCCESS : EXIT_FAILURE );
	}

	unsigned int has_master = cfg_size( cfg, "master" );
	if( has_master ) {
		if( create_master( cfg ) != 0 ) {
			fprintf( stderr, "FATAL: Unable to create master thread!\n" );
			cfg_free( cfg );
			cmdline_parser_free( &args_info );
			exit( EXIT_FAILURE );
		}
	}

	unsigned int has_coordinator = cfg_size( cfg, "coordinator" );
	if( has_coordinator ) {
		if( create_coordinator( cfg ) != 0 ) {
			fprintf( stderr, "FATAL: Unable to create coordinator thread!\n" );
			cfg_free( cfg );
			cmdline_parser_free( &args_info );
			exit( EXIT_FAILURE );
		}
	}
	
#ifndef _WIN32
	unsigned int has_webserver = cfg_size( cfg, "webserver" );
	if( has_webserver ) {
		if( create_webserver( cfg ) != 0 ) {
			fprintf( stderr, "FATAL: Unable to create webserver thread!\n" );
			cfg_free( cfg );
			cmdline_parser_free( &args_info );
			exit( EXIT_FAILURE );
		}
	}
#endif

	if( args_info.foreground_given ) {
#ifdef _WIN32
		SetConsoleCtrlHandler( terminate_foreground_func, TRUE );
#else
		struct sigaction sa;

		memset( &sa, 0, sizeof( struct sigaction ) );
		sa.sa_handler = terminate_foreground_func;
		sa.sa_flags = SA_RESTART;
		
		(void)sigaction( SIGINT, &sa, NULL );
		(void)sigaction( SIGTERM, &sa, NULL );
#endif
		
		while( !got_terminate ) {
			sleep( 1 );
		}
	}
	
#ifndef _WIN32
	if( has_webserver ) {
		webserver_terminate( );
	}
#endif
	if( has_coordinator ) {
		coordinator_terminate( );
	}
	if( has_master ) {
		master_terminate( !has_coordinator );
	}
	
	if( has_coordinator ) {
		coordinator_free( );
	}
	if( has_master ) {
		master_free( );
	}
#ifndef _WIN32
	if( has_webserver ) {
		webserver_free( );
	}
#endif
	
	cfg_free( cfg );
	cmdline_parser_free( &args_info );

	exit( EXIT_SUCCESS );
}