more work on mysqlmanager (122329f7) · Commits · Software / OSDI20 Artifacts / mariadb

tools/mysqlmanager.c

+285 −31

Original line number	Diff line number	Diff line
		@@ -40,28 +40,28 @@
		#include <violite.h>
		#include <my_pthread.h>

		#define MNGD_VERSION "1.0"
		#define MNGD_GREETING "MySQL Server Management Daemon v.1.0"
		#define MANAGER_VERSION "1.0"
		#define MANAGER_GREETING "MySQL Server Management Daemon v.1.0"

		#define LOG_ERR 1
		#define LOG_WARN 2
		#define LOG_INFO 3
		#define LOG_DEBUG 4

		#ifndef MNGD_PORT
		#define MNGD_PORT 23546
		#ifndef MANAGER_PORT
		#define MANAGER_PORT 23546
		#endif

		#ifndef MNGD_MAX_CMD_LEN
		#define MNGD_MAX_CMD_LEN 16384
		#ifndef MANAGER_MAX_CMD_LEN
		#define MANAGER_MAX_CMD_LEN 16384
		#endif

		#ifndef MNGD_LOG_FILE
		#define MNGD_LOG_FILE "/var/log/mysqlmanager.log"
		#ifndef MANAGER_LOG_FILE
		#define MANAGER_LOG_FILE "/var/log/mysqlmanager.log"
		#endif

		#ifndef MNGD_BACK_LOG
		#define MNGD_BACK_LOG 50
		#ifndef MANAGER_BACK_LOG
		#define MANAGER_BACK_LOG 50
		#endif

		#ifndef MAX_USER_NAME
		@@ -73,17 +73,18 @@
		set by the user
		*/

		uint manager_port = MNGD_PORT;
		uint manager_port = MANAGER_PORT;
		FILE* errfp;
		const char* manager_log_file = MNGD_LOG_FILE;
		pthread_mutex_t lock_log, lock_shutdown;
		const char* manager_log_file = MANAGER_LOG_FILE;
		pthread_mutex_t lock_log,lock_shutdown,lock_exec_hash;
		int manager_sock = -1;
		struct sockaddr_in manager_addr;
		ulong manager_bind_addr = INADDR_ANY;
		int manager_back_log = MNGD_BACK_LOG;
		int manager_back_log = MANAGER_BACK_LOG;
		int in_shutdown = 0, shutdown_requested=0;
		const char* manager_greeting = MNGD_GREETING;
		uint manager_max_cmd_len = MNGD_MAX_CMD_LEN;
		const char* manager_greeting = MANAGER_GREETING;
		uint manager_max_cmd_len = MANAGER_MAX_CMD_LEN;
		int one_thread = 0; /* for debugging */

		/* messages */

		@@ -98,7 +99,6 @@ uint manager_max_cmd_len = MNGD_MAX_CMD_LEN;
		#define MSG_CLIENT_ERR 450
		#define MSG_INTERNAL_ERR 500


		/* access flags */

		#define PRIV_SHUTDOWN 1
		@@ -112,9 +112,18 @@ struct manager_thd
		int fatal,finished;
		};

		struct manager_thd* manager_thd_new(Vio* vio);
		void manager_thd_free(struct manager_thd* thd);

		HASH exec_hash;

		static struct manager_thd* manager_thd_new(Vio* vio);
		static struct manager_exec* manager_exec_new(char* arg_start,char* arg_end);
		static void manager_exec_print(Vio* vio,struct manager_exec* e);
		static void manager_thd_free(struct manager_thd* thd);
		static void manager_exec_free(void* e);
		static char* arg_strmov(char* dest, const char* src, int n);
		static byte* get_exec_key(const byte* e, uint* len,
		my_bool __attribute__((unused)) t);
		static uint tokenize_args(char* arg_start,char** arg_end);
		static void init_arg_array(char* arg_str,char** args,uint arg_count);
		typedef int (manager_cmd_handler)(struct manager_thd,char,char);


		@@ -126,6 +135,20 @@ struct manager_cmd
		int len;
		};

		struct manager_exec
		{
		char* ident;
		int ident_len;
		const char* error;
		char* bin_path;
		char** args;
		char con_user[16];
		char con_pass[16];
		int con_port;
		char con_sock[FN_REFLEN];
		char* data_buf;
		};

		#define HANDLE_DECL(com) static int handle_ ## com (struct manager_thd* thd,\
		char* args_start,char* args_end)

		@@ -138,12 +161,16 @@ HANDLE_NOARG_DECL(ping);
		HANDLE_NOARG_DECL(quit);
		HANDLE_NOARG_DECL(help);
		HANDLE_NOARG_DECL(shutdown);
		HANDLE_DECL(def_exec);
		HANDLE_NOARG_DECL(show_exec);

		struct manager_cmd commands[] =
		{
		{"ping", "Check if this server is alive", handle_ping,4},
		{"quit", "Finish session", handle_quit,4},
		{"shutdown", "Shutdown this server", handle_shutdown,8},
		{"def_exec", "Define executable entry", handle_def_exec,8},
		{"show_exec","Show defined executable entries",handle_show_exec,9},
		{"help", "Print this message", handle_help,4},
		{0,0,0,0}
		};
		@@ -158,6 +185,7 @@ struct option long_options[] =
		{"tcp-backlog", required_argument, 0, 'B'},
		{"greeting", required_argument, 0, 'g'},
		{"max-command-len",required_argument,0,'m'},
		{"one-thread",no_argument,0,'d'},
		{"version", no_argument, 0, 'V'},
		{0, 0, 0, 0}
		};
		@@ -190,6 +218,7 @@ static int exec_line(struct manager_thd* thd,char* buf,char* buf_end)
		commands");
		return 1;
		}
		for (;p<buf_end && isspace(*p);p++);
		return cmd->handler_func(thd,p,buf_end);
		}

		@@ -238,6 +267,78 @@ HANDLE_NOARG_DECL(shutdown)
		return 0;
		}

		HANDLE_DECL(def_exec)
		{
		struct manager_exec* e=0;
		const char* error=0;
		if (!(e=manager_exec_new(args_start,args_end)))
		{
		error="Out of memory";
		goto err;
		}
		if (e->error)
		{
		error=e->error;
		goto err;
		}
		pthread_mutex_lock(&lock_exec_hash);
		hash_insert(&exec_hash,(byte*)e);
		pthread_mutex_unlock(&lock_exec_hash);
		client_msg(thd->vio,MSG_OK,"Exec definition created");
		return 0;
		err:
		client_msg(thd->vio,MSG_CLIENT_ERR,error);
		if (e)
		manager_exec_free(e);
		return 1;
		}

		HANDLE_NOARG_DECL(show_exec)
		{
		uint i;
		client_msg_pre(thd->vio,MSG_INFO,"Exec_def\tArguments");
		pthread_mutex_lock(&lock_exec_hash);
		for (i=0;i<exec_hash.records;i++)
		{
		struct manager_exec* e=(struct manager_exec*)hash_element(&exec_hash,i);
		manager_exec_print(thd->vio,e);
		}
		pthread_mutex_unlock(&lock_exec_hash);
		client_msg(thd->vio,MSG_INFO,"End");
		return 0;
		}

		static char* arg_strmov(char* dest, const char* src, int n)
		{
		char* dest_end = dest+n-1;
		char c;
		for (;dest<dest_end && (c=*src++);)
		{
		if (c=='%')
		*dest++='%';
		*dest++=c;
		}
		return dest;
		}

		static void manager_exec_print(Vio* vio,struct manager_exec* e)
		{
		char buf[MAX_CLIENT_MSG_LEN];
		char* p=buf,*buf_end=buf+sizeof(buf);
		char** args=e->args;

		p=arg_strmov(p,e->ident,(int)(buf_end-p)-2);
		*p++='\t';
		for(;p<buf_end && *args;args++)
		{
		p=arg_strmov(p,*args,(int)(buf_end-p)-2);
		*p++='\t';
		}
		*p=0;
		client_msg_pre(vio,MSG_INFO,buf);
		return;
		}

		static int authenticate(struct manager_thd* thd)
		{
		char* buf_end;
		@@ -323,6 +424,8 @@ LOG_MSG_FUNC(info,INFO)

		#ifndef DBUG_OFF
		LOG_MSG_FUNC(debug,DEBUG)
		#else
		inline void log_debug(char* __attribute__((unused)) fmt,...) {}
		#endif

		static pthread_handler_decl(process_connection,arg)
		@@ -439,7 +542,7 @@ struct manager_thd* manager_thd_new(Vio* vio)
		return tmp;
		}

		void manager_thd_free(struct manager_thd* thd)
		static void manager_thd_free(struct manager_thd* thd)
		{
		if (thd->vio)
		vio_close(thd->vio);
		@@ -466,11 +569,11 @@ static void clean_up()

		static void print_version(void)
		{
		printf("%s Ver %s Distrib %s, for %s (%s)\n",my_progname,MNGD_VERSION,
		printf("%s Ver %s Distrib %s, for %s (%s)\n",my_progname,MANAGER_VERSION,
		MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
		}

		void usage()
		static void usage()
		{
		print_version();
		printf("MySQL AB, by Sasha\n");
		@@ -493,10 +596,10 @@ void usage()
		-V, --version Output version information and exit.\n\n");
		}

		int parse_args(int argc, char **argv)
		static int parse_args(int argc, char **argv)
		{
		int c, option_index = 0;
		while ((c=getopt_long(argc,argv,"P:?#:Vl:b:B:g:m:",
		while ((c=getopt_long(argc,argv,"P:?#:Vl:b:B:g:m:d",
		long_options,&option_index)) != EOF)
		{
		switch (c)
		@@ -504,6 +607,9 @@ int parse_args(int argc, char **argv)
		case '#':
		DBUG_PUSH(optarg ? optarg : "d:t:O,/tmp/mysqlmgrd.trace");
		break;
		case 'd':
		one_thread=1;
		break;
		case 'P':
		manager_port=atoi(optarg);
		break;
		@@ -535,7 +641,7 @@ int parse_args(int argc, char **argv)
		return 0;
		}

		int init_server()
		static int init_server()
		{
		int arg=1;
		log_info("Started");
		@@ -554,7 +660,7 @@ int init_server()
		return 0;
		}

		int run_server_loop()
		static int run_server_loop()
		{
		pthread_t th;
		struct manager_thd *thd;
		@@ -598,7 +704,13 @@ int run_server_loop()
		}
		if (shutdown_requested)
		break;
		if (pthread_create(&th,0,process_connection,(void*)thd))
		if (one_thread)
		{
		process_connection((void*)thd);
		manager_thd_free(thd);
		continue;
		}
		else if (pthread_create(&th,0,process_connection,(void*)thd))
		{
		client_msg(vio,MSG_INTERNAL_ERR,"Could not create thread, errno=%d",
		errno);
		@@ -609,7 +721,7 @@ int run_server_loop()
		return 0;
		}

		FILE* open_log_stream()
		static FILE* open_log_stream()
		{
		FILE* fp;
		if (!(fp=fopen(manager_log_file,"a")))
		@@ -617,7 +729,131 @@ FILE* open_log_stream()
		return fp;
		}

		int daemonize()
		static byte* get_exec_key(const byte* e, uint* len,
		my_bool __attribute__((unused)) t)
		{
		register const char* key;
		key = ((struct manager_exec*)e)->ident;
		len = ((struct manager_exec)e)->ident_len;
		return (byte*)key;
		}

		static void init_arg_array(char* arg_str,char** args,uint arg_count)
		{
		char* p = arg_str;
		for (;arg_count>0;arg_count--)
		{
		*args++=p;
		p += strlen(p)+1;
		}
		*args=0;
		}

		static uint tokenize_args(char* arg_start,char** arg_end)
		{
		char* p, p_write,p_end;
		uint arg_count=0;
		int quoted=0,escaped=0,last_space=0;
		p_end=*arg_end;
		p_write=p=arg_start;
		for(;p<p_end;p++)
		{
		char c = *p;
		switch (c)
		{
		case ' ':
		case '\r':
		case '\n':
		if (!quoted)
		{
		if (!last_space)
		{
		*p_write++=0;
		arg_count++;
		last_space=1;
		}
		}
		else
		*p_write++=c;
		escaped=0;
		break;
		case '"':
		if (!escaped)
		quoted=!quoted;
		else
		*p_write++=c;
		last_space=0;
		escaped=0;
		break;
		case '\\':
		if (!escaped)
		escaped=1;
		else
		{
		*p_write++=c;
		escaped=0;
		}
		last_space=0;
		break;
		default:
		escaped=last_space=0;
		*p_write++=c;
		break;
		}
		}
		if (!last_space && p_write>arg_start)
		arg_count++;
		*p_write=0;
		*arg_end=p_write;
		log_debug("arg_count=%d,arg_start='%s'",arg_count,arg_start);
		return arg_count;
		}


		static struct manager_exec* manager_exec_new(char* arg_start,char* arg_end)
		{
		struct manager_exec* tmp;
		char* first_arg;
		uint arg_len,num_args;
		num_args=tokenize_args(arg_start,&arg_end);
		arg_len=(uint)(arg_end-arg_start)+1; /* include \0 terminator*/
		if (!(tmp=(struct manager_exec)my_malloc(sizeof(tmp)+arg_len+
		sizeof(char)num_args,MYF(0))))
		return 0;
		if (num_args<2)
		{
		tmp->error="Too few arguments";
		return tmp;
		}
		tmp->data_buf=(char)tmp+sizeof(tmp);
		memcpy(tmp->data_buf,arg_start,arg_len);
		tmp->args=(char**)(tmp->data_buf+arg_len);
		tmp->ident=tmp->data_buf;
		tmp->ident_len=strlen(tmp->ident);
		first_arg=tmp->ident+tmp->ident_len+1;
		init_arg_array(first_arg,tmp->args,num_args-1);
		strmov(tmp->con_user,"root");
		tmp->con_pass[0]=0;
		tmp->con_sock[0]=0;
		tmp->con_port=MYSQL_PORT;
		tmp->bin_path=tmp->args[0];
		tmp->error=0;
		return tmp;
		}


		static void manager_exec_free(void* e)
		{
		my_free(e,MYF(0));
		}

		static void init_globals()
		{
		if (hash_init(&exec_hash,1024,0,0,get_exec_key,manager_exec_free,MYF(0)))
		die("Exec hash initialization failed");
		}

		static int daemonize()
		{
		switch (fork())
		{
		@@ -625,8 +861,10 @@ int daemonize()
		die("Cannot fork");
		case 0:
		errfp = open_log_stream();
		init_globals();
		close(0);
		close(1);
		close(2);
		init_server();
		run_server_loop();
		clean_up();
		@@ -644,8 +882,24 @@ int main(int argc, char** argv)
		parse_args(argc,argv);
		pthread_mutex_init(&lock_log,0);
		pthread_mutex_init(&lock_shutdown,0);
		pthread_mutex_init(&lock_exec_hash,0);
		if (one_thread)
		{
		init_globals();
		init_server();
		run_server_loop();
		clean_up();
		return 0;
		}
		else
		return daemonize();
		}