1

#include <unistd.h>

     2

#include <stdio.h>

     3

#include <string.h>

     4

#include <stdlib.h>

     5

#include <assert.h>

     6

     7

#include "cache.h"

     8

#include "cache_engines.h"

     9

#include "common.h"

    10

    11

#define LINE_LENGTH 1024

    12

#define REQ_COUNT 8

    13

    14

static struct cache *cache = NULL;

    15

static struct cache_engine *fs_engine = NULL;

    16

static struct cache_req_ctx {

    17

    struct cache_req *req;

    18

    int index;

    19

    20

    int pipe_read;

    21

    int pipe_write;

    22

    23

} req_list[REQ_COUNT];

    24

static int quit = 0;

    25

    26

void usage (char *argv_0) {

    27

    err_exit("Usage: %s [-h] <cache_dir>", argv_0);

    28

}

    29

    30

const char *cache_state_str (enum cache_req_state state) {

    31

    switch (state) {

    32

        case CACHE_STATE_INVALID:       return "INVALID";

    33

    34

        case CACHE_STATE_LOOKUP:        return "LOOKUP";

    35

        case CACHE_STATE_HIT:           return "HIT";

    36

        case CACHE_STATE_MISS:          return "MISS";

    37

    38

        case CACHE_STATE_OPEN_READ:     return "OPEN_READ";

    39

        case CACHE_STATE_READ:          return "READ";

    40

    41

        case CACHE_STATE_OPEN_WRITE:    return "OPEN_WRITE";

    42

        case CACHE_STATE_WRITE:         return "WRITE";

    43

        case CACHE_STATE_WRITE_PAUSE:   return "WRITE_PAUSE";

    44

    45

        case CACHE_STATE_ERROR:         return "ERROR";

    46

        default:                        return "???";

    47

    }

    48

}

    49

/*

    50

const char *cache_event_str (enum cache_req_event event) {

    51

    switch (event) {

    52

        case CACHE_EVENT_HIT:           return "HIT";

    53

        case CACHE_EVENT_MISS:          return "MISS";

    54

        case CACHE_EVENT_BEGIN_WRITE:   return "BEGIN_WRITE";

    55

        case CACHE_EVENT_BEGIN_READ:    return "BEGIN_READ";

    56

        case CACHE_EVENT_PAUSE_WRITE:   return "PAUSE_WRITE";

    57

        case CACHE_EVENT_RESUME_WRITE:  return "RESUME_WRITE";

    58

        case CACHE_EVENT_DATA_AVAILABLE:return "DATA_AVAILABLE";

    59

        case CACHE_EVENT_DONE:          return "DONE";

    60

        case CACHE_EVENT_ERROR:         return "ERROR";

    61

        default:                        return "???";

    62

    }

    63

}

    64

*/

    65

    66

//int cache_cb (struct cache_req *req, enum cache_req_event event, void *arg) {

    67

int cache_cb (struct cache_req *req, void *arg) {

    68

    struct cache_req_ctx *ctx = arg;

    69

    70

    const struct cache_key *key = cache_req_key(ctx->req);

    71

    72

    INFO("Request %d (%*s) event: state = %s", 

    73

        ctx->index, 

    74

        (int) key->length, key->buf, 

    75

        cache_state_str(cache_req_state(req))

    76

   );

    77

    78

    return 0;

    79

}

    80

    81

void cmd_help (int index, char *cmd_name);

    82

void cmd_quit (int index, char *cmd_name);

    83

void cmd_req (int index, char *key_buf);

    84

void cmd_status (int index, char *key);

    85

void cmd_available (int index, char *unused);

    86

void cmd_read (int index, char *unused);

    87

void cmd_write (int index, char *unused);

    88

void cmd_push (int index, char *data);

    89

void cmd_pull (int index, char *unused);

    90

void cmd_done (int index, char *unused);

    91

void cmd_release (int index, char *unused);

    92

    93

struct cmd {

    94

    char *name;

    95

    void (*func)(int index, char *str);

    96

    char *usage;

    97

    98

} _commands[] = {

    99

    {   "quit",     &cmd_quit,      "quit"                      },

   100

    {   "help",     &cmd_help,      "help [<ignored> <cmd>]"    },

   101

    {   "req",      &cmd_req,       "req <req_id> <key>"        },

   102

    {   "status",   &cmd_status,    "status <req_id>"           },

   103

    {   "available",&cmd_available, "available <req_id>"        },

   104

    {   "read",     &cmd_read,      "read <req_id>"             },

   105

    {   "write",    &cmd_write,     "write <req_id> [<size_hint>]"  },

   106

    {   "push",     &cmd_push,      "push <req_id> <data>"      },

   107

    {   "pull",     &cmd_pull,      "pull <req_id>"             },

   108

    {   "done",     &cmd_done,      "done <req_id>"             },

   109

    {   "release",  &cmd_release,   "release <req_id>"          },

   110

    {   NULL,       NULL,           NULL                        }

   111

};

   112

   113

   114

void cmd_help (int index, char *cmd_name) {

   115

    struct cmd *cmd;

   116

   117

    if (cmd_name == NULL) {

   118

        printf("Available commands: ");

   119

   120

        for (cmd = _commands; cmd->func != NULL; cmd++) {

   121

            printf("%s ", cmd->name);

   122

        }

   123

   124

        printf("\n");

   125

   126

    } else {

   127

        for (cmd = _commands; cmd->func != NULL; cmd++) {

   128

            if (strcmp(cmd->name, cmd_name) == 0)

   129

                break;

   130

        }

   131

   132

        if (cmd->func) {

   133

            INFO("%s", cmd->usage);

   134

   135

        } else {

   136

            ERROR("Unknown command: '%s'", cmd_name);

   137

        }

   138

    }

   139

   140

error:

   141

    return;

   142

}

   143

   144

void cmd_quit (int index, char *cmd_name) {

   145

    quit = 1;

   146

}

   147

   148

void cmd_req (int index, char *key_buf) {

   149

    struct cache_key key;

   150

   151

    if (index < 0 || index >= REQ_COUNT)

   152

        ERROR("index is out of range");

   153

   154

    if (!key_buf)

   155

        ERROR("No key given");

   156

   157

    key.buf = key_buf;

   158

    key.length = 0;

   159

   160

    if ((req_list[index].req = cache_req(cache, &key, &cache_cb, &req_list[index])) == NULL)

   161

        ERROR("req_list failed");

   162

   163

    INFO("Request opened: %s", cache_state_str(cache_req_state(req_list[index].req)));

   164

   165

error:

   166

    return;

   167

}

   168

   169

void cmd_status (int index, char *unused) {

   170

    const struct cache_key *key;

   171

   172

    if (index < 0 || index >= REQ_COUNT)

   173

        ERROR("index is out of range");

   174

   175

    if (unused)

   176

        ERROR("Too many arguments");

   177

   178

    key = cache_req_key(req_list[index].req);

   179

   180

    INFO("Request %d (%*s) status: %s", index, (int) key->length, key->buf, cache_state_str(cache_req_state(req_list[index].req)));

   181

   182

error:

   183

    return;

   184

   185

}

   186

   187

void cmd_available (int index, char *unused) {

   188

    const struct cache_key *key;

   189

    size_t size, offset, available;

   190

   191

    if (index < 0 || index >= REQ_COUNT)

   192

        ERROR("index is out of range");

   193

   194

    if (unused)

   195

        ERROR("Too many arguments");

   196

   197

    key = cache_req_key(req_list[index].req);

   198

   199

    if (cache_req_available(req_list[index].req, &size, &offset, &available))

   200

        ERROR("cache_req_available failed");

   201

   202

    INFO("Request %d (%*s) available: %zu/%zu, %zu to read", 

   203

        index, 

   204

        (int) key->length, key->buf, 

   205

        offset, size, available

   206

    );

   207

   208

error:

   209

    return;

   210

   211

}

   212

   213

void cmd_read (int index, char *unused) {

   214

    const struct cache_key *key;

   215

   216

    if (index < 0 || index >= REQ_COUNT)

   217

        ERROR("index is out of range");

   218

   219

    key = cache_req_key(req_list[index].req);

   220

   221

    INFO("Request %d (%*s): beginning read", 

   222

        index, (int) key->length, key->buf

   223

    );

   224

   225

    if (cache_req_begin_read(req_list[index].req))

   226

        ERROR("cache_req_begin_read failed");

   227

   228

error:

   229

    return;

   230

}

   231

   232

void cmd_write (int index, char *hint_str) {

   233

    size_t hint;

   234

   235

    const struct cache_key *key;

   236

   237

    if (index < 0 || index >= REQ_COUNT)

   238

        ERROR("index is out of range");

   239

   240

    if (hint_str)

   241

        hint = atoi(hint_str);

   242

    else

   243

        hint = 0;

   244

   245

    key = cache_req_key(req_list[index].req);

   246

   247

    INFO("Request %d (%*s): beginning write", 

   248

        index, (int) key->length, key->buf

   249

    );

   250

   251

    if (cache_req_begin_write(req_list[index].req, hint))

   252

        ERROR("cache_req_begin_write failed");

   253

   254

error:

   255

    return;

   256

}

   257

   258

void cmd_push (int index, char *data) {

   259

    size_t data_length, length;

   260

    const struct cache_key *key;

   261

   262

    data_length = data ? strlen(data) : 0;

   263

   264

    if (data) {

   265

        // write to the pipe

   266

        if ((length = write(req_list[index].pipe_write, data, data_length)) == -1)

   267

            PERROR("write");

   268

   269

        if (length != data_length)

   270

            PWARNING("Only %zu/%zu bytes written to pipe!", length, data_length);

   271

    }

   272

   273

    // unknown size

   274

    length = 0;

   275

   276

    key = cache_req_key(req_list[index].req);

   277

   278

    if (cache_req_push(req_list[index].req, req_list[index].pipe_read, &length))

   279

        ERROR("cache_req_push failed");

   280

   281

    INFO("Request %d (%*s): pushed %zu/%zu bytes", 

   282

        index, (int) key->length, key->buf,

   283

        length, data_length

   284

    );

   285

   286

error:

   287

    return;

   288

}

   289

   290

void cmd_pull (int index, char *unused) {

   291

    size_t data_length, length;

   292

    const struct cache_key *key;

   293

   294

    char buf[LINE_LENGTH];

   295

   296

    // unknown size

   297

    length = 0;

   298

   299

    key = cache_req_key(req_list[index].req);

   300

   301

    if (cache_req_pull(req_list[index].req, req_list[index].pipe_write, &length))

   302

        ERROR("cache_req_pull failed");

   303

   304

    assert(length < LINE_LENGTH);

   305

   306

    // read from the pipe

   307

    if ((data_length = read(req_list[index].pipe_read, buf, length)) == -1)

   308

        PERROR("read");

   309

   310

    // terminate

   311

    buf[data_length] = '\0';

   312

   313

    if (length != data_length)

   314

        PWARNING("Only %zu/%zu bytes read from pipe!", data_length, length);

   315

   316

    INFO("Request %d (%*s): pulled %zu/%zu bytes: %s", 

   317

        index, (int) key->length, key->buf,

   318

        data_length, length,

   319

        buf

   320

    );

   321

   322

error:

   323

    return;

   324

}

   325

   326

void cmd_done (int index, char *unused) {

   327

    const struct cache_key *key;

   328

   329

    key = cache_req_key(req_list[index].req);

   330

   331

    if (cache_req_done(req_list[index].req))

   332

        ERROR("cache_req_done failed");

   333

   334

    INFO("Request %d (%*s): done", 

   335

        index, (int) key->length, key->buf

   336

    );

   337

   338

error:

   339

    return;

   340

}

   341

   342

void cmd_release (int index, char *unused) {

   343

    const struct cache_key *key;

   344

   345

    key = cache_req_key(req_list[index].req);

   346

   347

    cache_req_release(req_list[index].req);

   348

   349

    INFO("Request %d (%*s): released", 

   350

        index, (int) key->length, key->buf

   351

    );

   352

   353

    req_list[index].req = NULL;

   354

}

   355

   356

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

   357

    int pipefds[2];

   358

    char line[LINE_LENGTH];

   359

   360

    // init req_list

   361

    for (int index = 0; index < REQ_COUNT; index++) {

   362

        req_list[index].index = index;

   363

   364

        if (pipe(pipefds))

   365

            PFATAL("pipe");

   366

   367

        req_list[index].pipe_read = pipefds[0];

   368

        req_list[index].pipe_write = pipefds[1];

   369

    }

   370

   371

     // parse arguments

   372

    int opt;

   373

    char *cache_dir;

   374

   375

    while ((opt = getopt(argc, argv, "h")) != -1) {

   376

        switch (opt) {

   377

   378

            case 'h':

   379

            default:

   380

                usage(argv[0]);

   381

        }

   382

    }

   383

   384

    // the cache_dir argument

   385

    if (optind >= argc)

   386

        usage(argv[0]);

   387

   388

    cache_dir = argv[optind];

   389

   390

    // create the fs_engine

   391

    if ((fs_engine = cache_engine_fs(cache_dir)) == NULL)

   392

        FATAL("failed to initialize fs cache engine");

   393

   394

    // create the cache

   395

    if ((cache = cache_open(fs_engine)) == NULL)

   396

        FATAL("failed to open the cache");

   397

   398

    INFO("Filesystem cache opened at '%s'", cache_dir);

   399

   400

    // enter the interactive loop

   401

    do {

   402

        printf(" > ");

   403

   404

   405

        if (fgets(line, LINE_LENGTH, stdin) == NULL)

   406

            quit = 1;

   407

        else {

   408

            char *line_ptr = line;

   409

            char *cmd_name = NULL, *str = NULL, *nl = NULL;

   410

            int index = 0;

   411

   412

            // strip the newline

   413

            if ((nl = strchr(line, '\n')) != NULL)

   414

                *nl = '\0';

   415

   416

            // parse the command/args

   417

            if (line_ptr)

   418

                cmd_name = strsep(&line_ptr, " ");

   419

   420

            if (strlen(cmd_name) == 0)

   421

                cmd_name = NULL;

   422

   423

            if (line_ptr)

   424

                index = atoi(strsep(&line_ptr, " "));

   425

   426

            if (line_ptr)

   427

                str = strsep(&line_ptr, " ");

   428

   429

            if (!cmd_name) {

   430

                continue;

   431

            }

   432

   433

            struct cmd *cmd;

   434

   435

            for (cmd = _commands; cmd->func != NULL; cmd++) {

   436

                if (strcmp(cmd->name, cmd_name) == 0)

   437

                    break;

   438

            }

   439

   440

            if (!cmd->func) {

   441

                INFO("Unknown command");

   442

   443

                continue;

   444

            }

   445

   446

            cmd->func(index, str);

   447

        }

   448

   449

        printf("\n");

   450

   451

    } while (!quit);

   452

   453

    return 0;

   454

}

   455