Commit 9a724443 authored by Willem Thiart's avatar Willem Thiart
Browse files

capnproto transport

parent 296c7e0b
CONTRIB_DIR = . CONTRIB_DIR = .
TEST_DIR = ./tests TEST_DIR = ./tests
LLQUEUE_DIR = $(CONTRIB_DIR)/CLinkedListQueue LLQUEUE_DIR = $(CONTRIB_DIR)/CLinkedListQueue
VPATH = src
GCOV_OUTPUT = *.gcda *.gcno *.gcov GCOV_OUTPUT = *.gcda *.gcno *.gcov
GCOV_CCFLAGS = -fprofile-arcs -ftest-coverage GCOV_CCFLAGS = -fprofile-arcs -ftest-coverage
SHELL = /bin/bash SHELL = /bin/bash
CFLAGS += -Iinclude -Werror -Werror=return-type -Werror=uninitialized -Wcast-align \ CFLAGS += -Iinclude \
-Wno-pointer-sign -fno-omit-frame-pointer -fno-common -fsigned-char \ -Werror -Wextra -Werror=return-type -Werror=uninitialized \
-Wunused-variable \ -Wno-pointer-sign -Wunused-variable \
$(GCOV_CCFLAGS) -I$(LLQUEUE_DIR) -Iinclude -g -O2 -fPIC -fno-omit-frame-pointer -fno-common -fsigned-char \
$(GCOV_CCFLAGS) -I$(LLQUEUE_DIR) -g -O2 -fPIC
#CFLAGS += -Wcast-align
UNAME := $(shell uname) UNAME := $(shell uname)
...@@ -26,7 +28,7 @@ SHAREDFLAGS = -shared ...@@ -26,7 +28,7 @@ SHAREDFLAGS = -shared
SHAREDEXT = so SHAREDEXT = so
endif endif
OBJECTS = src/raft_server.o src/raft_server_properties.o src/raft_node.o src/raft_log.o OBJECTS = src/raft_server.o src/raft_server_properties.o src/raft_node.o src/raft_log.o deps/capnproto/capn.c deps/capnproto/capn-malloc.c deps/capnproto/capn-stream.c
all: static shared all: static shared
......
/* capn-list.inc
*
* Copyright (C) 2013 James McKaskill
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*/
#define CAT2(A,B) A ## B
#define CAT(A,B) CAT2(A, B)
#define UINT_T CAT(CAT(uint, SZ), _t)
#define LIST_T CAT(capn_list, SZ)
#define FLIP CAT(capn_flip, SZ)
UINT_T CAT(capn_get,SZ) (LIST_T l, int off) {
char *d;
capn_ptr p = l.p;
if (off >= p.len) {
return 0;
}
switch (p.type) {
case CAPN_LIST:
if (p.datasz < SZ/8)
return 0;
d = p.data + off * (p.datasz + 8*p.ptrs);
return FLIP(*(UINT_T*)d);
case CAPN_PTR_LIST:
d = struct_ptr(p.seg, p.data + 8*off, SZ/8);
if (d) {
return FLIP(*(UINT_T*)d);
} else {
return 0;
}
default:
return 0;
}
}
int CAT(capn_getv,SZ) (LIST_T l, int off, UINT_T *to, int sz) {
int i;
capn_ptr p;
capn_resolve(&l.p);
p = l.p;
if (off + sz > p.len) {
sz = p.len - off;
}
switch (p.type) {
case CAPN_LIST:
if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) {
memcpy(to, p.data + off, sz * (SZ/8));
return sz;
} else if (p.datasz < SZ/8) {
return -1;
}
for (i = 0; i < sz; i++) {
char *d = p.data + (i + off) * (p.datasz + 8*p.ptrs);
to[i] = FLIP(*(UINT_T*)d);
}
return sz;
case CAPN_PTR_LIST:
for (i = 0; i < sz; i++) {
char *d = struct_ptr(p.seg, p.data + 8*(i+off), SZ/8);
if (d) {
to[i] = FLIP(*(UINT_T*)d);
} else {
return -1;
}
}
return sz;
default:
return -1;
}
}
int CAT(capn_set,SZ) (LIST_T l, int off, UINT_T v) {
char *d;
capn_ptr p = l.p;
if (off >= p.len) {
return -1;
}
switch (p.type) {
case CAPN_LIST:
if (p.datasz < SZ/8)
return -1;
d = p.data + off * (p.datasz + 8*p.ptrs);
*(UINT_T*) d = FLIP(v);
return 0;
case CAPN_PTR_LIST:
d = struct_ptr(p.seg, p.data + 8*off, SZ/8);
if (!d) {
return -1;
}
*(UINT_T*) d = FLIP(v);
return 0;
default:
return -1;
}
}
int CAT(capn_setv,SZ) (LIST_T l, int off, const UINT_T *from, int sz) {
int i;
capn_ptr p = l.p;
if (off + sz > p.len) {
sz = p.len - off;
}
switch (p.type) {
case CAPN_LIST:
if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) {
memcpy(p.data + off, from, sz * (SZ/8));
return sz;
} else if (p.datasz < SZ/8) {
return -1;
}
for (i = 0; i < sz; i++) {
char *d = p.data + (i + off) * (p.datasz + 8*p.ptrs);
*(UINT_T*) d = FLIP(from[i]);
}
return sz;
case CAPN_PTR_LIST:
for (i = 0; i < sz; i++) {
char *d = struct_ptr(p.seg, p.data + 8*(i+off), SZ/8);
if (d) {
*(UINT_T*) d = FLIP(from[i]);
} else {
return -1;
}
}
return sz;
default:
return -1;
}
}
LIST_T CAT(capn_new_list,SZ) (struct capn_segment *seg, int sz) {
LIST_T l = {{CAPN_LIST}};
l.p.seg = seg;
l.p.len = sz;
l.p.datasz = SZ/8;
new_object(&l.p, sz*(SZ/8));
return l;
}
#undef CAT2
#undef CAT
#undef UINT_T
#undef LIST_T
#undef FLIP
/* vim: set sw=8 ts=8 sts=8 noet: */
/* capn-malloc.c
*
* Copyright (C) 2013 James McKaskill
* Copyright (C) 2014 Steve Dee
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*/
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
#include "capnp_c.h"
#include "capnp_priv.h"
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
/*
* 8 byte alignment is required for struct capn_segment.
* This struct check_segment_alignment verifies this at compile time.
*
* Unless capn_segment is defined with 8 byte alignment, check_segment_alignment
* fails to compile in x86 mode (or on another CPU with 32-bit pointers),
* as (sizeof(struct capn_segment)&7) -> (44 & 7) evaluates to 4.
* It compiles in x64 mode (or on another CPU with 64-bit pointers),
* as (sizeof(struct capn_segment)&7) -> (80 & 7) evaluates to 0.
*/
struct check_segment_alignment {
unsigned int foo : (sizeof(struct capn_segment)&7) ? -1 : 1;
};
static struct capn_segment *create(void *u, uint32_t id, int sz) {
struct capn_segment *s;
sz += sizeof(*s);
if (sz < 4096) {
sz = 4096;
} else {
sz = (sz + 4095) & ~4095;
}
s = (struct capn_segment*) calloc(1, sz);
s->data = (char*) (s+1);
s->cap = sz - sizeof(*s);
s->user = s;
return s;
}
static struct capn_segment *create_local(void *u, int sz) {
return create(u, 0, sz);
}
void capn_init_malloc(struct capn *c) {
memset(c, 0, sizeof(*c));
c->create = &create;
c->create_local = &create_local;
}
void capn_free(struct capn *c) {
struct capn_segment *s = c->seglist;
while (s != NULL) {
struct capn_segment *n = s->next;
free(s->user);
s = n;
}
capn_reset_copy(c);
}
void capn_reset_copy(struct capn *c) {
struct capn_segment *s = c->copylist;
while (s != NULL) {
struct capn_segment *n = s->next;
free(s->user);
s = n;
}
c->copy = NULL;
c->copylist = NULL;
}
#define ZBUF_SZ 4096
static int read_fp(void *p, size_t sz, FILE *f, struct capn_stream *z, uint8_t* zbuf, int packed) {
if (f && packed) {
z->next_out = (uint8_t*) p;
z->avail_out = sz;
while (z->avail_out && capn_inflate(z) == CAPN_NEED_MORE) {
int r;
memmove(zbuf, z->next_in, z->avail_in);
r = fread(zbuf+z->avail_in, 1, ZBUF_SZ - z->avail_in, f);
if (r <= 0)
return -1;
z->avail_in += r;
}
return 0;
} else if (f && !packed) {
return fread(p, sz, 1, f) != 1;
} else if (packed) {
z->next_out = (uint8_t*) p;
z->avail_out = sz;
return capn_inflate(z) != 0;
} else {
if (z->avail_in < sz)
return -1;
memcpy(p, z->next_in, sz);
z->next_in += sz;
z->avail_in -= sz;
return 0;
}
}
static int init_fp(struct capn *c, FILE *f, struct capn_stream *z, int packed) {
/*
* Initialize 'c' from the contents of 'f', assuming the message has been
* serialized with the standard framing format. From https://capnproto.org/encoding.html:
*
* When transmitting over a stream, the following should be sent. All integers are unsigned and little-endian.
* (4 bytes) The number of segments, minus one (since there is always at least one segment).
* (N * 4 bytes) The size of each segment, in words.
* (0 or 4 bytes) Padding up to the next word boundary.
* The content of each segment, in order.
*/
struct capn_segment *s = NULL;
uint32_t i, segnum, total = 0;
uint32_t hdr[1024];
uint8_t zbuf[ZBUF_SZ];
char *data = NULL;
capn_init_malloc(c);
/* Read the first four bytes to know how many headers we have */
if (read_fp(&segnum, 4, f, z, zbuf, packed))
goto err;
segnum = capn_flip32(segnum);
if (segnum > 1023)
goto err;
segnum++; /* The wire encoding was zero-based */
/* Read the header list */
if (read_fp(hdr, 8 * (segnum/2) + 4, f, z, zbuf, packed))
goto err;
for (i = 0; i < segnum; i++) {
uint32_t n = capn_flip32(hdr[i]);
if (n > INT_MAX/8 || n > UINT32_MAX/8 || UINT32_MAX - total < n*8)
goto err;
hdr[i] = n*8;
total += hdr[i];
}
/* Allocate space for the data and the capn_segment structs */
s = (struct capn_segment*) calloc(1, total + (sizeof(*s) * segnum));
if (!s)
goto err;
/* Now read the data and setup the capn_segment structs */
data = (char*) (s+segnum);
if (read_fp(data, total, f, z, zbuf, packed))
goto err;
for (i = 0; i < segnum; i++) {
s[i].len = s[i].cap = hdr[i];
s[i].data = data;
data += s[i].len;
capn_append_segment(c, &s[i]);
}
/* Set the entire region to be freed on the last segment */
s[segnum-1].user = s;
return 0;
err:
memset(c, 0, sizeof(*c));
free(s);
return -1;
}
int capn_init_fp(struct capn *c, FILE *f, int packed) {
struct capn_stream z;
memset(&z, 0, sizeof(z));
return init_fp(c, f, &z, packed);
}
int capn_init_mem(struct capn *c, const uint8_t *p, size_t sz, int packed) {
struct capn_stream z;
memset(&z, 0, sizeof(z));
z.next_in = p;
z.avail_in = sz;
return init_fp(c, NULL, &z, packed);
}
static void header_calc(struct capn *c, uint32_t *headerlen, size_t *headersz)
{
/* segnum == 1:
* [segnum][segsiz]
* segnum == 2:
* [segnum][segsiz][segsiz][zeroes]
* segnum == 3:
* [segnum][segsiz][segsiz][segsiz]
* segnum == 4:
* [segnum][segsiz][segsiz][segsiz][segsiz][zeroes]
*/
*headerlen = ((2 + c->segnum) / 2) * 2;
*headersz = 4 * *headerlen;
}
static int header_render(struct capn *c, struct capn_segment *seg, uint32_t *header, uint32_t headerlen, size_t *datasz)
{
size_t i;
header[0] = capn_flip32(c->segnum - 1);
header[headerlen-1] = 0; /* Zero out the spare position in the header sizes */
for (i = 0; i < c->segnum; i++, seg = seg->next) {
if (0 == seg)
return -1;
*datasz += seg->len;
header[1 + i] = capn_flip32(seg->len / 8);
}
if (0 != seg)
return -1;
return 0;
}
static int capn_write_mem_packed(struct capn *c, uint8_t *p, size_t sz)
{
struct capn_segment *seg;
struct capn_ptr root;
uint32_t headerlen;
size_t headersz, datasz = 0;
uint32_t *header;
struct capn_stream z;
int ret;
root = capn_root(c);
header_calc(c, &headerlen, &headersz);
header = (uint32_t*) (p + headersz + 2); /* must reserve two bytes for worst case expansion */
if (sz < headersz*2 + 2) /* We must have space for temporary writing of header to deflate */
return -1;
ret = header_render(c, root.seg, header, headerlen, &datasz);
if (ret != 0)
return -1;
memset(&z, 0, sizeof(z));
z.next_in = (uint8_t *)header;
z.avail_in = headersz;
z.next_out = p;
z.avail_out = sz;
// pack the headers
ret = capn_deflate(&z);
if (ret != 0 || z.avail_in != 0)
return -1;
for (seg = root.seg; seg; seg = seg->next) {
z.next_in = (uint8_t *)seg->data;
z.avail_in = seg->len;
ret = capn_deflate(&z);
if (ret != 0 || z.avail_in != 0)
return -1;
}
return sz - z.avail_out;
}
int
capn_write_mem(struct capn *c, uint8_t *p, size_t sz, int packed)
{
struct capn_segment *seg;
struct capn_ptr root;
uint32_t headerlen;
size_t headersz, datasz = 0;
uint32_t *header;
int ret;
if (c->segnum == 0)
return -1;
if (packed)
return capn_write_mem_packed(c, p, sz);
root = capn_root(c);
header_calc(c, &headerlen, &headersz);
header = (uint32_t*) p;
if (sz < headersz)
return -1;
ret = header_render(c, root.seg, header, headerlen, &datasz);
if (ret != 0)
return -1;
if (sz < headersz + datasz)
return -1;
p += headersz;
for (seg = root.seg; seg; seg = seg->next) {
memcpy(p, seg->data, seg->len);
p += seg->len;
}
return headersz+datasz;
}
static int _write_fd(ssize_t (*write_fd)(int fd, const void *p, size_t count), int fd, void *p, size_t count)
{
ssize_t ret;
size_t sent = 0;
while (sent < count) {
ret = write_fd(fd, ((uint8_t*)p)+sent, count-sent);
if (ret < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
else
return -1;
}
sent += ret;
}
return 0;
}
int capn_write_fd(struct capn *c, ssize_t (*write_fd)(int fd, const void *p, size_t count), int fd, int packed)
{
unsigned char buf[4096];
struct capn_segment *seg;
struct capn_ptr root;
uint32_t headerlen;
size_t headersz, datasz = 0;
int ret;
struct capn_stream z;
unsigned char *p;
if (c->segnum == 0)
return -1;
root = capn_root(c);
header_calc(c, &headerlen, &headersz);
if (sizeof(buf) < headersz)
return -1;
ret = header_render(c, root.seg, (uint32_t*)buf, headerlen, &datasz);
if (ret != 0)
return -1;
if (packed) {
const int headerrem = sizeof(buf) - headersz;
const int maxpack = headersz + 2;
if (headerrem < maxpack)
return -1;
memset(&z, 0, sizeof(z));
z.next_in = buf;
z.avail_in = headersz;
z.next_out = buf + headersz;
z.avail_out = headerrem;
ret = capn_deflate(&z);
if (ret != 0)
return -1;
p = buf + headersz;
headersz = headerrem - z.avail_out;
} else {
p = buf;
}
ret = _write_fd(write_fd, fd, p, headersz);
if (ret < 0)
return -1;
datasz = headersz;
for (seg = root.seg; seg; seg = seg->next) {
size_t bufsz;
if (packed) {
memset(&z, 0, sizeof(z));
z.next_in = (uint8_t*)seg->data;
z.avail_in = seg->len;
z.next_out = buf;
z.avail_out = sizeof(buf);
ret = capn_deflate(&z);
if (ret != 0)
return -1;
p = buf;
bufsz = sizeof(buf) - z.avail_out;
} else {
p = (uint8_t*)seg->data;
bufsz = seg->len;
}
ret = _write_fd(write_fd, fd, p, bufsz);
if (ret < 0)
return -1;
datasz += bufsz;
}
return datasz;
}
/* vim: set sw=8 ts=8 sts=8 noet: */
/* capn-stream.c
*
* Copyright (C) 2013 James McKaskill
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*/
#include "capnp_c.h"
#include "capnp_priv.h"
#include <string.h>
#ifndef min
static unsigned min(unsigned a, unsigned b) { return (a < b) ? a : b; }
#endif
int capn_deflate(struct capn_stream* s) {
if (s->avail_in % 8) {
return CAPN_MISALIGNED;
}
while (s->avail_in) {
int i;
size_t sz;
uint8_t hdr = 0;
uint8_t *p;
if (!s->avail_out)
return CAPN_NEED_MORE;
if (s->raw > 0) {
sz = min(s->raw, min(s->avail_in, s->avail_out));
memcpy(s->next_out, s->next_in, sz);
s->next_out += sz;
s->next_in += sz;
s->avail_out -= sz;
s->avail_in -= sz;
s->raw -= sz;
continue;
}
if (s->avail_in < 8)
return CAPN_NEED_MORE;
sz = 0;
for (i = 0; i < 8; i++) {
if (s->next_in[i]) {
sz ++;
hdr |= 1 << i;
}
}
switch (sz) {
case 0:
if (s->avail_out < 2)
return CAPN_NEED_MORE;
s->next_out[0] = 0;
for (sz = 1; sz < min(s->avail_in/8, 256); sz++) {
if (((uint64_t*) s->next_in)[sz] != 0) {
break;
}
}
s->next_out[1] = (uint8_t) (sz-1);
s->next_in += sz*8;
s->avail_in -= sz*8;
s->next_out += 2;
s->avail_out -= 2;
continue;
case 8:
if (s->avail_out < 10)
return CAPN_NEED_MORE;
s->next_out[0] = 0xFF;
memcpy(s->next_out+1, s->next_in, 8);
s->next_in += 8;
s->avail_in -= 8;
s->raw = min(s->avail_in, 256*8);
if ((p = (uint8_t*) memchr(s->next_in, 0, s->raw)) != NULL) {
s->raw = (p - s->next_in) & ~7;
}
s->next_out[9] = (uint8_t) (s->raw/8);
s->next_out += 10;
s->avail_out -= 10;
continue;
default:
if (s->avail_out < 1U + sz)
return CAPN_NEED_MORE;
*(s->next_out++) = hdr;
for (i = 0; i < 8; i++) {
if (s->next_in[i]) {
*(s->next_out++) = s->next_in[i];
}
}
s->avail_out -= sz + 1;
s->next_in += 8;
s->avail_in -= 8;
continue;
}
}
return 0;
}
int capn_inflate(struct capn_stream* s) {
while (s->avail_out) {
int i;
size_t sz;
uint8_t hdr;
uint8_t *wr;
if (s->avail_buf && s->avail_out >= s->avail_buf) {
memcpy(s->next_out, s->inflate_buf, s->avail_buf);
s->next_out += s->avail_buf;
s->avail_out -= s->avail_buf;
s->avail_buf = 0;
if (!s->avail_out)
return 0;
}
if (s->avail_buf && s->avail_out < s->avail_buf) {
memcpy(s->next_out, s->inflate_buf, s->avail_out);
memmove(s->inflate_buf, s->inflate_buf + s->avail_out,
s->avail_buf - s->avail_out);
s->avail_buf -= s->avail_out;
s->avail_out = 0;
return 0;
}
if (s->zeros > 0) {
sz = min(s->avail_out, s->zeros);
memset(s->next_out, 0, sz);
s->next_out += sz;
s->avail_out -= sz;
s->zeros -= sz;
continue;
}
if (s->raw > 0) {
if (s->avail_in == 0)
return CAPN_NEED_MORE;
sz = min(min(s->avail_out, s->raw), s->avail_in);
memcpy(s->next_out, s->next_in, sz);
s->next_in += sz;
s->next_out += sz;
s->avail_in -= sz;
s->avail_out -= sz;
s->raw -= sz;
continue;
}
if (s->avail_in == 0)
return 0;
else if (s->avail_in < 2)
return CAPN_NEED_MORE;
switch (s->next_in[0]) {
case 0xFF:
/* 0xFF is followed by 8 bytes raw, followed by
* a byte with length in words to read raw */
if (s->avail_in < 10)
return CAPN_NEED_MORE;
memcpy(s->inflate_buf, s->next_in+1, 8);
s->avail_buf = 8;
s->raw = s->next_in[9] * 8;
s->next_in += 10;
s->avail_in -= 10;
continue;
case 0x00:
/* 0x00 is followed by a single byte indicating
* the count of consecutive zero value words
* minus 1 */
s->zeros = (s->next_in[1] + 1) * 8;
s->next_in += 2;
s->avail_in -= 2;
continue;
default:
hdr = s->next_in[0];
sz = 0;
for (i = 0; i < 8; i++) {
if (hdr & (1 << i))
sz++;
}
if (s->avail_in < 1U + sz)
return CAPN_NEED_MORE;
s->next_in += 1;
wr = s->inflate_buf;
for (i = 0; i < 8; i++) {
if (hdr & (1 << i)) {
*wr++ = *s->next_in++;
} else {
*wr++ = 0;
}
}
s->avail_buf = 8;
s->avail_in -= 1 + sz;
continue;
}
}
return 0;
}
This diff is collapsed.
/* vim: set sw=8 ts=8 sts=8 noet: */
/* capnp_c.h
*
* Copyright (C) 2013 James McKaskill
* Copyright (C) 2014 Steve Dee
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*/
/*
* functions / structures in this header are private to the capnproto-c
* library; applications should not call or use them.
*/
#ifndef CAPNP_PRIV_H
#define CAPNP_PRIV_H
#include "capnp_c.h"
#if defined(__GNUC__) && __GNUC__ >= 4
# define intern __attribute__((visibility ("internal")))
#else
# define intern /**/
#endif
/* capn_stream encapsulates the needed fields for capn_(deflate|inflate) in a
* similar manner to z_stream from zlib
*
* The user should set next_in, avail_in, next_out, avail_out to the
* available in/out buffers before calling capn_(deflate|inflate).
*
* Other fields should be zero initialized.
*/
struct capn_stream {
const uint8_t *next_in;
size_t avail_in;
uint8_t *next_out;
size_t avail_out;
unsigned zeros, raw;
uint8_t inflate_buf[8];
size_t avail_buf;
};
#define CAPN_MISALIGNED -1
#define CAPN_NEED_MORE -2
/* capn_deflate deflates a stream to the packed format
* capn_inflate inflates a stream from the packed format
*
* Returns:
* CAPN_MISALIGNED - if the unpacked data is not 8 byte aligned
* CAPN_NEED_MORE - more packed data/room is required (out for inflate, in for
* deflate)
* 0 - success, all output for inflate, all input for deflate processed
*/
intern int capn_deflate(struct capn_stream*);
intern int capn_inflate(struct capn_stream*);
#endif /* CAPNP_PRIV_H */
@0xd27081948f8c0117;
annotation nameinfix @0x85a8d86d736ba637 (file): Text;
annotation fieldgetset @0xf72bc690355d66de (file): Void;
$fieldgetset;
struct LogEntry
{
term @0 :UInt64;
id @1 :UInt64;
type @2 :UInt64;
data @3 :Data;
}
struct RequestVoteMsg
{
term @0 :UInt64;
candidateId @1 :UInt64;
lastLogIdx @2 :UInt64;
lastLogTerm @3 :UInt64;
}
struct RequestVoteResponseMsg
{
term @0 :UInt64;
voteGranted @1 :UInt64;
}
struct AppendEntriesMsg
{
term @0 :UInt64;
prevLogIdx @1 :UInt64;
prevLogTerm @2 :UInt64;
leaderCommit @3 :UInt64;
nEntries @4 :UInt64;
entries @5 :List(LogEntry);
}
struct AppendEntriesResponseMsg
{
term @0 :UInt64;
success @1 :UInt64;
currentIdx @2 :UInt64;
firstIdx @3 :UInt64;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment