uringmachine 0.29.1 → 0.30.0

data/ext/um/um.h

@@ -48,6 +48,9 @@ enum um_op_kind {
   OP_CLOSE,
   OP_CLOSE_ASYNC,
   OP_STATX,
+  OP_SPLICE,
+  OP_TEE,
+  OP_FSYNC,
 
   OP_ACCEPT,
   OP_RECV,
@@ -161,7 +164,7 @@ struct um_op {
     struct iovec *iovecs; // used for vectorized write/send
     siginfo_t siginfo; // used for waitid
     int int_value; // used for getsockopt
-    size_t bp_commit_level; // buffer pool commit threshold
+    size_t bp_commit_level; // buffer pool commit level
   };
 };
 
@@ -283,7 +286,8 @@ struct um_stream {
   struct um_op *op;
   struct um_segment *head;
   struct um_segment *tail;
-  size_t pending_len;
+  size_t consumed_bytes;
+  size_t pending_bytes;
   size_t pos;
   int eof;
 };
@@ -324,7 +328,6 @@ void um_op_list_compact(struct um *machine, struct um_op *head);
 void um_op_multishot_results_push(struct um *machine, struct um_op *op, __s32 res, __u32 flags);
 void um_op_multishot_results_clear(struct um *machine, struct um_op *op);
 
-struct um_segment *um_segment_alloc(struct um *machine);
 void um_segment_free(struct um *machine, struct um_segment *segment);
 
 void um_runqueue_push(struct um *machine, struct um_op *op);
@@ -390,6 +393,9 @@ VALUE um_waitid_status(struct um *machine, int idtype, int id, int options);
 #endif
 
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
+VALUE um_splice(struct um *machine, int in_fd, int out_fd, uint nbytes);
+VALUE um_tee(struct um *machine, int in_fd, int out_fd, uint nbytes);
+VALUE um_fsync(struct um *machine, int fd);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
@@ -436,6 +442,7 @@ void stream_clear(struct um_stream *stream);
 VALUE stream_get_line(struct um_stream *stream, VALUE buf, size_t maxlen);
 VALUE stream_get_string(struct um_stream *stream, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
 void stream_skip(struct um_stream *stream, size_t inc, int safe_inc);
+void stream_each(struct um_stream *stream);
 VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
 void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);
@@ -453,9 +460,9 @@ void um_sidecar_signal_wait(struct um *machine);
 void um_sidecar_signal_wake(struct um *machine);
 
 void um_ssl_set_bio(struct um *machine, VALUE ssl_obj);
-int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, int maxlen);
-int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, int maxlen);
-int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, int len);
+int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, size_t maxlen);
+int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, size_t maxlen);
+int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, size_t len);
 
 void bp_setup(struct um *machine);
 void bp_teardown(struct um *machine);

data/ext/um/um_buffer_pool.c

@@ -18,7 +18,7 @@ inline struct um_buffer *buffer_alloc(struct um *machine) {
   return buffer;
 }
 
-inline struct um_buffer *bp_buffer_checkout(struct um *machine) {
+struct um_buffer *bp_buffer_checkout(struct um *machine) {
   struct um_buffer *buffer = machine->bp_buffer_freelist;
   if (buffer) {
     struct um_buffer *next = buffer->next;
@@ -50,13 +50,13 @@ inline void buffer_free(struct um *machine, struct um_buffer *buffer) {
   }
 }
 
-inline void bp_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
+void bp_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
   assert(buffer->ref_count > 0);
   buffer->ref_count--;
   if (!buffer->ref_count) buffer_free(machine, buffer);
 }
 
-inline void bp_discard_buffer_freelist(struct um *machine) {
+void bp_discard_buffer_freelist(struct um *machine) {
   while (machine->bp_buffer_freelist) {
     struct um_buffer *buffer = machine->bp_buffer_freelist;
     struct um_buffer *next = buffer->next;
@@ -69,7 +69,7 @@ inline void bp_discard_buffer_freelist(struct um *machine) {
   }
 }
 
-inline void bp_setup(struct um *machine) {
+void bp_setup(struct um *machine) {
   int ret;
   machine->bp_br = io_uring_setup_buf_ring(&machine->ring, BP_BR_ENTRIES, BP_BGID, IOU_PBUF_RING_INC, &ret);
   if (unlikely(!machine->bp_br)) rb_syserr_fail(ret, strerror(ret));
@@ -85,7 +85,7 @@ inline void bp_setup(struct um *machine) {
   machine->bp_total_commited = 0;
 }
 
-inline void bp_teardown(struct um *machine) {
+void bp_teardown(struct um *machine) {
   bp_discard_buffer_freelist(machine);
   for (int i = 0; i < BP_BR_ENTRIES; i++) {
     struct um_buffer *buffer = machine->bp_commited_buffers[i];
@@ -162,7 +162,7 @@ inline int should_commit_more_p(struct um *machine) {
          (machine->bp_total_commited < machine->bp_commit_level);
 }
 
-inline void bp_ensure_commit_level(struct um *machine) {
+void bp_ensure_commit_level(struct um *machine) {
   if (machine->bp_total_commited > (machine->bp_commit_level / 2))
     return;
 
@@ -179,7 +179,7 @@ inline void bp_ensure_commit_level(struct um *machine) {
   // size.
 }
 
-inline void bp_handle_enobufs(struct um *machine) {
+void bp_handle_enobufs(struct um *machine) {
   if (unlikely(machine->bp_commit_level >= BP_MAX_COMMIT_LEVEL))
     rb_raise(eUMError, "Buffer starvation");
 
@@ -189,7 +189,7 @@ inline void bp_handle_enobufs(struct um *machine) {
   bp_discard_buffer_freelist(machine);
 }
 
-inline struct um_segment *um_segment_alloc(struct um *machine) {
+inline struct um_segment *segment_alloc(struct um *machine) {
   if (machine->segment_freelist) {
     struct um_segment *segment = machine->segment_freelist;
     machine->segment_freelist = segment->next;
@@ -208,14 +208,14 @@ inline struct um_segment *um_segment_alloc(struct um *machine) {
   return batch;
 }
 
-inline void um_segment_free(struct um *machine, struct um_segment *segment) {
+void um_segment_free(struct um *machine, struct um_segment *segment) {
   segment->next = machine->segment_freelist;
   machine->segment_freelist = segment;
   machine->metrics.segments_free++;
 }
 
-inline struct um_segment *bp_buffer_consume(struct um *machine, struct um_buffer *buffer, size_t len) {
-  struct um_segment *segment = um_segment_alloc(machine);
+struct um_segment *bp_buffer_consume(struct um *machine, struct um_buffer *buffer, size_t len) {
+  struct um_segment *segment = segment_alloc(machine);
   segment->ptr = buffer->buf + buffer->pos;
   segment->len = len;
   segment->buffer = buffer;

data/ext/um/um_class.c

@@ -534,6 +534,60 @@ VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
   return um_statx(machine, NUM2INT(dirfd), path, NUM2INT(flags), NUM2UINT(mask));
 }
 
+/* call-seq:
+ *   machine.splice(in_fd, out_fd, nbytes) -> len
+ *
+ * Splices bytes from in_fd to out_fd. At least one of the given fds must be a
+ * pipe.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/splice.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_splice.3.html
+ *
+ * @param in_fd [Integer] fd to splice from
+ * @param out_fd [Integer] fd to splice to
+ * @param nbytes [Integer] number of bytes to splice
+ * @return [Integer] number of bytes spliced
+ */
+VALUE UM_splice(VALUE self, VALUE in_fd, VALUE out_fd, VALUE nbytes) {
+  struct um *machine = um_get_machine(self);
+  return um_splice(machine, NUM2INT(in_fd), NUM2INT(out_fd), NUM2UINT(nbytes));
+}
+
+/* call-seq:
+ *   machine.tee(in_fd, out_fd, nbytes) -> len
+ *
+ * Duplicates bytes from in_fd to out_fd. At least one of the given fds must be
+ * a pipe.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/tee.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_tee.3.html
+ *
+ * @param in_fd [Integer] fd to copy from
+ * @param out_fd [Integer] fd to copy to
+ * @param nbytes [Integer] number of bytes to duplicate
+ * @return [Integer] number of bytes duplicated
+ */
+VALUE UM_tee(VALUE self, VALUE in_fd, VALUE out_fd, VALUE nbytes) {
+  struct um *machine = um_get_machine(self);
+  return um_tee(machine, NUM2INT(in_fd), NUM2INT(out_fd), NUM2UINT(nbytes));
+}
+
+/* call-seq:
+ *   machine.fsync(fd) -> 0
+ *
+ * Flushes all modified file data to the storage device.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/fsync.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_fsync.3.html
+ *
+ * @param fd [Integer] fd
+ * @return [Integer] 0 if successful
+ */
+VALUE UM_fsync(VALUE self, VALUE fd) {
+  struct um *machine = um_get_machine(self);
+  return um_fsync(machine, NUM2INT(fd));
+}
+
 /* call-seq:
  *   machine.close(fd) -> 0
  *
@@ -1480,6 +1534,9 @@ void Init_UM(void) {
   rb_define_method(cUM, "writev", UM_writev, -1);
   rb_define_method(cUM, "write_async", UM_write_async, -1);
   rb_define_method(cUM, "statx", UM_statx, 4);
+  rb_define_method(cUM, "splice", UM_splice, 3);
+  rb_define_method(cUM, "tee", UM_tee, 3);
+  rb_define_method(cUM, "fsync", UM_fsync, 1);
 
   rb_define_method(cUM, "poll", UM_poll, 2);
   rb_define_method(cUM, "select", UM_select, 3);

data/ext/um/um_ssl.c

@@ -75,7 +75,7 @@ void um_ssl_set_bio(struct um *machine, VALUE ssl_obj)
   SSL_set0_wbio(ssl, bio);
 }
 
-int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, int maxlen) {
+int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, size_t maxlen) {
   SSL *ssl = RTYPEDDATA_GET_DATA(ssl_obj);
 
   int ret = SSL_read(ssl, ptr, maxlen);
@@ -84,22 +84,23 @@ int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, int maxlen) {
   return ret;
 }
 
-int um_ssl_read(struct um *machine, VALUE ssl_obj, VALUE buf, int maxlen) {
+int um_ssl_read(struct um *machine, VALUE ssl_obj, VALUE buf, size_t maxlen) {
   void *ptr = um_prepare_read_buffer(buf, maxlen, 0);
   int ret = um_ssl_read_raw(machine, ssl_obj, ptr, maxlen);
   um_update_read_buffer(buf, 0, ret);
   return ret;
 }
 
-int um_ssl_write(struct um *machine, VALUE ssl_obj, VALUE buf, int len) {
+int um_ssl_write(struct um *machine, VALUE ssl_obj, VALUE buf, size_t len) {
   SSL *ssl = RTYPEDDATA_GET_DATA(ssl_obj);
   const void *base;
   size_t size;
   um_get_buffer_bytes_for_writing(buf, &base, &size, true);
-  if ((len == (int)-1) || (len > (int)size)) len = (int)size;
+  if (!len || (len > size)) len = size;
+  if (len > INT_MAX) len = INT_MAX;
   if (unlikely(!len)) return INT2NUM(0);
 
-  int ret = SSL_write(ssl, base, len);
+  int ret = SSL_write(ssl, base, (int)len);
   if (ret <= 0) rb_raise(eUMError, "Failed to write");
 
   return ret;

data/ext/um/um_stream.c

@@ -1,5 +1,6 @@
-#include "um.h"
 #include <stdlib.h>
+#include <ruby/io/buffer.h>
+#include "um.h"
 
 inline void stream_add_segment(struct um_stream *stream, struct um_segment *segment) {
   segment->next = NULL;
@@ -9,7 +10,7 @@ inline void stream_add_segment(struct um_stream *stream, struct um_segment *segm
   }
   else
     stream->head = stream->tail = segment;
-  stream->pending_len += segment->len;
+  stream->pending_bytes += segment->len;
 }
 
 inline int stream_process_op_result(struct um_stream *stream, struct um_op_result *result) {
@@ -73,7 +74,7 @@ void um_stream_cleanup(struct um_stream *stream) {
     um_segment_checkin(stream->machine, stream->head);
     stream->head = next;
   }
-  stream->pending_len = 0;
+  stream->pending_bytes = 0;
 }
 
 // returns true if case of ENOBUFS error, sets more to true if more data forthcoming
@@ -124,7 +125,7 @@ void stream_clear(struct um_stream *stream) {
     um_segment_checkin(stream->machine, stream->head);
     stream->head = next;
   }
-  stream->pending_len = 0;
+  stream->pending_bytes = 0;
 
   if (stream->working_buffer) {
     bp_buffer_checkin(stream->machine, stream->working_buffer);
@@ -156,12 +157,12 @@ int stream_get_more_segments_bp(struct um_stream *stream) {
     enobufs = stream_process_segments(stream, &total_bytes, &more);
     um_op_multishot_results_clear(stream->machine, stream->op);
     if (unlikely(enobufs)) {
-      int should_restart = stream->pending_len < (stream->machine->bp_buffer_size * 4);
+      int should_restart = stream->pending_bytes < (stream->machine->bp_buffer_size * 4);
       // int same_threshold = stream->op->bp_commit_level == stream->machine->bp_commit_level;
 
       // fprintf(stderr, "%p enobufs total: %ld pending: %ld threshold: %ld bc: %d (same: %d, restart: %d)\n",
       //   stream,
-      //   total_bytes, stream->pending_len, stream->machine->bp_commit_level,
+      //   total_bytes, stream->pending_bytes, stream->machine->bp_commit_level,
       //   stream->machine->bp_buffer_count,
       //   same_threshold, should_restart
       // );
@@ -173,7 +174,7 @@ int stream_get_more_segments_bp(struct um_stream *stream) {
       if (should_restart) {
         if (stream->op->bp_commit_level == stream->machine->bp_commit_level)
           bp_handle_enobufs(stream->machine);
-  
+
         um_op_release(stream->machine, stream->op);
         stream->op = NULL;
         // stream_multishot_op_start(stream);
@@ -234,13 +235,24 @@ inline void stream_shift_head(struct um_stream *stream) {
   stream->pos = 0;
 }
 
+inline VALUE make_segment_io_buffer(struct um_segment *segment, size_t pos) {
+  return rb_io_buffer_new(
+    segment->ptr + pos, segment->len - pos,
+    RB_IO_BUFFER_LOCKED|RB_IO_BUFFER_READONLY
+  );
+}
+
 inline void stream_skip(struct um_stream *stream, size_t inc, int safe_inc) {
+  if (unlikely(stream->eof && !stream->head)) return;
+  if (safe_inc && !stream->tail && !stream_get_more_segments(stream)) return;
+
   while (inc) {
     size_t segment_len = stream->head->len - stream->pos;
     size_t inc_len = (segment_len <= inc) ? segment_len : inc;
     inc -= inc_len;
     stream->pos += inc_len;
-    stream->pending_len -= inc_len;
+    stream->consumed_bytes += inc_len;
+    stream->pending_bytes -= inc_len;
     if (stream->pos == stream->head->len) {
       stream_shift_head(stream);
       if (inc && safe_inc && !stream->head) {
@@ -250,6 +262,30 @@ inline void stream_skip(struct um_stream *stream, size_t inc, int safe_inc) {
   }
 }
 
+inline void stream_each(struct um_stream *stream) {
+  if (unlikely(stream->eof && !stream->head)) return;
+  if (!stream->tail && !stream_get_more_segments(stream)) return;
+
+  struct um_segment *current = stream->head;
+  size_t pos = stream->pos;
+
+  VALUE buffer = Qnil;
+  while (true) {
+    struct um_segment *next = current->next;
+    buffer = make_segment_io_buffer(current, pos);
+    rb_yield(buffer);
+    rb_io_buffer_free_locked(buffer);
+    stream_shift_head(stream);
+
+    if (!next) {
+      if (!stream_get_more_segments(stream)) return;
+    }
+    current = stream->head;
+    pos = 0;
+  }
+  RB_GC_GUARD(buffer);
+}
+
 inline void stream_copy(struct um_stream *stream, char *dest, size_t len) {
   while (len) {
     char *segment_ptr = stream->head->ptr + stream->pos;
@@ -259,7 +295,8 @@ inline void stream_copy(struct um_stream *stream, char *dest, size_t len) {
 
     len -= cpy_len;
     stream->pos += cpy_len;
-    stream->pending_len -= cpy_len;
+    stream->consumed_bytes += cpy_len;
+    stream->pending_bytes -= cpy_len;
     dest += cpy_len;
     if (stream->pos == stream->head->len) stream_shift_head(stream);
   }

data/ext/um/um_stream_class.c

@@ -102,6 +102,20 @@ static inline void stream_setup(struct um_stream *stream, VALUE target, VALUE mo
     rb_raise(eUMError, "Invalid stream mode");
 }
 
+/* call-seq:
+ *   UM::Stream.new(machine, fd, mode = nil) -> stream
+ *   machine.stream(fd, mode = nil) -> stream
+ *   machine.stream(fd, mode = nil) { |stream| ... }
+ *
+ * Initializes a new stream with the given UringMachine instance, target and
+ * optional mode. The target maybe a file descriptor, or an instance of
+ * OpenSSL::SSL::SSLSocket. In case of an SSL socket, the mode should be :ssl.
+ *
+ * @param machine [UringMachine] UringMachine instance
+ * @param target [integer, OpenSSL::SSL::SSLSocket] stream target: file descriptor or SSL socket
+ * @param mode [Symbol] optional stream mode: :bp_read, :bp_recv, :ssl
+ * @return [void]
+ */
 VALUE Stream_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE machine;
   VALUE target;
@@ -118,6 +132,13 @@ VALUE Stream_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/* call-seq:
+ *   stream.mode -> mode
+ *
+ * Returns the stream mode.
+ *
+ * @return [Symbol] stream mode
+ */
 VALUE Stream_mode(VALUE self) {
   struct um_stream *stream = um_get_stream(self);
   switch (stream->mode) {
@@ -129,16 +150,70 @@ VALUE Stream_mode(VALUE self) {
   return Qnil;
 }
 
+/* call-seq:
+ *   stream.get_line(limit) -> str
+ *
+ * Reads from the string until a newline character is encountered. Returns the
+ * line without the newline delimiter. If limit is 0, the line length is not
+ * limited. If no newline delimiter is found before EOF, returns nil.
+ *
+ * @param limit [integer] maximum line length (0 means no limit)
+ * @return [String, nil] read data or nil
+ */
 VALUE Stream_get_line(VALUE self, VALUE limit) {
   struct um_stream *stream = um_get_stream(self);
   return stream_get_line(stream, Qnil, NUM2ULONG(limit));
 }
 
+/* call-seq:
+ *   stream.get_string(len) -> str
+ *
+ * Reads len bytes from the stream. If len is 0, reads all available bytes. If
+ * len is negative, reads up to -len available bytes. If len is positive and eof
+ * is encountered before len bytes are read, returns nil.
+ *
+ * @param len [integer] number of bytes to read
+ * @return [String, nil] read data or nil
+ */
 VALUE Stream_get_string(VALUE self, VALUE len) {
   struct um_stream *stream = um_get_stream(self);
   return stream_get_string(stream, Qnil, NUM2LONG(len), 0, false);
 }
 
+/* call-seq:
+ *   stream.skip(len) -> len
+ *
+ * Skips len bytes in the stream.
+ *
+ * @param len [integer] number of bytes to skip
+ * @return [Integer] len
+ */
+VALUE Stream_skip(VALUE self, VALUE len) {
+  struct um_stream *stream = um_get_stream(self);
+  stream_skip(stream, NUM2LONG(len), true);
+  return len;
+}
+
+/* call-seq:
+ *   stream.each { |data| } -> stream
+ *
+ * Reads from the target, passing each chunk to the given block.
+ *
+ * @return [UringMachine::Stream] stream
+ */
+VALUE Stream_each(VALUE self) {
+  struct um_stream *stream = um_get_stream(self);
+  stream_each(stream);
+  return self;
+}
+
+/* call-seq:
+ *   stream.resp_decode -> obj
+ *
+ * Decodes an object from a RESP (Redis protocol) message.
+ *
+ * @return [any] decoded object
+ */
 VALUE Stream_resp_decode(VALUE self) {
   struct um_stream *stream = um_get_stream(self);
   VALUE out_buffer = rb_utf8_str_new_literal("");
@@ -147,6 +222,15 @@ VALUE Stream_resp_decode(VALUE self) {
   return obj;
 }
 
+/* call-seq:
+ *   stream.resp_encode(obj) -> string
+ *
+ * Encodes an object into a RESP (Redis protocol) message.
+ *
+ * @param str [String] string buffer
+ * @param obj [any] object to be encoded
+ * @return [String] str
+ */
 VALUE Stream_resp_encode(VALUE self, VALUE str, VALUE obj) {
   struct um_write_buffer buf;
   write_buffer_init(&buf, str);
@@ -156,11 +240,49 @@ VALUE Stream_resp_encode(VALUE self, VALUE str, VALUE obj) {
   return str;
 }
 
+/* call-seq:
+ *   stream.eof? -> bool
+ *
+ * Returns true if stream has reached EOF.
+ *
+ * @return [bool] EOF reached
+ */
 VALUE Stream_eof_p(VALUE self) {
   struct um_stream *stream = um_get_stream(self);
   return stream->eof ? Qtrue : Qfalse;
 }
 
+/* call-seq:
+ *   stream.consumed -> int
+ *
+ * Returns the total number of bytes consumed from the stream.
+ *
+ * @return [Integer] total bytes consumed
+ */
+VALUE Stream_consumed(VALUE self) {
+  struct um_stream *stream = um_get_stream(self);
+  return LONG2NUM(stream->consumed_bytes);
+}
+
+/* call-seq:
+ *   stream.pending -> int
+ *
+ * Returns the number of bytes available for reading.
+ *
+ * @return [Integer] bytes available
+ */
+VALUE Stream_pending(VALUE self) {
+  struct um_stream *stream = um_get_stream(self);
+  return LONG2NUM(stream->pending_bytes);
+}
+
+/* call-seq:
+ *   stream.clear -> stream
+ *
+ * Clears all available bytes and stops any ongoing read operation.
+ *
+ * @return [UM::Stream] self
+ */
 VALUE Stream_clear(VALUE self) {
   struct um_stream *stream = um_get_stream(self);
   stream_clear(stream);
@@ -176,11 +298,15 @@ void Init_Stream(void) {
 
   rb_define_method(cStream, "get_line", Stream_get_line, 1);
   rb_define_method(cStream, "get_string", Stream_get_string, 1);
+  rb_define_method(cStream, "skip", Stream_skip, 1);
+  rb_define_method(cStream, "each", Stream_each, 0);
 
   rb_define_method(cStream, "resp_decode", Stream_resp_decode, 0);
   rb_define_singleton_method(cStream, "resp_encode", Stream_resp_encode, 2);
 
   rb_define_method(cStream, "eof?", Stream_eof_p, 0);
+  rb_define_method(cStream, "consumed", Stream_consumed, 0);
+  rb_define_method(cStream, "pending", Stream_pending, 0);
   rb_define_method(cStream, "clear", Stream_clear, 0);
 
   eStreamRESPError = rb_define_class_under(cStream, "RESPError", rb_eStandardError);