static NEOERR *wdb_load_defn (WDB *wdb, const char *name)
{
char path[_POSIX_PATH_MAX];
char line[1024];
FILE *fp;
NEOERR *err = STATUS_OK;
snprintf (path, sizeof(path), "%s.wdf", name);
fp = fopen (path, "r");
if (fp == NULL)
{
if (errno == ENOENT)
return nerr_raise (NERR_NOT_FOUND, "Unable to open defn %s", name);
return nerr_raise_errno (NERR_IO, "Unable to open defn %s", name);
}
/* Read Version string */
if (fgets (line, sizeof(line), fp) == NULL)
{
fclose(fp);
return nerr_raise_errno (NERR_IO, "Unable to read defn %s", name);
}
string_rstrip(line);
if (!strcmp(line, DEFN_VERSION_1))
{
err = wdb_load_defn_v1(wdb, fp);
fclose(fp);
if (err) return nerr_pass(err);
}
else
{
fclose(fp);
return nerr_raise (NERR_ASSERT, "Unknown defn version %s: %s", line, name);
}
wdb->table_version = rand();
return STATUS_OK;
}
static NEOERR *wdb_load_defn_v1 (WDB *wdb, FILE *fp)
{
char line[1024];
int state = 1;
char *k, *v;
NEOERR *err = STATUS_OK;
int colindex = 1;
WDBColumn *col;
while (fgets(line, sizeof(line), fp) != NULL)
{
string_rstrip(line);
switch (state)
{
case STATE_REQUIRED:
if (!strcmp(line, "attributes"))
state = STATE_ATTRIBUTES;
else if (!strcmp(line, "columns"))
state = STATE_COLUMN_DEF;
else
{
k = line;
v = strchr(line, ':');
/* HACK */
if (!strcmp(k, "name") && ((v == NULL) || (v[1] == '\0')))
{
v = "dNone";
}
else
{
if (v == NULL)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
if (v[1] == '\0')
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
}
v[0] = '\0';
v++;
if (!strcmp(k, "key"))
{
err = wdb_decode_str_alloc (v, &(wdb->key));
if (err) return nerr_pass(err);
}
else if (!strcmp(k, "name"))
{
err = wdb_decode_str_alloc (v, &(wdb->name));
if (err) return nerr_pass(err);
}
else if (!strcmp(k, "ondisk"))
{
wdb->last_ondisk = atoi (v);
}
}
break;
case STATE_ATTRIBUTES:
if (!strcmp(line, "columns"))
state = STATE_COLUMN_DEF;
else
{
k = line;
v = strchr(line, ':');
if (v == NULL)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
v[0] = '\0';
v++;
err = wdb_decode_str_alloc (k, &k);
if (err) return nerr_pass(err);
err = wdb_decode_str_alloc (v, &v);
if (err) return nerr_pass(err);
err = dictSetValue(wdb->attrs, k, v);
free(k);
if (err)
return nerr_pass_ctx(err, "Error parsing %s", line);
}
break;
case STATE_COLUMN_DEF:
k = line;
v = strchr(line, ':');
if (v == NULL)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
if (v[1] == '\0')
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
v[0] = '\0';
v++;
err = wdb_decode_str_alloc (k, &k);
if (err) return nerr_pass(err);
col = (WDBColumn *) calloc (1, sizeof (WDBColumn));
col->name = k;
col->inmem_index = colindex++;
col->type = *v;
v+=2;
col->ondisk_index = atoi(v);
err = dictSetValue(wdb->cols, k, col);
if (err)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
err = uListAppend(wdb->cols_l, col);
if (err) return nerr_pass(err);
/* stupid skiplist will assert */
if (col->ondisk_index == 0)
{
return nerr_raise (NERR_ASSERT, "Invalid ondisk mapping for %s", k);
}
err = skipInsert (wdb->ondisk, col->ondisk_index,
(void *)(col->inmem_index), 0);
if (err)
return nerr_pass_ctx(err, "Unable to update ondisk mapping for %s", k);
break;
default:
return nerr_raise (NERR_ASSERT, "Invalid state %d", state);
}
}
return STATUS_OK;
}
/* TCP ACCEPT後の処理 */
static void
rpc_accept_main(int sd, short event, void *info) {
tcp_accept_info_t *acceptinfo = info;
struct rpc *rpc = acceptinfo->args;
FILE *sp = acceptinfo->accept_sp;
char buffer[128] = "";
if (event == EV_READ) {
if (fgets(buffer, sizeof(buffer), sp) == NULL) {
tcp_server_accept_clear(acceptinfo);
return;
}
if (string_rstrip(buffer, "\r\n \t")) {
fprintf(sp, RESPONSE_INTERNAL_ERROR);
goto end;
}
if (strncmp(
buffer,
COMMAND_STOP_MONITOR,
sizeof(COMMAND_STOP_MONITOR) - 1) == 0 ) {
alert_cancel(rpc->alert);
sensor_monitor_stop(rpc->sensor);
fprintf(sp, RESPONSE_OK);
} else if (strncmp(
buffer,
COMMAND_START_MONITOR,
sizeof(COMMAND_START_MONITOR) - 1) == 0 ) {
sensor_monitor_start(rpc->sensor);
fprintf(sp, RESPONSE_OK);
} else if (strncmp(
buffer,
COMMAND_GET_MONITOR_STATUS,
sizeof(COMMAND_GET_MONITOR_STATUS) - 1) == 0 ) {
if (sensor_get_monitor_status(rpc->sensor)) {
fprintf(sp, RESPONSE_RUNNING);
} else {
fprintf(sp, RESPONSE_STOPPING);
}
} else if (strncmp(
buffer,
COMMAND_CANCEL_ALERT,
sizeof(COMMAND_CANCEL_ALERT) - 1) == 0 ) {
alert_cancel(rpc->alert);
fprintf(sp, RESPONSE_OK);
} else if (strncmp(
buffer,
COMMAND_GET_ALERT_STATUS,
sizeof(COMMAND_GET_ALERT_STATUS) - 1) == 0 ) {
switch (alert_get_status(rpc->alert)) {
case ALERT_STATUS_NO_ALERT:
fprintf(sp, RESPONSE_GOOD);
break;
case ALERT_STATUS_FIRST_ALERT:
fprintf(sp, RESPONSE_FIRST_ALERT);
break;
case ALERT_STATUS_SECOND_ALERT:
fprintf(sp, RESPONSE_SECOND_ALERT);
break;
default:
ABORT();
/* NOT REACHED */
}
} else if (strncmp(buffer,
COMMAND_CLEAR_ALERT_STATUS,
sizeof(COMMAND_CLEAR_ALERT_STATUS) - 1) == 0 ) {
alert_clear_status(rpc->alert);
fprintf(sp, RESPONSE_OK);
} else {
fprintf(stderr, "rpc unknown command.\n");
fprintf(sp, RESPONSE_UNKNOWN_COMMAND);
}
} else if (event == EV_TIMEOUT) {
fprintf(stderr, "rpc timeout.\n");
fprintf(sp, RESPONSE_TIMEOUT);
} else {
ABORT();
/* NOT REACHED */
}
end:
fflush(sp);
tcp_server_accept_clear(acceptinfo);
return;
}
