예제 #1
0
bool
my_fileset_get(
	struct my_fileset *fs,
	size_t i,
	const char **fname_out,
	void **ptr_out)
{
	if (i < entry_vec_size(fs->entries)) {
		*fname_out = entry_vec_value(fs->entries, i)->fname;
		*ptr_out = entry_vec_value(fs->entries, i)->ptr;
		return (true);
	}
	return (false);
}
예제 #2
0
void
my_fileset_destroy(struct my_fileset **fs)
{
	if (*fs != NULL) {
		for (size_t i = 0; i < entry_vec_size((*fs)->entries); i++) {
			struct fileset_entry *ent = entry_vec_value((*fs)->entries, i);
			if ((*fs)->unload)
				(*fs)->unload(*fs, ent->fname, ent->ptr);
			free(ent->fname);
			free(ent);
		}
		entry_vec_destroy(&(*fs)->entries);
		free((*fs)->setdir);
		free((*fs)->setfile);
		free(*fs);
		*fs = NULL;
	}
}
예제 #3
0
파일: sorter.c 프로젝트: code-for-fun/mtbl
void
mtbl_sorter_destroy(struct mtbl_sorter **s)
{
	if (*s) {
		for (unsigned i = 0; i < entry_vec_size((*s)->vec); i++) {
			struct entry *ent = entry_vec_value((*s)->vec, i);
			free(ent);
		}
		entry_vec_destroy(&((*s)->vec));
		for (unsigned i = 0; i < chunk_vec_size((*s)->chunks); i++) {
			struct chunk *c = chunk_vec_value((*s)->chunks, i);
			close(c->fd);
			free(c);
		}
		chunk_vec_destroy(&((*s)->chunks));
		free((*s)->opt.tmp_dname);
		free(*s);
		*s = NULL;
	}
}
예제 #4
0
void
my_fileset_reload(struct my_fileset *fs)
{
	assert(fs != NULL);
	struct fileset_entry *ent, **entptr;
	entry_vec *new_entries;
	FILE *fp;
	char *fname, *line = NULL;
	size_t len = 0;
	ubuf *u;

	if (!setfile_updated(fs))
		return;

	fp = fopen(fs->setfile, "r");
	if (fp == NULL)
		return;

	u = ubuf_init(64);
	new_entries = entry_vec_init(1);

	while (getline(&line, &len, fp) != -1) {
		ubuf_clip(u, 0);
                if (line[0] != '/') { /* if not absolute path, prepend fileset file's path */
                        ubuf_add_cstr(u, fs->setdir);
                        ubuf_add(u, '/');
                }
		ubuf_add_cstr(u, line);
		ubuf_rstrip(u, '\n');
		fname = ubuf_cstr(u);
		if (path_exists(fname)) {
			entptr = fetch_entry(fs->entries, fname);
			if (entptr == NULL) {
				ent = my_calloc(1, sizeof(*ent));
				ent->fname = my_strdup(fname);
				if (fs->load)
					ent->ptr = fs->load(fs, fname);
				entry_vec_add(new_entries, ent);
			} else {
				ent = my_calloc(1, sizeof(*ent));
				ent->fname = my_strdup(fname);
				ent->ptr = (*entptr)->ptr;
				(*entptr)->keep = true;
				entry_vec_add(new_entries, ent);
			}
		}
	}
	free(line);
	fclose(fp);

	qsort(entry_vec_data(new_entries),
	      entry_vec_size(new_entries),
	      sizeof(void *),
	      cmp_fileset_entry);

	for (size_t i = 0; i < entry_vec_size(fs->entries); i++) {
		ent = entry_vec_value(fs->entries, i);
		assert(ent != NULL);
		if (ent->keep == false && fs->unload)
			fs->unload(fs, ent->fname, ent->ptr);
		free(ent->fname);
		free(ent);
	}
	entry_vec_destroy(&fs->entries);
	fs->entries = new_entries;
	ubuf_destroy(&u);
}
예제 #5
0
파일: sorter.c 프로젝트: code-for-fun/mtbl
	ubuf_append(tmp_fname, (const uint8_t *) "\x00", 1);

	c->fd = mkstemp((char *) ubuf_data(tmp_fname));
	assert(c->fd >= 0);
	int unlink_ret = unlink((char *) ubuf_data(tmp_fname));
	assert(unlink_ret == 0);
	ubuf_destroy(&tmp_fname);

	struct mtbl_writer_options *wopt = mtbl_writer_options_init();
	mtbl_writer_options_set_compression(wopt, MTBL_COMPRESSION_SNAPPY);
	struct mtbl_writer *w = mtbl_writer_init_fd(c->fd, wopt);
	mtbl_writer_options_destroy(&wopt);

	size_t entries_written = 0;
	struct entry **array = entry_vec_data(s->vec);
	qsort(array, entry_vec_size(s->vec), sizeof(void *), _mtbl_sorter_compare);
	for (unsigned i = 0; i < entry_vec_size(s->vec); i++) {
		struct entry *ent = entry_vec_value(s->vec, i);

		if (i + 1 < entry_vec_size(s->vec)) {
			struct entry *next_ent = entry_vec_value(s->vec, i + 1);
			struct entry *merge_ent = NULL;

			if (_mtbl_sorter_compare(&ent, &next_ent) == 0) {
				assert(s->opt.merge != NULL);
				uint8_t *merge_val = NULL;
				size_t len_merge_val = 0;
				s->opt.merge(s->opt.merge_clos,
					     entry_key(ent), ent->len_key,
					     entry_val(ent), ent->len_val,
					     entry_val(next_ent), next_ent->len_val,