1

     2

/*

     3

 * A simple PostgreSQL-based filesystem.

     4

 */

     5

     6

#include <string.h>

     7

#include <errno.h>

     8

     9

#include <event2/event.h>

    10

    11

#include "evfuse.h"

    12

#include "evsql.h"

    13

#include "dirbuf.h"

    14

#include "lib/log.h"

    15

#include "lib/signals.h"

    16

#include "lib/misc.h"

    17

    18

#define SERROR(val) do { (val); goto error; } while(0)

    19

    20

struct dbfs {

    21

    struct event_base *ev_base;

    22

    struct signals *signals;

    23

    24

    const char *db_conninfo;

    25

    struct evsql *db;

    26

    27

    struct evfuse *ev_fuse;

    28

};

    29

    30

#define CONNINFO_DEFAULT "dbname=test"

    31

    32

// XXX: not sure how this should work

    33

#define CACHE_TIMEOUT 1.0

    34

    35

mode_t _dbfs_mode (const char *type) {

    36

    if (!strcmp(type, "DIR"))

    37

        return S_IFDIR;

    38

    39

    if (!strcmp(type, "REG"))

    40

        return S_IFREG;

    41

    42

    else {

    43

        WARNING("[dbfs] weird mode-type: %s", type);

    44

        return 0;

    45

    }

    46

}

    47

    48

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

    49

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

    50

    51

}

    52

    53

void dbfs_destroy (void *userdata) {

    54

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

    55

    56

    57

}

    58

   126

void _dbfs_lookup_result (const struct evsql_result_info *res, void *arg) {

   127

    struct fuse_req *req = arg;

   128

    struct fuse_entry_param e; ZINIT(e);

   129

    int err = 0;

   130

   131

    uint32_t ino;

   132

   136

   137

    // get the data

   138

    if (0

   139

        ||  evsql_result_uint32(res, 0, 0, &ino,        0 ) // inodes.ino

   140

    )

   141

        EERROR(err = EIO, "invalid db data");

   144

   148

   150

    e.ino = e.attr.st_ino = ino;

   151

    e.attr_timeout = CACHE_TIMEOUT;

   152

    e.entry_timeout = CACHE_TIMEOUT;

   153

   154

    // reply

   155

    if ((err = fuse_reply_entry(req, &e)))

   156

        EERROR(err, "fuse_reply_entry");

   157

   158

error:

   159

    if (err && (err = fuse_reply_err(req, err)))

   160

        EWARNING(err, "fuse_reply_err");

   161

   162

    // free

   163

    evsql_result_free(res);

   164

}

   165

   166

void dbfs_lookup (struct fuse_req *req, fuse_ino_t parent, const char *name) {

   167

    struct dbfs *ctx = fuse_req_userdata(req);

   168

    int err;

   169

   170

    INFO("[dbfs.lookup] parent=%lu name=%s", parent, name);

   171

   172

    // query and params

   173

    const char *sql = 

   174

        "SELECT"

   175

        " inodes.ino, inodes.type, inodes.mode, inodes.size, count(*)"

   176

        " FROM file_tree INNER JOIN inodes ON (file_tree.inode = inodes.ino)"

   178

        " GROUP BY inodes.ino, inodes.type, inodes.mode, inodes.size";

   179

   180

    static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   181

        EVSQL_PARAM ( UINT32 ),

   182

        EVSQL_PARAM ( STRING ),

   183

   184

        EVSQL_PARAMS_END

   185

    };

   186

   187

    // build params

   188

    if (0

   189

        ||  evsql_param_uint32(&params, 0, parent)

   190

        ||  evsql_param_string(&params, 1, name)

   191

    )

   192

        EERROR(err = EIO, "evsql_param_*");

   193

   194

    // query

   196

        EERROR(err = EIO, "evsql_query_params");

   197

   198

    // XXX: handle interrupts

   199

   200

    // wait

   201

    return;

   202

   203

error:

   204

    if ((err = fuse_reply_err(req, err)))

   205

        EWARNING(err, "fuse_reply_err");

   206

}

   207

   279

struct fuse_lowlevel_ops dbfs_llops = {

   281

    .init           = dbfs_init,

   282

    .destroy        = dbfs_destroy,

   283

   284

    .lookup         = dbfs_lookup,

   287

};

   288

   289

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

   290

    struct dbfs *ctx = arg;

   291

   292

    // AAAAAAAAAA.... panic

   293

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

   294

   295

    event_base_loopbreak(ctx->ev_base);

   296

}

   297

   298

int main (int argc, char **argv) {

   299

    struct fuse_args fuse_args = FUSE_ARGS_INIT(argc, argv);

   300

    struct dbfs ctx; ZINIT(ctx);

   301

   302

    // parse args, XXX: fuse_args

   303

    ctx.db_conninfo = CONNINFO_DEFAULT;

   304

   305

    // init libevent

   306

    if ((ctx.ev_base = event_base_new()) == NULL)

   307

        ERROR("event_base_new");

   308

   309

    // setup signals

   310

    if ((ctx.signals = signals_default(ctx.ev_base)) == NULL)

   311

        ERROR("signals_default");

   312

   313

    // open sql

   314

    if ((ctx.db = evsql_new_pq(ctx.ev_base, ctx.db_conninfo, dbfs_sql_error, &ctx)) == NULL)

   315

        ERROR("evsql_new_pq");

   316

   317

    // open fuse

   318

    if ((ctx.ev_fuse = evfuse_new(ctx.ev_base, &fuse_args, &dbfs_llops, &ctx)) == NULL)

   319

        ERROR("evfuse_new");

   320

   321

    // run libevent

   322

    INFO("running libevent loop");

   323

   324

    if (event_base_dispatch(ctx.ev_base))

   325

        PERROR("event_base_dispatch");

   326

   327

    // clean shutdown

   328

   329

error :

   330

    // cleanup

   331

    if (ctx.ev_fuse)

   332

        evfuse_close(ctx.ev_fuse);

   333

   334

    // XXX: ctx.db

   335

   336

    if (ctx.signals)

   337

        signals_free(ctx.signals);

   338

   339

    if (ctx.ev_base)

   340

        event_base_free(ctx.ev_base);

   341

   342

    fuse_opt_free_args(&fuse_args);

   343

}

   344