struct vrt_consumer *
vrt_consumer_new(const char *name, struct vrt_queue *q)
{
struct vrt_consumer *c = cork_new(struct vrt_consumer);
memset(c, 0, sizeof(struct vrt_consumer));
c->name = cork_strdup(name);
cork_array_init(&c->dependencies);
ei_check(vrt_queue_add_consumer(q, c));
c->cursor.value = starting_value;
c->last_available_id = starting_value;
c->current_id = starting_value;
c->eof_count = 0;
c->batch_count = 0;
c->yield_count = 0;
return c;
error:
if (c->name != NULL) {
cork_strfree(c->name);
}
cork_array_done(&c->dependencies);
cork_delete(struct vrt_consumer, c);
return NULL;
}
struct bz_repo *
bz_git_repo_new(const char *url, const char *commit)
{
struct bz_git_repo *repo;
struct bz_env *repo_env;
struct cork_path *base_dir;
repo = cork_new(struct bz_git_repo);
cork_buffer_init(&repo->slug);
repo->url = cork_strdup(url);
repo->commit = cork_strdup(commit);
bz_git_make_slug(&repo->slug, url, commit);
repo_env = bz_repo_env_new_empty();
bz_env_add_override
(repo_env, "repo.git.url", bz_string_value_new(url));
bz_env_add_override
(repo_env, "repo.git.commit", bz_string_value_new(commit));
bz_env_add_override
(repo_env, "repo.name",
bz_interpolated_value_new("${repo.git.url} (${repo.git.commit})"));
bz_env_add_override
(repo_env, "repo.slug", bz_string_value_new(repo->slug.buf));
bz_env_add_override
(repo_env, "repo.base_dir",
bz_interpolated_value_new("${repo_dir}/${repo.slug}"));
bz_env_add_override
(repo_env, "package_slug",
bz_interpolated_value_new("${name}-${repo.slug}"));
repo->repo = bz_repo_new
(repo_env, repo, bz_git__free,
bz_git__load,
bz_git__update);
ep_check(base_dir = bz_env_get_path(repo_env, "repo.base_dir", true));
bz_env_set_base_path(repo_env, cork_path_get(base_dir));
return repo->repo;
error:
bz_repo_free(repo->repo);
return NULL;
}
struct vrt_producer *
vrt_producer_new(const char *name, unsigned int batch_size,
struct vrt_queue *q)
{
struct vrt_producer *p;
unsigned int maximum_batch_size;
p = cork_new(struct vrt_producer);
memset(p, 0, sizeof(struct vrt_producer));
p->name = cork_strdup(name);
ei_check(vrt_queue_add_producer(q, p));
if (batch_size == 0) {
batch_size = DEFAULT_BATCH_SIZE;
}
maximum_batch_size = vrt_queue_size(q) / 4;
if (batch_size > maximum_batch_size) {
batch_size = maximum_batch_size;
}
clog_trace("<%s> Batch size is %u", name, batch_size);
p->last_produced_id = starting_value;
p->last_claimed_id = starting_value;
p->batch_size = batch_size;
p->yield = NULL;
p->batch_count = 0;
p->yield_count = 0;
return p;
error:
if (p->name != NULL) {
cork_strfree(p->name);
}
cork_delete(struct vrt_producer, p);
return NULL;
}
struct vrt_queue *
vrt_queue_new(const char *name, struct vrt_value_type *value_type,
unsigned int size)
{
struct vrt_queue *q = cork_new(struct vrt_queue);
memset(q, 0, sizeof(struct vrt_queue));
q->name = cork_strdup(name);
unsigned int value_count;
if (size == 0) {
value_count = DEFAULT_QUEUE_SIZE;
} else {
if (size < MINIMUM_QUEUE_SIZE) {
size = MINIMUM_QUEUE_SIZE;
}
value_count = min_power_of_2(size);
}
q->value_mask = value_count - 1;
q->last_consumed_id = starting_value;
q->last_claimed_id.value = q->last_consumed_id;
q->cursor.value = q->last_consumed_id;
q->value_type = value_type;
q->values = cork_calloc(value_count, sizeof(struct vrt_value *));
clog_debug("[%s] Create queue with %u entries", q->name, value_count);
cork_pointer_array_init(&q->producers, (cork_free_f) vrt_producer_free);
cork_pointer_array_init(&q->consumers, (cork_free_f) vrt_consumer_free);
unsigned int i;
for (i = 0; i < value_count; i++) {
q->values[i] = vrt_value_new(value_type);
cork_abort_if_null(q->values[i], "Cannot allocate values");
}
return q;
}
