1

#include <unistd.h>

     2

#include <stdio.h>

     3

#include <string.h>

     4

#include <stdlib.h>

     5

     6

#include "cache.h"

     7

#include "cache_engines.h"

     8

#include "common.h"

     9

    10

#define LINE_LENGTH 1024

    11

#define REQ_COUNT 8

    12

    13

static struct cache *cache = NULL;

    14

static struct cache_engine *fs_engine = NULL;

    15

static struct cache_req_ctx {

    16

    struct cache_req *req;

    17

    int index;

    18

    19

    int pipe_read;

    20

    int pipe_write;

    21

    22

} req_list[REQ_COUNT];

    23

static int quit = 0;

    24

    25

void usage (char *argv_0) {

    26

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

    27

}

    28

    29

const char *cache_state_str (enum cache_req_state state) {

    30

    switch (state) {

    31

        case CACHE_STATE_INVALID:       return "INVALID";

    33

        case CACHE_STATE_LOOKUP:        return "LOOKUP";

    41

        case CACHE_STATE_WRITE:         return "WRITE";

    42

        case CACHE_STATE_WRITE_PAUSE:   return "WRITE_PAUSE";

    44

        case CACHE_STATE_ERROR:         return "ERROR";

    45

        default:                        return "???";

    46

    }

    47

}

    48

/*

    49

const char *cache_event_str (enum cache_req_event event) {

    50

    switch (event) {

    51

        case CACHE_EVENT_HIT:           return "HIT";

    52

        case CACHE_EVENT_MISS:          return "MISS";

    53

        case CACHE_EVENT_BEGIN_WRITE:   return "BEGIN_WRITE";

    54

        case CACHE_EVENT_BEGIN_READ:    return "BEGIN_READ";

    55

        case CACHE_EVENT_PAUSE_WRITE:   return "PAUSE_WRITE";

    56

        case CACHE_EVENT_RESUME_WRITE:  return "RESUME_WRITE";

    57

        case CACHE_EVENT_DATA_AVAILABLE:return "DATA_AVAILABLE";

    58

        case CACHE_EVENT_DONE:          return "DONE";

    59

        case CACHE_EVENT_ERROR:         return "ERROR";

    60

        default:                        return "???";

    61

    }

    62

}

    63

*/

    64

    65

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

    66

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

    67

    struct cache_req_ctx *ctx = arg;

    68

    69

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

    70

    71

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

    72

        ctx->index, 

    73

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

    74

        cache_state_str(cache_req_state(req))

    75

   );

    76

    77

    return 0;

    78

}

    79

    80

void cmd_help (int index, char *cmd_name);

    81

void cmd_quit (int index, char *cmd_name);

    82

void cmd_req (int index, char *key_buf);

    83

void cmd_status (int index, char *key);

    84

void cmd_available (int index, char *unused);

    85

void cmd_write (int index, char *unused);

    86

void cmd_push (int index, char *data);

    87

void cmd_done (int index, char *unused);

    88

void cmd_release (int index, char *unused);

    89

    90

struct cmd {

    91

    char *name;

    92

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

    93

    char *usage;

    94

    95

} _commands[] = {

    96

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

    97

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

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

    {   NULL,       NULL,           NULL                        }

   106

};

   107

   108

   109

void cmd_help (int index, char *cmd_name) {

   110

    struct cmd *cmd;

   111

   112

    if (cmd_name == NULL) {

   113

        printf("Available commands: ");

   114

   115

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

   116

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

   117

        }

   118

   119

        printf("\n");

   120

   121

    } else {

   122

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

   123

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

   124

                break;

   125

        }

   126

   127

        if (cmd->func) {

   128

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

   129

   130

        } else {

   131

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

   132

        }

   133

    }

   134

   135

error:

   136

    return;

   137

}

   138

   139

void cmd_quit (int index, char *cmd_name) {

   140

    quit = 1;

   141

}

   142

   143

void cmd_req (int index, char *key_buf) {

   144

    struct cache_key key;

   145

   146

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

   147

        ERROR("index is out of range");

   148

   149

    if (!key_buf)

   150

        ERROR("No key given");

   151

   152

    key.buf = key_buf;

   153

    key.length = 0;

   154

   155

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

   156

        ERROR("req_list failed");

   157

   158

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

   159

   160

error:

   161

    return;

   162

}

   163

   164

void cmd_status (int index, char *unused) {

   165

    const struct cache_key *key;

   166

   167

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

   168

        ERROR("index is out of range");

   169

   170

    if (unused)

   171

        ERROR("Too many arguments");

   172

   173

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

   174

   175

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

   176

   177

error:

   178

    return;

   179

   180

}

   181

   182

void cmd_available (int index, char *unused) {

   183

    const struct cache_key *key;

   184

    size_t size, offset, available;

   185

   186

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

   187

        ERROR("index is out of range");

   188

   189

    if (unused)

   190

        ERROR("Too many arguments");

   191

   192

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

   193

   194

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

   195

        ERROR("cache_req_available failed");

   196

   197

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

   198

        index, 

   199

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

   200

        offset, size, available

   201

    );

   202

   203

error:

   204

    return;

   205

   206

}

   207

   208

   209

void cmd_write (int index, char *hint_str) {

   210

    size_t hint;

   211

   212

    const struct cache_key *key;

   213

   214

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

   215

        ERROR("index is out of range");

   216

   217

    if (hint_str)

   218

        hint = atoi(hint_str);

   219

    else

   220

        hint = 0;

   221

   222

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

   223

   224

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

   225

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

   226

    );

   227

   228

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

   229

        ERROR("cache_req_begin_write failed");

   230

   231

error:

   232

    return;

   233

}

   234

   235

void cmd_push (int index, char *data) {

   236

    size_t data_length, length;

   237

    const struct cache_key *key;

   238

   239

    data_length = data ? strlen(data) : 0;

   240

   241

    if (data) {

   242

        // write to the pipe

   243

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

   244

            PERROR("write");

   245

   246

        if (length != data_length)

   247

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

   248

    }

   249

   250

    // unknown size

   251

    length = 0;

   252

   253

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

   254

   255

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

   256

        ERROR("cache_req_push failed");

   257

   258

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

   259

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

   260

        length, data_length

   261

    );

   262

   263

error:

   264

    return;

   265

}

   266

   267

void cmd_done (int index, char *unused) {

   268

    const struct cache_key *key;

   269

   270

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

   271

   272

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

   273

        ERROR("cache_req_done failed");

   274

   275

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

   276

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

   277

    );

   278

   279

error:

   280

    return;

   281

}

   282

   283

void cmd_release (int index, char *unused) {

   284

    const struct cache_key *key;

   285

   286

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

   287

   288

    cache_req_release(req_list[index].req);

   289

   290

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

   291

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

   292

    );

   293

   294

    req_list[index].req = NULL;

   295

}

   296

   297

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

   298

    int pipefds[2];

   299

    char line[LINE_LENGTH];

   300

   301

    // init req_list

   302

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

   303

        req_list[index].index = index;

   304

   305

        if (pipe(pipefds))

   306

            PFATAL("pipe");

   307

   308

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

   309

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

   310

    }

   311

   312

     // parse arguments

   313

    int opt;

   314

    char *cache_dir;

   315

   316

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

   317

        switch (opt) {

   318

   319

            case 'h':

   320

            default:

   321

                usage(argv[0]);

   322

        }

   323

    }

   324

   325

    // the cache_dir argument

   326

    if (optind >= argc)

   327

        usage(argv[0]);

   328

   329

    cache_dir = argv[optind];

   330

   331

    // create the fs_engine

   332

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

   333

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

   334

   335

    // create the cache

   336

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

   337

        FATAL("failed to open the cache");

   338

   339

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

   340

   341

    // enter the interactive loop

   342

    do {

   343

        printf(" > ");

   344

   345

   346

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

   347

            quit = 1;

   348

        else {

   349

            char *line_ptr = line;

   350

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

   351

            int index = 0;

   352

   353

            // strip the newline

   354

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

   355

                *nl = '\0';

   356

   357

            // parse the command/args

   358

            if (line_ptr)

   359

                cmd_name = strsep(&line_ptr, " ");

   360

   361

            if (strlen(cmd_name) == 0)

   362

                cmd_name = NULL;

   363

   364

            if (line_ptr)

   365

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

   366

   367

            if (line_ptr)

   368

                str = strsep(&line_ptr, " ");

   369

   370

            if (!cmd_name) {

   371

                continue;

   372

            }

   373

   374

            struct cmd *cmd;

   375

   376

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

   377

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

   378

                    break;

   379

            }

   380

   381

            if (!cmd->func) {

   382

                INFO("Unknown command");

   383

   384

                continue;

   385

            }

   386

   387

            cmd->func(index, str);

   388

        }

   389

   390

        printf("\n");

   391

   392

    } while (!quit);

   393

   394

    return 0;

   395

}

   396