sds latencyCommandGenSparkeline(char *event, struct latencyTimeSeries *ts) {
int j;
struct sequence *seq = createSparklineSequence();
sds graph = sdsempty();
uint32_t min = 0, max = 0;
for (j = 0; j < LATENCY_TS_LEN; j++) {
int i = (ts->idx + j) % LATENCY_TS_LEN;
int elapsed;
char *label;
char buf[64];
if (ts->samples[i].time == 0) continue;
/* Update min and max. */
if (seq->length == 0) {
min = max = ts->samples[i].latency;
} else {
if (ts->samples[i].latency > max) max = ts->samples[i].latency;
if (ts->samples[i].latency < min) min = ts->samples[i].latency;
}
/* Use as label the number of seconds / minutes / hours / days
* ago the event happened. */
elapsed = time(NULL) - ts->samples[i].time;
if (elapsed < 60)
snprintf(buf,sizeof(buf),"%ds",elapsed);
else if (elapsed < 3600)
snprintf(buf,sizeof(buf),"%dm",elapsed/60);
else if (elapsed < 3600*24)
snprintf(buf,sizeof(buf),"%dh",elapsed/3600);
else
snprintf(buf,sizeof(buf),"%dd",elapsed/(3600*24));
label = zstrdup(buf);
sparklineSequenceAddSample(seq,ts->samples[i].latency,label);
}
graph = sdscatprintf(graph,
"%s - high %lu ms, low %lu ms (all time high %lu ms)\n", event,
(unsigned long) max, (unsigned long) min, (unsigned long) ts->max);
for (j = 0; j < LATENCY_GRAPH_COLS; j++)
graph = sdscatlen(graph,"-",1);
graph = sdscatlen(graph,"\n",1);
graph = sparklineRender(graph,seq,LATENCY_GRAPH_COLS,4,SPARKLINE_FILL);
freeSparklineSequence(seq);
return graph;
}
END_TEST
START_TEST (test_find_common_prefix_same_pattern2)
{
node * n = r3_tree_create(10);
edge * e = r3_edge_createl(zstrdup("{slug:xxx}/hate"), sizeof("{slug:xxx}/hate")-1, NULL);
r3_node_append_edge(n,e);
int prefix_len;
edge *ret_edge = NULL;
prefix_len = 0;
ret_edge = r3_node_find_common_prefix(n, "{slug:yyy}/hate", sizeof("{slug:yyy}/hate")-1, &prefix_len, NULL);
ck_assert(ret_edge);
ck_assert_int_eq(prefix_len, 0);
r3_tree_free(n);
}
END_TEST
START_TEST (test_find_common_prefix_double_middle)
{
node * n = r3_tree_create(10);
edge * e = r3_edge_createl(zstrdup("{slug}/foo/{name}"), sizeof("{slug}/foo/{name}")-1, NULL);
r3_node_append_edge(n,e);
int prefix_len;
edge *ret_edge = NULL;
char *errstr;
errstr = NULL;
ret_edge = r3_node_find_common_prefix(n, "{slug}/foo/{number}", sizeof("{slug}/foo/{number}")-1, &prefix_len, &errstr);
ck_assert(ret_edge);
ck_assert_int_eq(prefix_len, 11);
SAFE_FREE(errstr);
r3_tree_free(n);
}
END_TEST
START_TEST (test_find_common_prefix_after)
{
node * n = r3_tree_create(10);
edge * e = r3_edge_createl(zstrdup("{slug}/foo"), sizeof("{slug}/foo")-1, NULL);
r3_node_append_edge(n,e);
int prefix_len = 0;
edge *ret_edge = NULL;
char *errstr = NULL;
errstr = NULL;
ret_edge = r3_node_find_common_prefix(n, "/foo", sizeof("/foo")-1, &prefix_len, &errstr);
ck_assert(ret_edge == NULL);
ck_assert_int_eq(prefix_len, 0);
SAFE_FREE(errstr);
errstr = NULL;
ret_edge = r3_node_find_common_prefix(n, "{slug}/bar", sizeof("{slug}/bar")-1, &prefix_len, &errstr);
ck_assert(ret_edge);
ck_assert_int_eq(prefix_len, 7);
SAFE_FREE(errstr);
errstr = NULL;
ret_edge = r3_node_find_common_prefix(n, "{slug}/foo", sizeof("{slug}/foo")-1, &prefix_len, &errstr);
ck_assert(ret_edge);
ck_assert_int_eq(prefix_len, 10);
SAFE_FREE(errstr);
r3_tree_free(n);
}
apex_cfg_t*
apex_cfg_new(int argc, char* argv[]){
apex_cfg_t* self = (apex_cfg_t*)zmalloc(sizeof(apex_cfg_t));
assert(self);
memset(self, 0, sizeof(apex_cfg_t));
self->apex_address = zstrdup(option(argc,argv, "-a", "10.27.49.13@9101/tcp"));
//self->apex_address = zstrdup(option(argc,argv, "-a", "127.0.0.1@9101/tcp"));
self->apex_user = zstrdup(option(argc,argv, "-u", ""));
self->apex_pwd = zstrdup(option(argc,argv, "-p", ""));
self->apex_timeout = atoi(option(argc,argv,"-t","3"));
self->apex_reconnect = atoi(option(argc,argv,"-r","1000"));
self->verbose = atoi(option(argc,argv, "-v", "1"));
self->debug = atoi(option(argc,argv, "-dbg", "0"));
self->worker_threads = atoi(option(argc,argv, "-c", "2"));
self->broker = zstrdup(option(argc,argv, "-b", "localhost:15555"));
self->service_name = zstrdup(option(argc,argv, "-s", "APEX"));
self->service_regtoken = zstrdup(option(argc,argv, "-kreg", ""));
self->service_acctoken = zstrdup(option(argc,argv, "-kacc", ""));
self->probe_interval = atoi(option(argc,argv, "-t", "6000"));
self->log_path = zstrdup(option(argc,argv, "-log", NULL));
return self;
}
void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
char tmpfile[256], *err;
int dfd, maxtries = 5;
int sockerr = 0;
socklen_t errlen = sizeof(sockerr);
REDIS_NOTUSED(el);
REDIS_NOTUSED(privdata);
REDIS_NOTUSED(mask);
/* If this event fired after the user turned the instance into a master
* with SLAVEOF NO ONE we must just return ASAP. */
if (server.repl_state == REDIS_REPL_NONE) {
close(fd);
return;
}
/* Check for errors in the socket. */
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) == -1)
sockerr = errno;
if (sockerr) {
aeDeleteFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE);
redisLog(REDIS_WARNING,"Error condition on socket for SYNC: %s",
strerror(sockerr));
goto error;
}
/* If we were connecting, it's time to send a non blocking PING, we want to
* make sure the master is able to reply before going into the actual
* replication process where we have long timeouts in the order of
* seconds (in the meantime the slave would block). */
if (server.repl_state == REDIS_REPL_CONNECTING) {
redisLog(REDIS_NOTICE,"Non blocking connect for SYNC fired the event.");
/* Delete the writable event so that the readable event remains
* registered and we can wait for the PONG reply. */
aeDeleteFileEvent(server.el,fd,AE_WRITABLE);
server.repl_state = REDIS_REPL_RECEIVE_PONG;
/* Send the PING, don't check for errors at all, we have the timeout
* that will take care about this. */
syncWrite(fd,"PING\r\n",6,100);
return;
}
/* Receive the PONG command. */
if (server.repl_state == REDIS_REPL_RECEIVE_PONG) {
char buf[1024];
/* Delete the readable event, we no longer need it now that there is
* the PING reply to read. */
aeDeleteFileEvent(server.el,fd,AE_READABLE);
/* Read the reply with explicit timeout. */
buf[0] = '\0';
if (syncReadLine(fd,buf,sizeof(buf),
server.repl_syncio_timeout*1000) == -1)
{
redisLog(REDIS_WARNING,
"I/O error reading PING reply from master: %s",
strerror(errno));
goto error;
}
/* We don't care about the reply, it can be +PONG or an error since
* the server requires AUTH. As long as it replies correctly, it's
* fine from our point of view. */
if (buf[0] != '-' && buf[0] != '+') {
redisLog(REDIS_WARNING,"Unexpected reply to PING from master.");
goto error;
} else {
redisLog(REDIS_NOTICE,
"Master replied to PING, replication can continue...");
}
}
/* AUTH with the master if required. */
if(server.masterauth) {
err = sendSynchronousCommand(fd,"AUTH",server.masterauth,NULL);
if (err) {
redisLog(REDIS_WARNING,"Unable to AUTH to MASTER: %s",err);
sdsfree(err);
goto error;
}
}
/* Set the slave port, so that Master's INFO command can list the
* slave listening port correctly. */
{
sds port = sdsfromlonglong(server.port);
err = sendSynchronousCommand(fd,"REPLCONF","listening-port",port,
NULL);
sdsfree(port);
/* Ignore the error if any, not all the Redis versions support
* REPLCONF listening-port. */
if (err) {
redisLog(REDIS_NOTICE,"(non critical): Master does not understand REPLCONF listening-port: %s", err);
sdsfree(err);
}
}
/* Issue the SYNC command */
if (syncWrite(fd,"SYNC\r\n",6,server.repl_syncio_timeout*1000) == -1) {
redisLog(REDIS_WARNING,"I/O error writing to MASTER: %s",
strerror(errno));
goto error;
}
/* Prepare a suitable temp file for bulk transfer */
while(maxtries--) {
snprintf(tmpfile,256,
"temp-%d.%ld.rdb",(int)server.unixtime,(long int)getpid());
dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
if (dfd != -1) break;
sleep(1);
}
if (dfd == -1) {
redisLog(REDIS_WARNING,"Opening the temp file needed for MASTER <-> SLAVE synchronization: %s",strerror(errno));
goto error;
}
/* Setup the non blocking download of the bulk file. */
if (aeCreateFileEvent(server.el,fd, AE_READABLE,readSyncBulkPayload,NULL)
== AE_ERR)
{
redisLog(REDIS_WARNING,
"Can't create readable event for SYNC: %s (fd=%d)",
strerror(errno),fd);
goto error;
}
server.repl_state = REDIS_REPL_TRANSFER;
server.repl_transfer_size = -1;
server.repl_transfer_read = 0;
server.repl_transfer_last_fsync_off = 0;
server.repl_transfer_fd = dfd;
server.repl_transfer_lastio = server.unixtime;
server.repl_transfer_tmpfile = zstrdup(tmpfile);
return;
error:
close(fd);
server.repl_transfer_s = -1;
server.repl_state = REDIS_REPL_CONNECT;
return;
}
void error_throw(char *error_code, char *error_message) {
error_clear();
strncpy(stack.error_squid, error_code, ERROR_CODE);
stack.description = (char *)zstrdup(error_message);
}
void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
char tmpfile[256], *err;
int dfd, maxtries = 5;
int sockerr = 0;
socklen_t errlen = sizeof(sockerr);
REDIS_NOTUSED(el);
REDIS_NOTUSED(privdata);
REDIS_NOTUSED(mask);
/* If this event fired after the user turned the instance into a master
* with SLAVEOF NO ONE we must just return ASAP. */
if (server.repl_state == REDIS_REPL_NONE) {
close(fd);
return;
}
/* Check for errors in the socket. */
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &sockerr, &errlen) == -1)
sockerr = errno;
if (sockerr) {
aeDeleteFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE);
redisLog(REDIS_WARNING,"Error condition on socket for SYNC: %s",
strerror(sockerr));
goto error;
}
/* If we were connecting, it's time to send a non blocking PING, we want to
* make sure the master is able to reply before going into the actual
* replication process where we have long timeouts in the order of
* seconds (in the meantime the slave would block). */
//如果之前正在REDIS_REPL_CONNECTING，现在有可读可写事件了，说明连接成功了，下一步就是需要发送PING请求
if (server.repl_state == REDIS_REPL_CONNECTING) {
redisLog(REDIS_NOTICE,"Non blocking connect for SYNC fired the event.");
/* Delete the writable event so that the readable event remains
* registered and we can wait for the PONG reply. */
aeDeleteFileEvent(server.el,fd,AE_WRITABLE);
server.repl_state = REDIS_REPL_RECEIVE_PONG;
/* Send the PING, don't check for errors at all, we have the timeout
* that will take care about this. */
syncWrite(fd,"PING\r\n",6,100);//同步阻塞发送PING命令,这样服务端会返回"+PONG\r\n"字符串的
//这里实现的比较简单，就是发送完PING后，当连接可读可写时，再进syncWithMaster这个函数的时候
//下面的代码会判断PONG这个动作，然后就会阻塞去读取一行回复，看他是不是成功了。
return;
}
/* Receive the PONG command. */
if (server.repl_state == REDIS_REPL_RECEIVE_PONG) {
char buf[1024];
//上面在REDIS_REPL_CONNECTING状态的时候给master发送了一行PING指令，这样master会返回"+PONG\r\n"的，
//现在连接可读或者可写了，所以我们阻塞读取这么多数据，判断返回是否OK。
/* Delete the readable event, we no longer need it now that there is
* the PING reply to read. */
aeDeleteFileEvent(server.el,fd,AE_READABLE);
/* Read the reply with explicit timeout. */
buf[0] = '\0';
if (syncReadLine(fd,buf,sizeof(buf),
server.repl_syncio_timeout*1000) == -1)
{
redisLog(REDIS_WARNING,
"I/O error reading PING reply from master: %s",
strerror(errno));
goto error;
}
/* We accept only two replies as valid, a positive +PONG reply
* (we just check for "+") or an authentication error.
* Note that older versions of Redis replied with "operation not
* permitted" instead of using a proper error code, so we test
* both. */
if (buf[0] != '+' &&
strncmp(buf,"-NOAUTH",7) != 0 &&
strncmp(buf,"-ERR operation not permitted",28) != 0)
{
redisLog(REDIS_WARNING,"Error reply to PING from master: '%s'",buf);
goto error;
} else {
redisLog(REDIS_NOTICE, "Master replied to PING, replication can continue...");
}
}
/* AUTH with the master if required. */
if(server.masterauth) {
err = sendSynchronousCommand(fd,"AUTH",server.masterauth,NULL);
if (err) {
redisLog(REDIS_WARNING,"Unable to AUTH to MASTER: %s",err);
sdsfree(err);
goto error;
}
}
/* Set the slave port, so that Master's INFO command can list the
* slave listening port correctly. */
{
sds port = sdsfromlonglong(server.port);
err = sendSynchronousCommand(fd,"REPLCONF","listening-port",port,
NULL);
sdsfree(port);
/* Ignore the error if any, not all the Redis versions support
* REPLCONF listening-port. */
if (err) {
redisLog(REDIS_NOTICE,"(non critical): Master does not understand REPLCONF listening-port: %s", err);
sdsfree(err);
}
}
//到这里的话，连接肯定成功了，而且PING指令也都收到了回复。所以果断发送SYNC指令
/* Issue the SYNC command */
if (syncWrite(fd,"SYNC\r\n",6,server.repl_syncio_timeout*1000) == -1) {
redisLog(REDIS_WARNING,"I/O error writing to MASTER: %s",
strerror(errno));
goto error;
}
/* Prepare a suitable temp file for bulk transfer */
while(maxtries--) {
snprintf(tmpfile,256,
"temp-%d.%ld.rdb",(int)server.unixtime,(long int)getpid());
dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
if (dfd != -1) break;
sleep(1);
}
if (dfd == -1) {
redisLog(REDIS_WARNING,"Opening the temp file needed for MASTER <-> SLAVE synchronization: %s",strerror(errno));
goto error;
}
//SYNC命令已经发送了，以后的可读可写事件就依靠readSyncBulkPayload来读取解析了。
/* Setup the non blocking download of the bulk file. */
if (aeCreateFileEvent(server.el,fd, AE_READABLE,readSyncBulkPayload,NULL)
== AE_ERR)
{
redisLog(REDIS_WARNING,
"Can't create readable event for SYNC: %s (fd=%d)",
strerror(errno),fd);
goto error;
}
server.repl_state = REDIS_REPL_TRANSFER;
server.repl_transfer_size = -1;
server.repl_transfer_read = 0;
server.repl_transfer_last_fsync_off = 0;
server.repl_transfer_fd = dfd;
server.repl_transfer_lastio = server.unixtime;
server.repl_transfer_tmpfile = zstrdup(tmpfile);
return;
error:
close(fd);
server.repl_transfer_s = -1;
server.repl_state = REDIS_REPL_CONNECT;
return;
}
atom_t *new_string(const char *value) {
atom_t *atom = new_atom(ATOM_STRING);
string(atom) = zstrdup(value);
return atom;
}
void DXDB_initServerConfig() { //printf("DXDB_initServerConfig\n");
bzero(&server.alc, sizeof(alchemy_server_extensions_t));
server.alc.Basedir = zstrdup("./");
server.alc.WebServerMode = -1;
server.alc.RestAPIMode = -1;
}
int zmaster_server_main(int argc, char **argv)
{
int op;
char *test_listen = 0;
parent_pid = getppid();
test_mode = 1;
reloading = 0;
softstopping = 0;
ev_status = 0;
ev_listen = 0;
local_ev_close_do_once = 1;
signal(SIGPIPE, SIG_IGN);
if (!zvar_progname) {
zvar_progname = argv[0];
}
zvar_config_init();
zvar_evbase_init();
while ((op = getopt(argc, argv, "Ml:c:o:t:dv")) > 0) {
switch (op) {
case 'M':
test_mode = 0;
break;
case 'l':
test_listen = optarg;
break;
case 'c':
zconfig_load(zvar_config, optarg);
break;
case 'o':
{
char *key, *value;
key = zstrdup(optarg);
value = strchr(key, '=');
if (value) {
*value++ = 0;
}
zconfig_add(zvar_config, key, value);
zfree(key);
}
break;
case 't':
zvar_master_server_listen_type = optarg[0];
break;
case 'd':
zlog_set_level_from_console(ZLOG_DEBUG);
break;
case 'v':
zlog_set_level_from_console(ZLOG_VERBOSE);
break;
default:
zfatal("parameters error");
}
}
zlog_set_level(zlog_parse_level(zconfig_get_str(zvar_config, "zlog_level", "info")));
register_server(test_listen);
{
char *run_user = zconfig_get_str(zvar_config, "zrun_user", 0);
if (!ZEMPTY(run_user)) {
if (zchroot_user(0, run_user) < 0) {
zfatal("change user %s(%m)", run_user);
}
}
}
if (zmaster_server_before_service) {
zmaster_server_before_service();
}
while (1) {
zevbase_dispatch(zvar_evbase, 0);
if (zmaster_server_loop) {
zmaster_server_loop();
}
if (reloading) {
local_ev_close();
if (getppid() != parent_pid) {
break;
}
}
if (softstopping) {
local_ev_close();
break;
}
}
local_ev_close();
if (zmaster_server_before_exit) {
zmaster_server_before_exit();
}
zevtimer_fini(&reload_timer);
zevbase_free(zvar_evbase);
return 0;
}
void pending_operations_init (const char *const olddir_prefix, const char *const newdir_prefix) {
po_olddir = zstrdup (olddir_prefix);
po_newdir = zstrdup (newdir_prefix);
po_olddir_length = strlen (po_olddir);
po_newdir_length = strlen (po_newdir);
}
void *
dictStrDup (void *privdata, const void *val)
{
DICT_NOTUSED (privdata);
return zstrdup ((char *) val);
}
/* I agree, this is a very rudimental way to load a configuration...
will improve later if the config gets more complex */
void loadServerConfig(char *filename) {
FILE *fp;
char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
int linenum = 0;
sds line = NULL;
if (filename[0] == '-' && filename[1] == '\0')
fp = stdin;
else {
if ((fp = fopen(filename,"r")) == NULL) {
redisLog(REDIS_WARNING, "Fatal error, can't open config file '%s'", filename);
exit(1);
}
}
while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
sds *argv;
int argc, j;
linenum++;
line = sdsnew(buf);
line = sdstrim(line," \t\r\n");
/* Skip comments and blank lines*/
if (line[0] == '#' || line[0] == '\0') {
sdsfree(line);
continue;
}
/* Split into arguments */
argv = sdssplitargs(line,&argc);
sdstolower(argv[0]);
/* Execute config directives */
if (!strcasecmp(argv[0],"timeout") && argc == 2) {
server.maxidletime = atoi(argv[1]);
if (server.maxidletime < 0) {
err = "Invalid timeout value"; goto loaderr;
}
} else if (!strcasecmp(argv[0],"port") && argc == 2) {
server.port = atoi(argv[1]);
if (server.port < 0 || server.port > 65535) {
err = "Invalid port"; goto loaderr;
}
} else if (!strcasecmp(argv[0],"bind") && argc == 2) {
server.bindaddr = zstrdup(argv[1]);
} else if (!strcasecmp(argv[0],"formula") && argc == 2) {
void *val = loadfm(argv[1]);
if(!val) goto loaderr;
int retval = dictAdd(server.fms, sdsnew(argv[1]), val);
if(retval != DICT_OK) goto loaderr;
} else if (!strcasecmp(argv[0],"dir") && argc == 2) {
if (chdir(argv[1]) == -1) {
redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
argv[1], strerror(errno));
exit(1);
}
} else if (!strcasecmp(argv[0],"loglevel") && argc == 2) {
if (!strcasecmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
else if (!strcasecmp(argv[1],"verbose")) server.verbosity = REDIS_VERBOSE;
else if (!strcasecmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
else if (!strcasecmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;
else {
err = "Invalid log level. Must be one of debug, notice, warning";
goto loaderr;
}
} else if (!strcasecmp(argv[0],"logfile") && argc == 2) {
FILE *logfp;
server.logfile = zstrdup(argv[1]);
if (!strcasecmp(server.logfile,"stdout")) {
zfree(server.logfile);
server.logfile = NULL;
}
if (server.logfile) {
/* Test if we are able to open the file. The server will not
* be able to abort just for this problem later... */
logfp = fopen(server.logfile,"a");
if (logfp == NULL) {
err = sdscatprintf(sdsempty(),
"Can't open the log file: %s", strerror(errno));
goto loaderr;
}
fclose(logfp);
}
} else if (!strcasecmp(argv[0],"databases") && argc == 2) {
server.dbnum = atoi(argv[1]);
if (server.dbnum < 1) {
err = "Invalid number of databases"; goto loaderr;
}
} else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
server.maxclients = atoi(argv[1]);
} else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
if ((server.daemonize = yesnotoi(argv[1])) == -1) {
err = "argument must be 'yes' or 'no'"; goto loaderr;
}
} else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {
zfree(server.pidfile);
server.pidfile = zstrdup(argv[1]);
} else {
err = "Bad directive or wrong number of arguments"; goto loaderr;
}
for (j = 0; j < argc; j++)
sdsfree(argv[j]);
zfree(argv);
sdsfree(line);
}
if (fp != stdin) fclose(fp);
return;
loaderr:
fprintf(stderr, "\n*** FATAL CONFIG FILE ERROR ***\n");
fprintf(stderr, "Reading the configuration file, at line %d\n", linenum);
fprintf(stderr, ">>> '%s'\n", line);
fprintf(stderr, "%s\n", err);
exit(1);
}
atom_t *new_symbol(const char *value) {
atom_t *atom = new_atom(ATOM_SYMBOL);
symbol(atom) = zstrdup(value);
return atom;
}
VSTInstrument::VSTInstrument(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, 1, 0), align16()
//, vm(new LuaVM())
, downsampler(new invader::ZResampler2x)
//, vstEditor(nullptr)
, programFile(zstrdup(ZScopedRegistryKey("Software\\Fnuque\\Invader", "ProgramPath").str))
, synth(nullptr)
{
if (audioMaster)
{
setNumInputs(0); // no inputs
setNumOutputs(2); // usually 2 outputs, left and right channel respectively
canProcessReplacing();
programsAreChunks(true);
isSynth();
setUniqueID('inva');
}
//strcpy(programName, "default");
/*
// Init LuaVM
#ifdef RUN_FROM_DISK
ZScopedRegistryKey basePath("BasePath");
// Set skin path
char skinPath[512];
sprintf(skinPath, "%stransgressor/vst/gui/skins/", basePath.str);
vm->SetGlobalString("skinPath", skinPath);
// Paths should be matched by shortcuts below
vm->AddPackagePath("%s?.lua", basePath.str);
vm->AddPackagePath("%sexternal/libs/lpeg/src/?.lua", basePath.str);
vm->AddPackagePath("%stransgressor/vst/compiler/?.lua", basePath.str);
#else
// Set skin path
ZScopedRegistryKey skinPath("SkinPath");
vm->SetGlobalString("skinPath", skinPath.str);
// Load embedded scripts and set preload shortcuts
ZResource scripts("packedscripts.lua", "LUA");
vm->DoString((const char* const)scripts.GetString());
vm->AddPackageShortcut("external.libs.lpeg.src");
vm->AddPackageShortcut("transgressor.vst.compiler");
#endif
vm->Require("libs.base_synth_gui.script.init");
vm->Require("transgressor.vst.gui.script.root");
// Create Editor
vstEditor = new VSTEditor(this, vm);
setEditor(vstEditor);
*/
suspend();
// vm->SetGlobalVariable("editor", "VSTEditor *", vstEditor);
//invader::ZFIRInterpolator inter;
//inter.Init();
//i vm->SetGlobalVariable("synth", "ZSynth *", synth);
// vm->LoadDefaultProgram();
/*// Create test program
synth->synth = synth;
synth->instrument = NULL;
synth->voice = NULL;
synth->program = new ZVMProgram;
synth->program->bytecodeSize = 3;
synth->program->bytecode = new opcode_t[3];
synth->program->bytecode[0] = kOpcodeSynthRenderInstrument;
synth->program->bytecode[1] = 0;
synth->program->bytecode[2] = kOpcodeStop;
synth->entryPoint = 0;
synth->CreateNodeInstances(synth->program);
synth->instruments[0]->hasProgram = true;
synth->instruments[0]->isActive = true;
for (uint32_t i=0; i<kNumVoices; i++)
{
ZVoice* voice = synth->instruments[0]->voices[i];
voice->synth = synth;
voice->instrument = synth->instruments[0];
voice->voice = voice;
voice->program = new ZVMProgram;
voice->program->bytecodeSize = 2;
voice->program->bytecode = new opcode_t[2];
voice->program->bytecode[0] = kOpcodeSynthSinOsc;
voice->program->bytecode[1] = kOpcodeStop;
voice->entryPoint = 0;
voice->CreateNodeInstances(voice->program);
}*/
}
int syncWithMaster(void) {
char buf[1024], tmpfile[256], authcmd[1024];
int fd = anetTcpConnect(NULL,server.masterhost,server.masterport);
int dfd, maxtries = 5;
if (fd == -1) {
redisLog(REDIS_WARNING,"Unable to connect to MASTER: %s",
strerror(errno));
return REDIS_ERR;
}
/* AUTH with the master if required. */
if(server.masterauth) {
snprintf(authcmd, 1024, "AUTH %s\r\n", server.masterauth);
if (syncWrite(fd, authcmd, strlen(server.masterauth)+7, 5) == -1) {
close(fd);
redisLog(REDIS_WARNING,"Unable to AUTH to MASTER: %s",
strerror(errno));
return REDIS_ERR;
}
/* Read the AUTH result. */
if (syncReadLine(fd,buf,1024,3600) == -1) {
close(fd);
redisLog(REDIS_WARNING,"I/O error reading auth result from MASTER: %s",
strerror(errno));
return REDIS_ERR;
}
if (buf[0] != '+') {
close(fd);
redisLog(REDIS_WARNING,"Cannot AUTH to MASTER, is the masterauth password correct?");
return REDIS_ERR;
}
}
/* Issue the SYNC command */
if (syncWrite(fd,"SYNC \r\n",7,5) == -1) {
close(fd);
redisLog(REDIS_WARNING,"I/O error writing to MASTER: %s",
strerror(errno));
return REDIS_ERR;
}
/* Prepare a suitable temp file for bulk transfer */
while(maxtries--) {
snprintf(tmpfile,256,
"temp-%d.%ld.rdb",(int)time(NULL),(long int)getpid());
dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
if (dfd != -1) break;
sleep(1);
}
if (dfd == -1) {
close(fd);
redisLog(REDIS_WARNING,"Opening the temp file needed for MASTER <-> SLAVE synchronization: %s",strerror(errno));
return REDIS_ERR;
}
/* Setup the non blocking download of the bulk file. */
if (aeCreateFileEvent(server.el, fd, AE_READABLE, readSyncBulkPayload, NULL)
== AE_ERR)
{
close(fd);
redisLog(REDIS_WARNING,"Can't create readable event for SYNC");
return REDIS_ERR;
}
server.replstate = REDIS_REPL_TRANSFER;
server.repl_transfer_left = -1;
server.repl_transfer_s = fd;
server.repl_transfer_fd = dfd;
server.repl_transfer_lastio = time(NULL);
server.repl_transfer_tmpfile = zstrdup(tmpfile);
return REDIS_OK;
}
void initClient(config_t * config) {
config->hostip = zstrdup("127.0.0.1");
config->hostport = 11211;
}
int DXDB_loadServerConfig(int argc, sds *argv) {
//printf("DXDB_loadServerConfig: 0: %s\n", argv[0]);
if (!strcasecmp(argv[0], "luacronfunc") && argc == 2) {
if (server.alc.LuaCronFunc) zfree(server.alc.LuaCronFunc);
server.alc.LuaCronFunc = zstrdup(argv[1]);
return 0;
} else if (!strcasecmp(argv[0], "basedir") && argc == 2) {
if (server.alc.Basedir) zfree(server.alc.Basedir);
server.alc.Basedir = zstrdup(argv[1]); return 0;
} else if (!strcasecmp(argv[0], "lua_output_start") && argc == 2) {
if (server.alc.OutputLuaFunc_Start) {
zfree(server.alc.OutputLuaFunc_Start);
}
server.alc.OutputLuaFunc_Start = zstrdup(argv[1]); return 0;
} else if (!strcasecmp(argv[0], "lua_output_cnames") && argc == 2) {
if (server.alc.OutputLuaFunc_Cnames) {
zfree(server.alc.OutputLuaFunc_Cnames);
}
server.alc.OutputLuaFunc_Cnames = zstrdup(argv[1]); return 0;
} else if (!strcasecmp(argv[0], "lua_output_row") && argc == 2) {
if (server.alc.OutputLuaFunc_Row) zfree(server.alc.OutputLuaFunc_Row);
server.alc.OutputLuaFunc_Row = zstrdup(argv[1]); return 0;
} else if (!strcasecmp(argv[0], "outputmode") && argc >= 2) {
if (!strcasecmp(argv[1], "embedded")) {
server.alc.OutputMode = OUTPUT_EMBEDDED;
} else if (!strcasecmp(argv[1], "pure_redis")) {
server.alc.OutputMode = OUTPUT_PURE_REDIS;
} else if (!strcasecmp(argv[1], "normal")) {
server.alc.OutputMode = OUTPUT_NORMAL;
} else if (!strcasecmp(argv[1], "lua")) {
if (!server.alc.OutputLuaFunc_Start ||
!server.alc.OutputLuaFunc_Cnames ||
!server.alc.OutputLuaFunc_Row) {
char *err = "OUTPUTMODE lua requires [lua_output_start, "\
"lua_output_cnames, lua_output_row]";
fprintf(stderr, "%s\n", err);
return -1;
}
server.alc.OutputMode = OUTPUT_LUA;
} else {
char *err = "argument must be 'embedded', 'pure_redis' or 'normal'";
fprintf(stderr, "%s\n", err);
return -1;
}
return 0;
} else if (!strcasecmp(argv[0], "webserver_mode") && argc == 2) {
if ((server.alc.WebServerMode = yesnotoi(argv[1])) == -1) {
char *err = "argument must be 'yes' or 'no'";
fprintf(stderr, "%s\n", err);
return -1;
}
#if 0 //TODO webserver_mode & rest_api_mode can run in tandem??? right???
if (server.alc.RestAPIMode != -1) {
char *err = "CHOOSE: webserver_mode OR rest_api_mode ";
fprintf(stderr, "%s\n", err);
return -1;
}
#endif
return 0;
} else if (!strcasecmp(argv[0], "webserver_index_function") && argc == 2) {
if (server.alc.WebServerIndexFunc) zfree(server.alc.WebServerIndexFunc);
server.alc.WebServerIndexFunc = zstrdup(argv[1]);
return 0;
} else if (!strcasecmp(argv[0], "webserver_whitelist_address") &&
argc == 2) {
if (!inet_aton(argv[1], &server.alc.WS_WL_Addr)) {
fprintf(stderr, "ERR: webserver_whitelist_address: %s\n", argv[1]);
return -1;
}
computeWS_WL_MinMax();
return 0;
} else if (!strcasecmp(argv[0], "webserver_whitelist_netmask") &&
argc == 2) {
if (!inet_aton(argv[1], &server.alc.WS_WL_Mask)) {
fprintf(stderr, "ERR: webserver_whitelist_netmask: %s\n", argv[1]);
return -1;
}
computeWS_WL_MinMax();
return 0;
} else if (!strcasecmp(argv[0], "rest_api_mode") && argc == 2) {
int yn = yesnotoi(argv[1]);
if (yn == -1) {
char *err = "argument must be 'yes' or 'no'";
fprintf(stderr, "%s\n", err);
return -1;
}
server.alc.RestAPIMode = yn ? 1 : -1;
#if 0 //TODO webserver_mode & rest_api_mode can run in tandem??? right???
if (server.alc.WebServerMode != -1) {
char *err = "CHOOSE: webserver_mode OR rest_api_mode ";
fprintf(stderr, "%s\n", err);
return -1;
}
#endif
return 0;
} else if (!strcasecmp(argv[0],"sqlappendonly") && argc == 2) {
if (!strcasecmp(argv[1], "no")) {
server.appendonly = 0;
} else if (!strcasecmp(argv[1], "yes")) {
server.appendonly = 1;
} else if (!strcasecmp(argv[1], "mysql")) {
server.appendonly = 1;
server.alc.SQL_AOF_MYSQL = 1;
} else {
fprintf(stderr, "argument must be 'yes', 'no' or 'mysql;\n");
return -1;
}
server.alc.SQL_AOF = 1;
return 0;
}
return 1;
}
static void
populate_command_table (dict * commands, int type)
{
int j;
int numcommands;
struct redis_command *command_table;
switch (type)
{
case COMMAND_MANAGER_TYPE_USER:
numcommands =
sizeof (redis_command_table) / sizeof (struct redis_command);
command_table = redis_command_table;
break;
case COMMAND_MANAGER_TYPE_ADMIN:
numcommands =
sizeof (admin_command_table) / sizeof (struct redis_command);
command_table = admin_command_table;
break;
default:
assert (0);
}
for (j = 0; j < numcommands; j++)
{
struct redis_command *c = command_table + j;
const char *f = c->sflags;
int retval;
while (*f != '\0')
{
switch (*f)
{
case 'w':
c->flags |= REDIS_CMD_WRITE;
break;
case 'r':
c->flags |= REDIS_CMD_READONLY;
break;
case 'm':
c->flags |= REDIS_CMD_DENYOOM;
break;
case 'a':
c->flags |= REDIS_CMD_ADMIN;
break;
case 'p':
c->flags |= REDIS_CMD_PUBSUB;
break;
case 'f':
c->flags |= REDIS_CMD_FORCE_REPLICATION;
break;
case 's':
c->flags |= REDIS_CMD_NOSCRIPT;
break;
case 'R':
c->flags |= REDIS_CMD_RANDOM;
break;
case 'S':
c->flags |= REDIS_CMD_SORT_FOR_SCRIPT;
break;
case 'l':
c->flags |= REDIS_CMD_LOADING;
break;
case 't':
c->flags |= REDIS_CMD_STALE;
break;
case 'M':
c->flags |= REDIS_CMD_SKIP_MONITOR;
break;
case 'N':
c->flags |= GW_CMD_NOT_SUPPORT;
break;
case 'A':
c->flags |= GW_CMD_ADMIN;
break;
default:
gwlog (GW_WARNING, "Unsupported command flag");
assert (0);
break;
}
f++;
}
retval = dictAdd (commands, zstrdup (c->name), c);
assert (retval == DICT_OK);
}
}
