Class: Iodine::Base::RackTmpFileIO

Inherits:

Object

• Object
• Iodine::Base::RackTmpFileIO

Defined in:

ext/iodine/rb-rack-io.c

Instance Method Summary

• #_hijack(*args) ⇒ Object

  for Rack: rack.hijack_io.

• #close ⇒ Object

  Does nothing - this is controlled by the server.

• #each ⇒ Object

  Passes each line of the input to the block.

• #gets ⇒ Object

  Gets returns a line.

• #read(*args) ⇒ Object

  Reads data from the IO, according to the Rack specifications for ‘#read`.

• #rewind ⇒ Object

  Rewinds the IO, so that it is read from the begining.

Instance Method Details

#_hijack(*args) ⇒ Object

for Rack: rack.hijack_io

# File 'ext/iodine/rb-rack-io.c', line 329

static VALUE rio_get_io(int argc, VALUE *argv, VALUE self) {
  if (TCPSOCKET_CLASS == Qnil)
    return Qfalse;
  intptr_t fduuid = get_uuid(self);
  // hijack the IO object
  VALUE fd = INT2FIX(sock_uuid2fd(fduuid));
  VALUE env = rb_ivar_get(self, env_id);
  // make sure we're not repeating ourselves
  VALUE new_io = rb_hash_aref(env, IODINE_R_HIJACK_IO);
  if (new_io != Qnil)
    return new_io;
  // VALUE new_io = how the fuck do we create a new IO from the fd?
  new_io = RubyCaller.call2(TCPSOCKET_CLASS, for_fd_id, 1,
                            &fd); // TCPSocket.for_fd(fd) ... cool...
  rb_hash_aset(env, IODINE_R_HIJACK_IO, new_io);
  if (argc)
    rb_hash_aset(env, IODINE_R_HIJACK_CB, *argv);
  return new_io;
}

#close ⇒ Object

Does nothing - this is controlled by the server.

# File 'ext/iodine/rb-rack-io.c', line 304

static VALUE tfio_close(VALUE self) {
  (void)self;
  return Qnil;
}

#each ⇒ Object

Passes each line of the input to the block. This should be avoided.

# File 'ext/iodine/rb-rack-io.c', line 310

static VALUE tfio_each(VALUE self) {
  rb_need_block();
  rio_rewind(self);
  VALUE str = Qnil;
  while ((str = tfio_gets(self)) != Qnil) {
    rb_yield(str);
  }
  return self;
}

#gets ⇒ Object

Gets returns a line. this is okay for small lines, but shouldn’t really be used.

Limited to ~ 1Mb of a line length.

# File 'ext/iodine/rb-rack-io.c', line 214

static VALUE tfio_gets(VALUE self) {
  int fd = get_tmpfile(self);
  size_t pos = get_pos(self);
  size_t end = get_end(self);
  if (pos == end)
    return Qnil;
  size_t pos_e = pos;
  char c;
  int ret;
  VALUE buffer;

  do {
    ret = pread(fd, &c, 1, pos_e);
  } while (ret > 0 && c != '\n' && (++pos_e < end));
  set_pos(self, pos_e + 1);
  if (pos > pos_e) {
    buffer = rb_str_buf_new(pos_e - pos);
    // make sure the buffer is binary encoded.
    rb_enc_associate(buffer, IodineBinaryEncoding);
    if (pread(fd, RSTRING_PTR(buffer), pos_e - pos, pos) < 0)
      return Qnil;
    rb_str_set_len(buffer, pos_e - pos);
    return buffer;
  }
  return Qnil;
}

#read(*args) ⇒ Object

Reads data from the IO, according to the Rack specifications for ‘#read`.

# File 'ext/iodine/rb-rack-io.c', line 242

static VALUE tfio_read(int argc, VALUE *argv, VALUE self) {
  int fd = get_tmpfile(self);
  size_t pos = get_pos(self);
  size_t end = get_end(self);
  VALUE buffer = Qnil;
  char ret_nil = 0;
  ssize_t len = 0;
  // get the buffer object if given
  if (argc == 2) {
    Check_Type(argv[1], T_STRING);
    buffer = argv[1];
  }
  // get the length object, if given
  if (argc > 0 && argv[0] != Qnil) {
    Check_Type(argv[0], T_FIXNUM);
    len = FIX2LONG(argv[0]);
    if (len < 0)
      rb_raise(rb_eRangeError, "length should be bigger then 0.");
    ret_nil = 1;
  }
  // return if we're at the EOF.
  if (pos == end)
    goto no_data;
  // calculate length if it wasn't specified.
  if (len == 0) {
    // make sure we're not reading more then we have
    len = end - pos;
    // set position for future reads
    set_pos(self, end);
    if (len == 0)
      goto no_data;
  } else {
    // set position for future reads
    set_pos(self, pos + len);
  }
  // limit read to what we have
  if (len + pos > end)
    len = end - pos;
  // create the buffer if we don't have one.
  if (buffer == Qnil) {
    buffer = rb_str_buf_new(len);
    // make sure the buffer is binary encoded.
    rb_enc_associate(buffer, IodineBinaryEncoding);
  } else {
    // make sure the buffer is binary encoded.
    rb_enc_associate(buffer, IodineBinaryEncoding);
    if (rb_str_capacity(buffer) < (size_t)len)
      rb_str_resize(buffer, len);
  }
  // read the data.
  if (pread(fd, RSTRING_PTR(buffer), len, pos) <= 0)
    goto no_data;
  rb_str_set_len(buffer, len);
  return buffer;
no_data:
  if (ret_nil)
    return Qnil;
  else
    return rb_str_buf_new(0);
}

#rewind ⇒ Object

Rewinds the IO, so that it is read from the begining.

# File 'ext/iodine/rb-rack-io.c', line 182

static VALUE rio_rewind(VALUE self) {
  set_pos(self, 0);
  return self;
}