static int
se_schedule(sescheduler *s, setask *task, seworker *w)
{
ss_trace(&w->trace, "%s", "schedule");
si_planinit(&task->plan);
uint64_t now = ss_utime();
se *e = (se*)s->env;
sedb *db;
srzone *zone = se_zoneof(e);
assert(zone != NULL);
task->checkpoint_complete = 0;
task->backup_complete = 0;
task->rotate = 0;
task->req = 0;
task->gc = 0;
task->db = NULL;
ss_mutexlock(&s->lock);
/* asynchronous reqs dispatcher */
if (s->req == 0) {
switch (zone->async) {
case 2:
if (se_reqqueue(e) == 0)
break;
case 1:
s->req = 1;
task->req = zone->async;
ss_mutexunlock(&s->lock);
return 0;
}
}
/* log gc and rotation */
if (s->rotate == 0)
{
task->rotate = 1;
s->rotate = 1;
}
/* checkpoint */
int in_progress = 0;
int rc;
checkpoint:
if (s->checkpoint) {
task->plan.plan = SI_CHECKPOINT;
task->plan.a = s->checkpoint_lsn;
rc = se_schedule_plan(s, &task->plan, &db);
switch (rc) {
case 1:
s->workers_branch++;
se_dbref(db, 1);
task->db = db;
task->gc = 1;
ss_mutexunlock(&s->lock);
return 1;
case 2: /* work in progress */
in_progress = 1;
break;
case 0: /* complete checkpoint */
s->checkpoint = 0;
s->checkpoint_lsn_last = s->checkpoint_lsn;
s->checkpoint_lsn = 0;
task->checkpoint_complete = 1;
break;
}
}
/* apply zone policy */
switch (zone->mode) {
case 0: /* compact_index */
case 1: /* compact_index + branch_count prio */
assert(0);
break;
case 2: /* checkpoint */
{
if (in_progress) {
ss_mutexunlock(&s->lock);
return 0;
}
uint64_t lsn = sr_seq(&e->seq, SR_LSN);
s->checkpoint_lsn = lsn;
s->checkpoint = 1;
goto checkpoint;
}
default: /* branch + compact */
assert(zone->mode == 3);
}
/* database shutdown-drop */
if (s->workers_gc_db < zone->gc_db_prio) {
ss_spinlock(&e->dblock);
db = NULL;
if (ssunlikely(e->db_shutdown.n > 0)) {
db = (sedb*)so_listfirst(&e->db_shutdown);
if (se_dbgarbage(db)) {
so_listdel(&e->db_shutdown, &db->o);
} else {
db = NULL;
}
}
ss_spinunlock(&e->dblock);
if (ssunlikely(db)) {
if (db->dropped)
task->plan.plan = SI_DROP;
else
task->plan.plan = SI_SHUTDOWN;
s->workers_gc_db++;
se_dbref(db, 1);
task->db = db;
ss_mutexunlock(&s->lock);
return 1;
}
}
/* backup */
if (s->backup && (s->workers_backup < zone->backup_prio))
{
/* backup procedure.
*
* state 0 (start)
* -------
*
* a. disable log gc
* b. mark to start backup (state 1)
*
* state 1 (background, delayed start)
* -------
*
* a. create backup_path/<bsn.incomplete> directory
* b. create database directories
* c. create log directory
* d. state 2
*
* state 2 (background, copy)
* -------
*
* a. schedule and execute node backup which bsn < backup_bsn
* b. state 3
*
* state 3 (background, completion)
* -------
*
* a. rotate log file
* b. copy log files
* c. enable log gc, schedule gc
* d. rename <bsn.incomplete> into <bsn>
* e. set last backup, set COMPLETE
*
*/
if (s->backup == 1) {
/* state 1 */
rc = se_backupstart(s);
if (ssunlikely(rc == -1)) {
se_backuperror(s);
goto backup_error;
}
s->backup = 2;
}
/* state 2 */
task->plan.plan = SI_BACKUP;
task->plan.a = s->backup_bsn;
rc = se_schedule_plan(s, &task->plan, &db);
switch (rc) {
case 1:
s->workers_backup++;
se_dbref(db, 1);
task->db = db;
ss_mutexunlock(&s->lock);
return 1;
case 2: /* work in progress */
break;
case 0: /* state 3 */
rc = se_backupcomplete(s, w);
if (ssunlikely(rc == -1)) {
se_backuperror(s);
goto backup_error;
}
s->backup_events++;
task->gc = 1;
task->backup_complete = 1;
break;
}
backup_error:;
}
/* garbage-collection */
if (s->gc) {
if (s->workers_gc < zone->gc_prio) {
task->plan.plan = SI_GC;
task->plan.a = sx_vlsn(&e->xm);
task->plan.b = zone->gc_wm;
rc = se_schedule_plan(s, &task->plan, &db);
switch (rc) {
case 1:
s->workers_gc++;
se_dbref(db, 1);
task->db = db;
ss_mutexunlock(&s->lock);
return 1;
case 2: /* work in progress */
break;
case 0: /* state 3 */
s->gc = 0;
s->gc_last = now;
break;
}
}
} else {
if (zone->gc_prio && zone->gc_period) {
if ( (now - s->gc_last) >= ((uint64_t)zone->gc_period * 1000000) ) {
s->gc = 1;
}
}
}
/* index aging */
if (s->age) {
if (s->workers_branch < zone->branch_prio) {
task->plan.plan = SI_AGE;
task->plan.a = zone->branch_age * 1000000; /* ms */
task->plan.b = zone->branch_age_wm;
rc = se_schedule_plan(s, &task->plan, &db);
switch (rc) {
case 1:
s->workers_branch++;
se_dbref(db, 1);
task->db = db;
ss_mutexunlock(&s->lock);
return 1;
case 0:
s->age = 0;
s->age_last = now;
break;
}
}
} else {
if (zone->branch_prio && zone->branch_age_period) {
if ( (now - s->age_last) >= ((uint64_t)zone->branch_age_period * 1000000) ) {
s->age = 1;
}
}
}
/* branching */
if (s->workers_branch < zone->branch_prio)
{
/* schedule branch task using following
* priority:
*
* a. peek node with the largest in-memory index
* which is equal or greater then branch
* watermark.
* If nothing is found, stick to b.
*
* b. peek node with the largest in-memory index,
* which has oldest update time.
*
* c. if no branch work is needed, schedule a
* compaction job
*
*/
task->plan.plan = SI_BRANCH;
task->plan.a = zone->branch_wm;
rc = se_schedule_plan(s, &task->plan, &db);
if (rc == 1) {
s->workers_branch++;
se_dbref(db, 1);
task->db = db;
task->gc = 1;
ss_mutexunlock(&s->lock);
return 1;
}
}
/* compaction */
task->plan.plan = SI_COMPACT;
task->plan.a = zone->compact_wm;
task->plan.b = zone->compact_mode;
rc = se_schedule_plan(s, &task->plan, &db);
if (rc == 1) {
se_dbref(db, 1);
task->db = db;
ss_mutexunlock(&s->lock);
return 1;
}
ss_mutexunlock(&s->lock);
return 0;
}
static int
se_dbscheme_set(sedb *db)
{
se *e = se_of(&db->o);
sischeme *s = &db->scheme;
/* storage */
if (strcmp(s->storage_sz, "cache") == 0) {
s->storage = SI_SCACHE;
} else
if (strcmp(s->storage_sz, "anti-cache") == 0) {
s->storage = SI_SANTI_CACHE;
} else
if (strcmp(s->storage_sz, "in-memory") == 0) {
s->storage = SI_SIN_MEMORY;
} else {
sr_error(&e->error, "unknown storage type '%s'", s->storage_sz);
return -1;
}
/* format */
if (strcmp(s->fmt_sz, "kv") == 0) {
s->fmt = SF_KV;
} else
if (strcmp(s->fmt_sz, "document") == 0) {
s->fmt = SF_DOCUMENT;
} else {
sr_error(&e->error, "unknown format type '%s'", s->fmt_sz);
return -1;
}
/* upsert and format */
if (sf_upserthas(&s->fmt_upsert)) {
if (s->fmt == SF_DOCUMENT) {
sr_error(&e->error, "%s", "incompatible options: format=document "
"and upsert function");
return -1;
}
if (s->cache_mode) {
sr_error(&e->error, "%s", "incompatible options: cache_mode=1 "
"and upsert function");
return -1;
}
}
/* compression_key */
if (s->compression_key) {
if (s->fmt == SF_DOCUMENT) {
sr_error(&e->error, "%s", "incompatible options: format=document "
"and compression_key=1");
return -1;
}
s->fmt_storage = SF_SKEYVALUE;
}
/* compression */
s->compression_if = ss_filterof(s->compression_sz);
if (ssunlikely(s->compression_if == NULL)) {
sr_error(&e->error, "unknown compression type '%s'",
s->compression_sz);
return -1;
}
s->compression = s->compression_if != &ss_nonefilter;
/* compression branch */
s->compression_branch_if = ss_filterof(s->compression_branch_sz);
if (ssunlikely(s->compression_branch_if == NULL)) {
sr_error(&e->error, "unknown compression type '%s'",
s->compression_branch_sz);
return -1;
}
s->compression_branch = s->compression_branch_if != &ss_nonefilter;
/* path */
if (s->path == NULL) {
char path[1024];
snprintf(path, sizeof(path), "%s/%s", e->conf.path, s->name);
s->path = ss_strdup(&e->a, path);
if (ssunlikely(s->path == NULL))
return sr_oom(&e->error);
}
/* backup path */
s->path_backup = e->conf.backup_path;
if (e->conf.backup_path) {
s->path_backup = ss_strdup(&e->a, e->conf.backup_path);
if (ssunlikely(s->path_backup == NULL))
return sr_oom(&e->error);
}
/* cache */
if (s->cache_sz) {
sedb *cache = (sedb*)se_dbmatch(e, s->cache_sz);
if (ssunlikely(cache == NULL)) {
sr_error(&e->error, "could not find cache database '%s'",
s->cache_sz);
return -1;
}
if (ssunlikely(cache == db)) {
sr_error(&e->error, "bad cache database '%s'",
s->cache_sz);
return -1;
}
if (! cache->scheme.cache_mode) {
sr_error(&e->error, "database '%s' is not in cache mode",
s->cache_sz);
return -1;
}
if (! sr_schemeeq(&db->scheme.scheme, &cache->scheme.scheme)) {
sr_error(&e->error, "database and cache '%s' scheme mismatch",
s->cache_sz);
return -1;
}
se_dbref(cache, 0);
db->cache = cache;
}
db->r.scheme = &s->scheme;
db->r.fmt = s->fmt;
db->r.fmt_storage = s->fmt_storage;
db->r.fmt_upsert = &s->fmt_upsert;
return 0;
}