size_t
fs_ruby_pack_to_data( struct fs_server* server, struct fs_pack* pack, BYTE** out){
BYTE* data = NULL;
size_t len = 0;
if(pack->data_output_stream_id != Qnil){
struct fs_output_stream* os = NULL;
Data_Get_Struct(pack->data_output_stream_id, struct fs_output_stream, os);
data = (BYTE*)fs_output_stream_get_dataptr(os);
len = fs_output_stream_get_len(os);
}
if(pack->data_input_stream_id != Qnil){
struct fs_input_stream* is = NULL;
Data_Get_Struct(pack->data_input_stream_id, struct fs_input_stream, is);
data = (BYTE*)fs_input_stream_get_data_ptr(is);
len = fs_input_stream_get_len(is);
}
if (pack->input_stream != NULL) {
data = (BYTE*)fs_input_stream_get_data_ptr(pack->input_stream);
len = fs_input_stream_get_len(pack->input_stream);
}
VALUE c_server = fs_server_get_script_id(server);
VALUE byte_order = rb_funcall(c_server, rb_intern("byte_order"), 0);
struct fs_output_stream* fos = fs_create_output_stream_ext;
fs_stream_write_byte(fos, FIX2INT(byte_order));
fs_stream_write_int32(fos, (int32_t)len + pack_head_len);
fs_stream_write_data(fos, data, len);
size_t ret_len = fs_output_stream_get_len(fos);
*out = fs_malloc(ret_len);
memcpy(*out, fs_output_stream_get_dataptr(fos), ret_len);
fs_stream_free_output(fos);
if(len == 0){
rb_raise(rb_eRuntimeError, "try send data len for 0");
}
return ret_len;
}
void
libevent_cb_node_onsend_data(int socket, short event, void* arg){
struct fs_node* node = (struct fs_node*)arg;
pthread_mutex_lock(&node->write_mutex);
if(node->send_buffer == NULL)
{
event_del(node->write_ev);
pthread_mutex_unlock(&node->write_mutex);
return;
}
void* data = (void*)fs_output_stream_get_dataptr(node->send_buffer);
size_t len = fs_output_stream_get_len(node->send_buffer);
ssize_t nsize = len;
ssize_t nwrite = 0;
ssize_t nwrited = 0;
while (nsize > 0) {
nwrite = send(node->socket, (BYTE*)data + (len - nsize), nsize, 0);
if(nwrite > 0){
nwrited += nwrite;
}
if(nwrite < nsize){
if(nwrite == -1){
if(errno == EAGAIN)
{
break;
}else{
fprintf(stderr, "%d on send_data error = %d \n", node->node_id, errno);
pthread_mutex_unlock(&node->write_mutex);
fs_node_shudown(node);
return;
}
}
}
nsize -= nwrite;
}
fs_output_stream_sub(node->send_buffer, nwrited, len - nwrited);
len = fs_output_stream_get_len(node->send_buffer);
if(len == 0){
event_del(node->write_ev);
}
pthread_mutex_unlock(&node->write_mutex);
}
void
fs_node_recv_data(struct fs_node* node, BYTE* data, size_t len){
if(!node->recv_buffer){
fprintf(stderr, "fs_node_recv_data but node recvbuffer is NULL\n");
return ;
}
fs_stream_write_data(node->recv_buffer, data, len);
const BYTE* stream_data = fs_output_stream_get_dataptr(node->recv_buffer);
size_t stream_len = fs_output_stream_get_len(node->recv_buffer);
struct fs_pack* pack = NULL;
size_t offset = 0;
do{
pack = NULL;
if(node->server != NULL){
size_t pack_len = fs_server_parse_pack(node->server, stream_data + offset, stream_len - offset, node->node_id, &pack);
if(pack_len){
fs_server_on_recv_pack(node->server, pack);
}
offset += pack_len;
}
}while (pack != NULL);
if(offset > 0 && node->recv_buffer){
fs_output_stream_sub(node->recv_buffer, offset, stream_len - offset);
}
}
OS_WRITE_FUNC( rb_OStream_write_byte, fs_stream_write_byte, rb_to_int, FIX2INT, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_long, fs_stream_write_long, rb_to_int, NUM2LONG, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_ulong, fs_stream_write_ulong, rb_to_int, NUM2ULONG, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_int64, fs_stream_write_int64, rb_to_int, NUM2LL, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_uint64, fs_stream_write_uint64, rb_to_int, NUM2LL, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_int32, fs_stream_write_int32, rb_to_int, FIX2INT, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_int16, fs_stream_write_int16, rb_to_int, FIX2INT, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_uint32, fs_stream_write_uint32, rb_to_int, FIX2INT, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_uint16, fs_stream_write_uint16, rb_to_int, FIX2INT, T_FIXNUM, fs_false);
OS_WRITE_FUNC( rb_OStream_write_float, fs_stream_write_float, rb_to_float, RFLOAT_VALUE, T_FLOAT, fs_false);
OS_WRITE_FUNC( rb_OStream_write_double, fs_stream_write_double, rb_to_float, RFLOAT_VALUE, T_FLOAT, fs_false);
OS_WRITE_FUNC( rb_OStream_skip, fs_output_stream_skip_to, rb_to_int, FIX2INT, T_FIXNUM, fs_true);
OS_GETER_FUNC( rb_OStream_len, fs_output_stream_get_len, INT2FIX , size_t, ret);
OS_GETER_FUNC( rb_OStream_data, fs_output_stream_get_dataptr, (VALUE), const BYTE*, rb_str_new((const char*)ret, fs_output_stream_get_len(is)));
void
rb_define_fs_stream(){
rb_cInputStream = rb_define_class("FSInputStream", rb_cObject);
rb_define_alloc_func(rb_cInputStream, wrap_IStream_allocate);
rb_define_method(rb_cInputStream, "initialize", RUBY_METHOD_FUNC(rb_IStream_initialize), 3);
rb_define_method(rb_cInputStream, "len", RUBY_METHOD_FUNC(rb_IStream_len), 0);
rb_define_method(rb_cInputStream, "read_byte", RUBY_METHOD_FUNC(rb_IStream_read_byte), 0);
rb_define_method(rb_cInputStream, "read_int64", RUBY_METHOD_FUNC(rb_IStream_read_int64), 0);
rb_define_method(rb_cInputStream, "read_uint64", RUBY_METHOD_FUNC(rb_IStream_read_uint64), 0);
rb_define_method(rb_cInputStream, "read_int32", RUBY_METHOD_FUNC(rb_IStream_read_int32), 0);
rb_define_method(rb_cInputStream, "read_int16", RUBY_METHOD_FUNC(rb_IStream_read_int16), 0);
rb_define_method(rb_cInputStream, "read_uint32", RUBY_METHOD_FUNC(rb_IStream_read_uint32), 0);
