提供maat_redis_tool，支持导出redis中的配置。

Makefile

@@ -6,9 +6,11 @@
 all:
 	cd src/entry/ && $(MAKE)
 	cd test && $(MAKE)
+	cd tools && $(MAKE)
 clean:
 	cd src/entry/ && $(MAKE) clean
 	cd test && $(MAKE) clean
+	cd tools && $(MAKE) clean
 			 
 opt:
 	$(MAKE) all

src/entry/Maat_rule_internal.h

@@ -428,6 +428,15 @@ struct _maat_garbage_t
 		MESA_htable_handle str2int_map;
 	};
 };
+struct serial_rule_t		//rm= Redis Maat
+{
+	enum MAAT_OPERATION op;//0: delete, 1: add.
+	int rule_id;
+	int label_id;
+	long long timeout;			// absolute unix time.
+	char table_name[256];
+	char* table_line;
+};
 void garbage_bagging(enum maat_garbage_type type,void *p,MESA_lqueue_head garbage_q);
 void garbage_bury(MESA_lqueue_head garbage_q,void *logger);
 void make_group_set(const struct _Maat_compile_inner_t* compile_rule,universal_bool_expr_t* a_set);
@@ -456,6 +465,9 @@ void maat_stat_output(struct _Maat_feather_t* feather);
 char* _maat_strdup(const char* s);
 char* str_unescape(char* s);
 redisReply *_wrap_redisCommand(redisContext *c, const char *format, ...);
+int get_rm_key_list(unsigned int version,redisContext *c,struct serial_rule_t** list,void* logger, unsigned int* new_version,int *update_type);
+int get_maat_redis_value(redisContext *c,struct serial_rule_t* rule_list,int rule_num,void* logger,int print_process);
+void empty_serial_rules(struct serial_rule_t* rule);
 void redis_monitor_traverse(unsigned int version,redisContext *c,
 							void (*start)(unsigned int ,int ,void*),//vesion,CM_UPDATE_TYPE_*,u_para
 							int (*update)(const char* ,const char*,void* ),//table name ,line ,u_para

src/entry/json2iris.h

@@ -1,2 +1,6 @@
-
+#ifndef H_MAAT_JSON2IRIS_H_INCLUDE
+#define H_MAAT_JSON2IRIS_H_INCLUDE
 int json2iris(const char* json_file,const char*compile_tn,const char* group_tn,char* iris_dir_buf,int buf_len,void* logger);
+int set_file_rulenum(const char* path,int rulenum,void* logger);
+#endif
+

test/Makefile

@@ -1,7 +1,8 @@
-LIBS=../lib/libmaatframe.so
+LIBS= ../lib/libmaatframe.so -lhiredis_vip
-INC=-I../inc/ -I/usr/include/MESA/
+INC=-I../inc/ -I ../src/entry/ -I../src/inc_internal/ -I/usr/include/MESA/
 all:
-	g++ -o maat_test -g -Wall maat_test.cpp $(INC) $(LIBS) -lMESA_handle_logger
+	g++ -o maat_redis_tool.o -c -g -Wall maat_redis_tool.cpp $(INC)
+	g++ -o maat_redis_tool maat_redis_tool.o $(LIBS)
 	g++ -o digest_gen -g digest_gen.c $(INC) $(LIBS)
 clean:
-	rm maat_test test.log* -f
+	rm *.o

tools/Makefile

@@ -0,0 +1,8 @@
+LIBS= ../lib/libmaatframe.so -lhiredis_vip
+INC=-I../inc/ -I ../src/entry/ -I../src/inc_internal/ -I/usr/include/MESA/
+all:
+	g++ -o maat_redis_tool.o -c -g -Wall maat_redis_tool.cpp $(INC)
+	g++ -o maat_redis_tool maat_redis_tool.o $(LIBS)
+	g++ -o digest_gen -g digest_gen.c $(INC) $(LIBS)
+clean:
+	rm *.o

tools/maat_redis_tool.cpp

@@ -0,0 +1,180 @@
+#include "Maat_rule.h"
+#include "Maat_command.h"
+#include "Maat_rule_internal.h"
+#include "json2iris.h"
+#include "config_monitor.h"
+#include "hiredis.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+const char* redis_dump_dir="./redis_dump";
+void maat_tool_print_usage(void)
+{
+	printf("maat_redis_tool manipulate rules from redis.\n");
+	printf("Usage:\n");
+	printf("\t-h [host], redis IP, 127.0.0.1 as default.\n");
+	printf("\t-p [port], redis port, 6379 as default.\n");
+	printf("\t-d [dir], dump rules from redis to [dir], %s as default.\n",redis_dump_dir);
+	printf("example: ./maat_redis_tool -h 127.0.0.1 -p 6379 -d %s\n",redis_dump_dir);
+	
+	return;
+}
+static int compare_serial_rule(const void *a, const void *b)
+{
+	struct serial_rule_t *ra=(struct serial_rule_t *)a;
+	struct serial_rule_t *rb=(struct serial_rule_t *)b;
+
+	char p_str[256],q_str[256];
+	snprintf(p_str,sizeof(p_str),"%s.%d",ra->table_name,ra->rule_id);
+	snprintf(q_str,sizeof(q_str),"%s.%d",rb->table_name,rb->rule_id);
+	return strcmp(p_str,q_str);
+}
+void read_rule_from_redis(const char*redis_ip, int redis_port, int redis_db,const char* output_path ,void*logger)
+{
+	struct serial_rule_t* rule_list;
+	int rule_num=0,line_count=0;
+	int i=0,ret=0;
+	int update_type=CM_UPDATE_TYPE_INC;
+	unsigned int version=0;
+	const char* cur_table=NULL;
+
+	char table_path[256],index_path[256];
+	FILE *table_fp=NULL, *index_fp=NULL;
+
+	struct timeval connect_timeout;
+	connect_timeout.tv_sec=0;
+	connect_timeout.tv_usec=100*1000; // 100 ms
+
+	redisContext * ctx;
+	ctx=redisConnectWithTimeout(redis_ip, redis_port,connect_timeout);
+	if(ctx==NULL)
+	{
+		printf("Unable to connect %s:%d db%d\n",redis_ip,redis_port,redis_db);
+		return;
+	}
+
+	printf("Reading key list from %s:%d db%d.\n",redis_ip,redis_port,redis_db);
+	rule_num=get_rm_key_list(0, ctx, &rule_list, logger,&version, &update_type);
+	assert(update_type==CM_UPDATE_TYPE_FULL);
+	printf("MAAT Version: %d, key number: %d\n", version, rule_num);
+	printf("Reading value: ");
+	ret=get_maat_redis_value(ctx,rule_list,rule_num,logger,1);
+	if(ret<0)
+	{
+		goto clean_up;
+	}
+	qsort(rule_list,rule_num, sizeof(struct serial_rule_t),
+                  compare_serial_rule);
+	if((access(output_path,F_OK)) <0)
+
+	{	if((mkdir(output_path,S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) < 0)
+		printf("mkdir %s error\n",output_path);
+
+	}
+	snprintf(index_path,sizeof(index_path),"%s/full_config_index.%010d",output_path,version);
+	index_fp=fopen(index_path,"w");
+	if(index_fp==NULL)
+	{
+		printf("Open %s failed.\n",index_path);
+		goto clean_up;
+	}
+
+	for(i=0;i<rule_num;i++)
+	{
+		if(cur_table==NULL||0!=strcmp(cur_table,rule_list[i].table_name))
+		{
+			if(table_fp!=NULL)
+			{
+				fprintf(index_fp,"%s\t%d\t%s\n",cur_table,line_count,table_path);
+				fclose(table_fp);
+				table_fp=NULL;
+				set_file_rulenum(table_path,line_count, logger);
+				line_count=0;
+			}
+			snprintf(table_path,sizeof(table_path),"%s/%s.%010d",output_path,rule_list[i].table_name,version);
+			set_file_rulenum(table_path, 0, logger);
+			table_fp=fopen(table_path,"a");
+			if(table_fp==NULL)
+			{
+				printf("Open %s failed.\n",table_path);
+				goto clean_up;
+			}
+			printf("Writing %s\n",table_path);
+			cur_table=rule_list[i].table_name;
+		}
+		fprintf(table_fp,"%s\tRID=%d\n",rule_list[i].table_line,rule_list[i].rule_id);
+		line_count++;
+	}
+	fclose(table_fp);
+	table_fp=NULL;
+	fprintf(index_fp,"%s\t%d\t%s\n",cur_table,line_count,table_path);
+	set_file_rulenum(table_path,line_count, logger);
+	
+	printf("Writing complete: %s\n",index_path);
+clean_up:
+	for(i=0;i<rule_num;i++)
+	{
+		empty_serial_rules(rule_list+i);
+	}
+	free(rule_list);
+	rule_list=NULL;
+	if(ctx!=NULL)
+	{
+		redisFree(ctx);
+	}
+	if(index_fp!=NULL)
+	{
+		fclose(index_fp);
+	}
+	if(table_fp!=NULL)
+	{
+		fclose(table_fp);
+	}
+	return;
+}
+int main(int argc, char * argv[])
+{
+	int oc=0;
+	char model='?';
+	char redis_ip[64];
+	int redis_port=6379;
+	int redis_db=0;
+	strncpy(redis_ip,"127.0.0.1",sizeof(redis_ip));
+	char table_info[128];
+	strncpy(table_info,"./table_info.conf",sizeof(table_info));
+	char dump_dir[128];
+	strncpy(dump_dir,redis_dump_dir,sizeof(dump_dir));
+	while((oc=getopt(argc,argv,"mh:p:t:d:f:"))!=-1)
+	{
+		switch(oc)
+		{
+			case 'm':
+				model=oc;
+				break;
+			case 'h':
+				strncpy(redis_ip,optarg,sizeof(redis_ip));
+				break;
+			case 'p':
+				sscanf(optarg,"%d",&redis_port);
+				break;
+			case 't':
+				strncpy(table_info,optarg,sizeof(table_info));
+				break;
+			case 'd':
+				strncpy(dump_dir,optarg,sizeof(dump_dir));
+				if(dump_dir[strlen(dump_dir)-1]=='/')
+				{
+					dump_dir[strlen(dump_dir)-1]='\0';
+				}
+				break;
+			case '?':
+			default:
+				maat_tool_print_usage();
+				return 0;
+				break;
+		}
+	}
+	read_rule_from_redis(redis_ip,redis_port, redis_db,dump_dir, NULL);
+}