ferret 0.3.2 → 0.9.0

data/ext/filter.c

@@ -0,0 +1,103 @@
+#include <string.h>
+#include "search.h"
+
+/***************************************************************************
+ *
+ * Filter
+ *
+ ***************************************************************************/
+
+void filt_destroy(void *p)
+{
+  Filter *self = (Filter *)p;
+  h_destroy(self->cache);
+  free(self->name);
+  free(self);
+}
+
+BitVector *filt_get_bv(Filter *self, IndexReader *ir)
+{
+  CacheObject *co = h_get(self->cache, ir);
+  if (!co) {
+    BitVector *bv;
+    if (!ir->cache) {
+      ir_add_cache(ir);
+    }
+    bv = self->get_bv(self, ir);
+    co = co_create(self->cache, ir->cache, self, ir,
+        &bv_destroy, (void *)bv);
+  }
+  return (BitVector *)co->obj;
+}
+
+char *filt_to_s(Filter *self)
+{
+  return estrdup(self->name);
+}
+
+Filter *filt_create(char *name)
+{
+  Filter *self = ALLOC(Filter);
+  self->cache = co_hsh_create();
+  self->name = estrdup(name);
+  self->to_s = &filt_to_s;
+  self->destroy = &filt_destroy;
+  return self;
+}
+
+/***************************************************************************
+ *
+ * QueryFilter
+ *
+ ***************************************************************************/
+
+char *qfilt_to_s(Filter *self)
+{
+  QueryFilter *qf = (QueryFilter *)self->data;
+  Query *query = (Query *)qf->query;
+  char *query_str = query->to_s(query, "");
+  char *filter_str = epstrdup("QueryFilter(%s)", strlen(query_str), query_str);
+  free(query_str);
+  return filter_str;
+}
+
+BitVector *qfilt_get_bv(Filter *filt, IndexReader *ir)
+{
+  BitVector *bv = bv_create_size(ir->max_doc(ir));
+  QueryFilter *qfilt = (QueryFilter *)filt->data;
+  Searcher *sea = sea_create(ir);
+  Weight *weight = q_weight(qfilt->query, sea);
+  Scorer *scorer = weight->scorer(weight, ir);
+  if (scorer) {
+    while (scorer->next(scorer)) {
+      bv_set(bv, scorer->doc);
+    }
+    scorer->destroy(scorer);
+  }
+  free(sea);
+  return bv;
+}
+
+void qfilt_destroy(void *p)
+{
+  Filter *filt = (Filter *)p;
+  QueryFilter *qfilt = filt->data;
+  /* caller is responsible for closing the query */
+  /* if (qfilt->query) qfilt->query->destroy(qfilt->query); */
+  free(qfilt);
+  filt_destroy(filt);
+}
+
+Filter *qfilt_create(Query *query)
+{
+  Filter *self;
+  QueryFilter *qfilt = ALLOC(QueryFilter);
+  qfilt->query = query;
+
+  self = filt_create("QueryFilter");
+  self->data = qfilt;
+  self->get_bv = &qfilt_get_bv;
+  self->to_s = &qfilt_to_s;
+  self->destroy = &qfilt_destroy;
+  return self;
+}

data/ext/fs_store.c

@@ -0,0 +1,352 @@
+#include <sys/types.h>
+#include <sys/dir.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include "store.h"
+
+static char *join_path(char *buf, const char *base, const char *filename)
+{
+  strcpy(buf, base);
+  strcat(buf, "/");
+  strcat(buf, filename);
+  return buf;
+}
+
+void fs_touch(Store *store, char *filename)
+{
+  char buf[MAX_PATH];
+  int fd = creat(join_path(buf, store->dir.path, filename), S_IRUSR|S_IWUSR);
+  close(fd);
+}
+
+int fs_exists(Store *store, char *filename)
+{
+  char buf[MAX_PATH];
+  int fd = open(join_path(buf, store->dir.path, filename), 0);
+  if (fd < 0) {
+    assert(errno == ENOENT);
+    return false;
+  }
+  close(fd);
+  return true;
+}
+
+int fs_remove(Store *store, char *filename)
+{
+  char buf[MAX_PATH];
+  return remove(join_path(buf, store->dir.path, filename));
+}
+
+int fs_rename(Store *store, char *from, char *to)
+{
+  char buf1[MAX_PATH], buf2[MAX_PATH];
+  int ret;
+
+  ret = rename(join_path(buf1, store->dir.path, from),
+      join_path(buf2, store->dir.path, to));
+
+  return ret;
+}
+
+int fs_count(Store *store)
+{
+  int cnt = 0;
+  DIR *d = opendir(store->dir.path);
+  struct dirent *de;
+
+  while ((de = readdir(d)) != NULL) {
+    if (de->d_name[0] != '.') {
+      cnt++;
+    }
+  }
+  closedir(d);
+
+  return cnt;
+}
+
+void fs_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
+{
+  DIR *d;
+  struct dirent *de;
+
+  d = opendir(store->dir.path);
+  while ((de = readdir(d)) != NULL) {
+    if ((strncmp(de->d_name, LOCK_PREFIX, strlen(LOCK_PREFIX)) == 0) ||
+        (de->d_name[0] == '.'))
+      continue;
+    func(de->d_name, arg);
+  }
+  closedir(d);
+}
+
+void fs_clear_locks(Store *store)
+{
+  DIR *d;
+  struct dirent *de;
+
+  d = opendir(store->dir.path);
+  while ((de = readdir(d)) != NULL) {
+    if (file_is_lock(de->d_name)) {
+      fs_remove(store, de->d_name);
+    }
+  }
+  closedir(d);
+}
+
+void fs_destroy(void *p)
+{
+  Store *store = (Store *)p;
+  fs_clear_locks(store);
+  free(store->dir.path);
+  store_destroy(store);
+}
+
+void fs_clear(Store *store)
+{
+  DIR *d;
+  struct dirent *de;
+
+  d = opendir(store->dir.path);
+  while ((de = readdir(d)) != NULL) {
+    if (de->d_name[0] != '.' && !file_is_lock(de->d_name)) {
+      fs_remove(store, de->d_name);
+    }
+  }
+  closedir(d);
+}
+
+void fs_clear_all(Store *store)
+{
+  DIR *d;
+  struct dirent *de;
+
+  d = opendir(store->dir.path);
+  while ((de = readdir(d)) != NULL) {
+    if (de->d_name[0] != '.') {
+      fs_remove(store, de->d_name);
+    }
+  }
+  closedir(d);
+}
+
+int fs_length(Store *store, char *filename)
+{
+  char buf[MAX_PATH];
+  struct stat stt;
+  stat(join_path(buf, store->dir.path, filename), &stt);
+  return stt.st_size;
+}
+
+void fso_flush_internal(OutStream *os, uchar *src, int len)
+{
+  fwrite(src, sizeof(uchar), len, (FILE *)os->file);
+}
+
+void fso_seek_internal(OutStream *os, int pos)
+{
+  fseek((FILE *)os->file, pos, SEEK_SET);
+}
+
+void fso_close_internal(OutStream *os)
+{
+  fclose((FILE *)os->file);
+}
+
+OutStream *fs_create_output(Store *store, const char *filename)
+{
+  char buf[MAX_PATH];
+  FILE *f = fopen(join_path(buf, store->dir.path, filename), "wb");
+  if (!f) {
+    eprintf(IO_ERROR, "Couldn't open the file %s to write. Error was %s",
+        buf, strerror(errno));
+  }
+  OutStream *os = os_create();
+  os->file = f;
+  os->flush_internal = &fso_flush_internal;
+  os->seek_internal  = &fso_seek_internal;
+  os->close_internal = &fso_close_internal;
+  return os;
+}
+
+void fsi_read_internal(InStream *is, uchar *b, int offset, int len)
+{
+  int fd = (int)is->file;
+  int pos = is_pos(is);
+  if (pos != lseek(fd, 0, SEEK_CUR)) {
+    lseek(fd, pos, SEEK_SET);
+  }
+  read(fd, b, len);
+}
+
+void fsi_seek_internal(InStream *is, int pos)
+{
+  lseek((int)is->file, pos, SEEK_SET);
+}
+
+void fsi_close_internal(InStream *is)
+{
+  if (!is->is_clone) {
+    close((int)is->file);
+    free(is->d.path);
+  }
+}
+
+void fsi_clone_internal(InStream *is, InStream *new_is)
+{ }
+
+int fsi_length(InStream *is)
+{
+  struct stat stt;
+  fstat((int)is->file, &stt);
+  return stt.st_size;
+}
+
+InStream *fs_open_input(Store *store, const char *filename)
+{
+  char buf[MAX_PATH];
+  int fd = open(join_path(buf, store->dir.path, filename), O_RDONLY);
+  if (fd < 0) {
+    eprintf(IO_ERROR, "Couldn't open the file %s to read", buf);
+  }
+  InStream *is = is_create();
+  is->file = (void *)fd;
+  is->d.path = estrdup(buf);
+  is->is_clone = false;
+  is->read_internal  = &fsi_read_internal;
+  is->seek_internal  = &fsi_seek_internal;
+  is->close_internal = &fsi_close_internal;
+  is->clone_internal = &fsi_clone_internal;
+  is->length_internal= &fsi_length;
+  return is;
+}
+
+#define LOCK_OBTAIN_TIMEOUT 5
+
+int fs_lock_obtain(Lock *lock)
+{
+  int f;
+  int trys = LOCK_OBTAIN_TIMEOUT;
+  while (((f = open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) &&
+        (trys > 0))
+    trys--;
+  if (f >= 0) {
+    close(f);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+int fs_lock_is_locked(Lock *lock)
+{
+  int f = open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
+  if (f >= 0) {
+    close(f);
+    remove(lock->name);
+    return false;
+  } else {
+    return true;
+  }
+}
+
+void fs_lock_release(Lock *lock)
+{
+  remove(lock->name);
+}
+
+Lock *fs_open_lock(Store *store, char *lockname)
+{
+  Lock *lock = ALLOC(Lock);
+  char lname[100];
+  char buf[MAX_PATH];
+  sprintf(lname, "%s%s.lck", LOCK_PREFIX, lockname);
+  lock->name = estrdup(join_path(buf, store->dir.path, lname));
+  lock->obtain = &fs_lock_obtain;
+  lock->release = &fs_lock_release;
+  lock->is_locked = &fs_lock_is_locked;
+  return lock;
+}
+
+void fs_close_lock(Lock *lock)
+{
+  remove(lock->name);
+  free(lock->name);
+  free(lock);
+}
+
+static HshTable stores = {
+  fill:0,
+  used:0,
+  mask:Hsh_MINSIZE - 1,
+  table:stores.smalltable,
+  lookup:&h_lookup_str,
+  hash:NULL,
+  eq:NULL,
+  free_key:dummy_free,
+  free_value:&fs_destroy
+};
+
+#ifndef FERRET_EXT
+static mutex_t stores_mutex = MUTEX_INITIALIZER;
+#endif
+
+void fs_close(Store *store)
+{
+  mutex_lock(&store->mutex);
+  if (--(store->ref_cnt) == 0) {
+    mutex_lock(&stores_mutex);
+    h_del(&stores, store->dir.path);
+    mutex_unlock(&stores_mutex);
+  } else {
+    mutex_unlock(&store->mutex);
+  }
+}
+
+Store *fs_store_create(const char *pathname)
+{
+  Store *new_store = store_create();
+
+  new_store->ref_cnt       = 0;
+  new_store->dir.path      = estrdup(pathname);
+  new_store->touch         = &fs_touch;
+  new_store->exists        = &fs_exists;
+  new_store->remove        = &fs_remove;
+  new_store->rename        = &fs_rename;
+  new_store->count         = &fs_count;
+  new_store->close         = &fs_close;
+  new_store->clear         = &fs_clear;
+  new_store->clear_all     = &fs_clear_all;
+  new_store->clear_locks   = &fs_clear_locks;
+  new_store->length        = &fs_length;
+  new_store->each          = &fs_each;
+  new_store->create_output = &fs_create_output;
+  new_store->open_input    = &fs_open_input;
+  new_store->open_lock     = &fs_open_lock;
+  new_store->close_lock    = &fs_close_lock;
+  return new_store;
+}
+
+Store *open_fs_store(const char *pathname)
+{
+  Store *store = NULL;
+  
+  mutex_lock(&stores_mutex);
+  store = h_get(&stores, pathname);
+  if (!store) {
+    store = fs_store_create(pathname);
+    h_set(&stores, pathname, store);
+  }
+  mutex_unlock(&stores_mutex);
+
+  mutex_lock(&store->mutex);
+  store->ref_cnt++;
+  mutex_unlock(&store->mutex);
+
+  return store;
+}