private byte[] core_open_stream_channel(byte[] args)
{
List <byte> request = new List <byte>(args);
int stream_id = Struct.extractInt32(request);
byte passthrough_byte = Struct.extractByte(request);
bool passthrough = false;
if (passthrough_byte == 1)
{
passthrough = true;
}
// check if stream is present
bool exists = this.hasStream(stream_id);
if (!exists)
{
throw new Exception(String.Format("Stream with ID '{0}' doesn't exist", stream_id));
}
// create stream channel
Stream stream = this.getStream(stream_id);
StreamChannel sc = new StreamChannel(stream, this.callbackChannelOutputPresent, this.triggerProcessingNeeded, passthrough);
//add stream channel to transport layer channels
this.AddChannel(sc);
//return stream id
UInt32 result = sc.ID;
List <byte> response = Struct.packUInt32(result);
return(response.ToArray());
}
private byte[] core_fs_close_stream(byte[] args)
{
List <byte> request = new List <byte>(args);
int stream_id = Struct.extractInt32(request);
// check if stream is present
bool exists = this.hasStream(stream_id);
if (!exists)
{
throw new Exception(String.Format("Stream with ID '{0}' doesn't exist", stream_id));
}
// close stream channel
Stream stream = this.getStream(stream_id);
stream.Dispose();
stream.Close();
Console.WriteLine(String.Format("Stream object with ID {0} closed.", stream_id));
this.removeStream(stream_id);
//return stream id
Int32 result = stream_id;
List <byte> response = Struct.packInt32(result);
return(response.ToArray());
}
private void dispatchControlMessage(List <byte> msg)
{
/*
* This method is called from the input thread (not the processing thread), so time consuming or
* blocking tasks mustn't be run here
*/
CH_MSG_TYPE ch_msg_type = (CH_MSG_TYPE)Struct.extractUInt32(msg);
switch (ch_msg_type)
{
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_STATE:
Console.WriteLine(String.Format("Received STATE request for StreamChannel {0}", this.ID));
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_FLUSH:
Console.WriteLine(String.Format("Received FLUSH request for StreamChannel {0}", this.ID));
stream.Flush();
//return message, stating that everything has been written (should be handed by output thread)
List <byte> flush_response = Struct.packUInt32((UInt32)StreamChannel.CH_MSG_TYPE.CHANNEL_CONTROL_INFORM_FLUSH_SUCCEEDED);
this.writeControlMessage(flush_response);
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_CLOSE:
Console.WriteLine(String.Format("Received CLOSE request for StreamChannel {0}", this.ID));
this.shouldBeClosed = true; //no processing overhead
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_POSITION:
Console.WriteLine(String.Format("Received POSITION request for StreamChannel {0}", this.ID));
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_LENGTH:
Console.WriteLine(String.Format("Received LENGTH request for StreamChannel {0}", this.ID));
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_READ_TIMEOUT:
Console.WriteLine(String.Format("Received READ_TIMEOUT request for StreamChannel {0}", this.ID));
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_WRITE_TIMEOUT:
Console.WriteLine(String.Format("Received WRITE_TIMEOUT request for StreamChannel {0}", this.ID));
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_SEEK:
int offset = Struct.extractInt32(msg);
int origin = Struct.extractInt32(msg);
Console.WriteLine(String.Format("Received SEEK request for StreamChannel {0}, count {1}, timeout {2}", this.ID, offset, origin));
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_WRITE:
int size = Struct.extractInt32(msg);
byte[] data_to_write = msg.ToArray();
//the data shouldn't be written from this thread, so the operation has to be moved to processing thread
this.stream.Write(data_to_write, 0, data_to_write.Length);
//return message, stating that everything has been written (should be handed by output thread)
List <byte> write_response = Struct.packUInt32((UInt32)StreamChannel.CH_MSG_TYPE.CHANNEL_CONTROL_INFORM_WRITE_SUCCEEDED);
write_response = Struct.packInt32(data_to_write.Length, write_response);
this.writeControlMessage(write_response);
break;
case CH_MSG_TYPE.CHANNEL_CONTROL_REQUEST_READ:
int count = Struct.extractInt32(msg);
int timeout = Struct.extractInt32(msg);
Console.WriteLine(String.Format("Received READ request for StreamChannel {0}, count {1}, timeout {2}", this.ID, count, timeout));
//the data shouldn't be readen from this thread, blocking would stop the input thread (has to be done from processing thread
if (this.readbuf.Length < count)
{
this.readbuf = new byte[count]; //resize read buffer if needed
}
int read_size = this.stream.Read(this.readbuf, 0, count);
List <Byte> read_data = new List <byte>(this.readbuf);
read_data.RemoveRange(read_size, this.readbuf.Length - read_size);
//return message, stating legngth of read data and the data itself (should be handed by output thread)
List <byte> read_response = Struct.packUInt32((UInt32)StreamChannel.CH_MSG_TYPE.CHANNEL_CONTROL_INFORM_READ_SUCCEEDED);
read_response = Struct.packInt32(read_size, read_response);
read_response.AddRange(read_data);
this.writeControlMessage(read_response);
break;
default:
Console.WriteLine(String.Format("Received unknown channel message for StreamChannel {0}", this.ID));
break;
}
}