1

     2

#include <stdlib.h>

     3

     4

#include "dbfs.h"

     5

#include "../dbfs.h"

     6

#include "../lib/log.h"

     7

     8

static struct fuse_lowlevel_ops dbfs_llops = {

     9

    .init           = dbfs_init,

    10

    .destroy        = dbfs_destroy,

    11

    .lookup         = dbfs_lookup,

    12

    // .forget                      // not needed

    13

    .getattr        = dbfs_getattr,

    14

    .setattr        = dbfs_setattr,

    15

    .readlink       = dbfs_readlink,

    16

    .mknod          = dbfs_mknod,

    17

    .mkdir          = dbfs_mkdir,

    18

    .unlink         = dbfs_unlink,

    19

    .rmdir          = dbfs_unlink,  // this behaves just the same

    20

    .symlink        = dbfs_symlink,

    21

    .rename         = dbfs_rename,

    22

    .link           = dbfs_link,

    23

    .open           = dbfs_open,

    24

    .read           = dbfs_read,

    25

    .write          = dbfs_write,

    26

    .flush          = dbfs_flush,

    27

    .release        = dbfs_release,

    28

    // .fsync                       // not needed

    29

    .opendir        = dbfs_opendir,

    30

    .readdir        = dbfs_readdir,

    31

    .releasedir     = dbfs_releasedir,

    32

};

    33

    34

void dbfs_init (void *userdata, struct fuse_conn_info *conn) {

    35

    INFO("[dbfs.init] userdata=%p, conn=%p", userdata, conn);

    36

    37

}

    38

    39

void dbfs_destroy (void *arg) {

    40

    struct dbfs *ctx = arg;

    41

    INFO("[dbfs.destroy %p]", ctx);

    42

    43

    // exit libevent

    44

    event_base_loopexit(ctx->ev_base, NULL);

    45

}

    46

    47

    48

void dbfs_sql_error (struct evsql *evsql, void *arg) {

    49

    struct dbfs *ctx = arg;

    50

    51

    // AAAAAAAAAA.... panic

    52

    WARNING("[dbfs] SQL error: BREAKING MAIN LOOP LIEK NAO");

    53

    54

    event_base_loopbreak(ctx->ev_base);

    55

}

    56

    57

struct dbfs *dbfs_new (struct event_base *ev_base, struct fuse_args *args, const char *db_conninfo) {

    58

    struct dbfs *ctx = NULL;

    59

    60

    // alloc ctx

    61

    if ((ctx = calloc(1, sizeof(*ctx))) == NULL)

    62

        ERROR("calloc");

    63

    64

    ctx->ev_base = ev_base;

    65

    ctx->db_conninfo = db_conninfo;

    66

    67

    // open sql

    68

    if ((ctx->db = evsql_new_pq(ctx->ev_base, ctx->db_conninfo, dbfs_sql_error, ctx)) == NULL)

    69

        ERROR("evsql_new_pq");

    70

    71

    // open fuse

    72

    if ((ctx->ev_fuse = evfuse_new(ctx->ev_base, args, &dbfs_llops, ctx)) == NULL)

    73

        ERROR("evfuse_new");

    74

    75

    // success

    76

    return ctx;

    77

    78

error:

    79

    if (ctx)

    80

        dbfs_free(ctx);

    81

    82

    return NULL;

    83

}    

    84

    85

void dbfs_free (struct dbfs *ctx) {

    86

    // cleanup

    87

    if (ctx->ev_fuse) {

    88

        evfuse_free(ctx->ev_fuse);

    89

    90

        ctx->ev_fuse = NULL;

    91

    }

    92

    93

    if (ctx->db) {

    94

        // XXX: not yet implemented 

    95

        // evsql_close(ctx->db);

    96

        // ctx->db = NULL;

    97

    }

    98

    99

    free(ctx);

   100

}