hyperbee 0.5.0

Peer to Peer B-tree
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

/*
 * This file is used to test the rust ffi bindings.
 *
 * It requires a detector be running at ws://localhost:8081
 * Usually we test with the simulated standalone detector.
 */

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <stdio.h>

const char * REL_PATH_TO_BASIC_DATA = "tests/common/js/data/basic";

/* utils */
int msleep(unsigned int tms) {
  return usleep(tms * 1000);
}

char* print_arr(char* out, char* arr_buff, size_t len) {
    for (int i = 0; i < len; i++) {
        char next[sizeof(char)];
        sprintf(next, "%c", arr_buff[i]);
        strcat(out, next);
    }
    return out;
}

// run command and write output to `output`
int run_command(char* command, char* output, size_t max_size) {
    FILE *pf;

    // Setup our pipe for reading and execute our command.
    pf = popen(command,"r");

    if(!pf){
      fprintf(stderr, "Could not open pipe for output.\n");
      return 1;
    }

    // Grab data from process execution
    fgets(output, max_size , pf);

    if (pclose(pf) != 0) {
        fprintf(stderr," Error: Failed to close command stream \n");
        return 1;
    }

    return 0;
}
/* end utils */

/* ffi declerations */
typedef void (*HbGetResultCallback)(int64_t error_code, char* error_message, unsigned long long seq, char* buff, size_t length);

extern void* init_runtime();
extern void* close_runtime(void* runtime);
extern void* hyperbee_from_storage_directory(void* runtime, char* storage_directory);
extern void* close_hyperbee(void* hyperbee);
extern int32_t hb_get(
        void* runtime,
        void* hyperbee,
        char* key_buff,
        size_t key_length,
        HbGetResultCallback cb);

extern void* deallocate_rust_string(
        char* ptr);
extern void* deallocate_rust_buffer(
        char* ptr,
        size_t len);

int callback_not_called = 1;

void callback(
        int64_t error_code,
        char* error_message,
        unsigned long long seq,
        char* key_buff,
        size_t key_length
    ) {
    char arr_str[255];
    print_arr(arr_str, key_buff, key_length);
    printf("%s\n", arr_str);
    deallocate_rust_string(error_message);
    deallocate_rust_buffer(key_buff, key_length);
    callback_not_called = 0;
}
/* end ffi declerations */


int test() {
    char git_root[512];
    char storage_dir[512];

    void* runtime = init_runtime();
    if (runtime == NULL) {
        printf("Failed to initialize runtime\n");
        return 1;
    }

    run_command("git rev-parse --show-toplevel", git_root, sizeof(git_root));
    // trim trailing whitespace https://stackoverflow.com/a/71442959/1609380
    strtok(git_root, "\r\t\n ");
    sprintf(storage_dir, "%s/%s", git_root, REL_PATH_TO_BASIC_DATA);

    void* hyperbee = hyperbee_from_storage_directory(runtime, storage_dir);
    if (hyperbee == NULL) {
        printf("Failed to initialize hyperbee\n");
        return 1;
    }

    char key_buf[1] = { '0' };
    size_t key_length = sizeof( key_buf );
    hb_get(runtime, hyperbee, key_buf, key_length, callback);
    int count = 0;
    while (callback_not_called){
        count += 1;
        msleep(50);
        if (count > 100) {
            // timeout ~ 5 seconds
            printf("Five second timeout reached!");
            return 1;
        }
    }

    close_hyperbee(hyperbee);
    close_runtime(runtime);
    return 0;
}

int main() {
   return test();
}