public void EndRequest(ushort requestID, int appStatus,
ProtocolStatus protocolStatus)
{
var body = new EndRequestBody(appStatus, protocolStatus);
try {
if (IsConnected)
{
byte[] bodyData = body.GetData();
CompatArraySegment <byte> bodyBuffer = send_buffers.EnforceBodyLength(bodyData.Length);
Array.Copy(bodyData, 0, bodyBuffer.Array, bodyBuffer.Offset, bodyData.Length);
var record = new NRecord(1, RecordType.EndRequest, requestID, bodyData.Length, send_buffers);
record.Send(socket);
}
} catch (System.Net.Sockets.SocketException) {
}
RemoveRequest(requestID);
lock (connection_teardown_lock) {
if (requests.Count == 0 && (!keep_alive || stop))
{
CloseSocket();
if (!stop)
{
server.EndConnection(this);
}
receive_buffers.Return();
send_buffers.Return();
}
}
}
public void Send(Socket socket)
{
var padding_size = (byte)((8 - (BodyLength % 8)) % 8);
CompatArraySegment <byte> header = buffers.EnforceHeaderLength(HeaderSize);
header [0] = version;
header [1] = (byte)type;
header [2] = (byte)(request_id >> 8);
header [3] = (byte)(request_id & 0xFF);
header [4] = (byte)(BodyLength >> 8);
header [5] = (byte)(BodyLength & 0xFF);
header [6] = padding_size;
CompatArraySegment <byte> padding = buffers.EnforcePaddingLength(padding_size);
for (int i = 0; i < padding_size; i++)
{
padding [i] = 0;
}
Logger.Write(LogLevel.Debug, Strings.Record_Sent, Type, RequestID, BodyLength);
SendAll(socket, header, HeaderSize);
SendAll(socket, buffers.Body, BodyLength);
SendAll(socket, padding, padding_size);
}
public void ReturnBuffer(CompatArraySegment <byte> buffer)
{
lock (bufferLock)
{
buffers.Push(buffer);
// TODO: if we have enough buffers we could release some
}
}
public void ReturnBuffer(CompatArraySegment<byte> buffer)
{
lock (bufferLock)
{
buffers.Push(buffer);
// TODO: if we have enough buffers we could release some
}
}
public void TestCase()
{
var test = new CompatArraySegment <int> (new int[1]);
IList <int> ilist = test;
test [0] = -3;
Assert.AreEqual(-3, ilist [0]);
}
public CompatArraySegment<byte> EnforceBodyLength(int length)
{
if (Body == null || Body.Value.Count < length) {
if (Body != null)
bigBufferManager.ReturnBuffer (Body.Value);
Body = new CompatArraySegment<byte> (new byte[length]);
}
return Body.Value;
}
public CompatArraySegment<byte> EnforceHeaderLength(int length)
{
if (Header == null || Header.Value.Count < length) {
if (Header != null)
smallBufferManager.ReturnBuffer (Header.Value);
Header = new CompatArraySegment<byte> (new byte[length]);
}
return Header.Value;
}
public CompatArraySegment <byte> EnforceBodyLength(int length)
{
if (Body == null || Body.Value.Count < length)
{
if (Body != null)
{
bigBufferManager.ReturnBuffer(Body.Value);
}
Body = new CompatArraySegment <byte> (new byte[length]);
}
return(Body.Value);
}
public CompatArraySegment <byte> EnforcePaddingLength(int length)
{
if (Padding == null || Padding.Value.Count < length)
{
if (Padding != null)
{
smallBufferManager.ReturnBuffer(Padding.Value);
}
Padding = new CompatArraySegment <byte> (new byte[length]);
}
return(Padding.Value);
}
public CompatArraySegment <byte> EnforceHeaderLength(int length)
{
if (Header == null || Header.Value.Count < length)
{
if (Header != null)
{
smallBufferManager.ReturnBuffer(Header.Value);
}
Header = new CompatArraySegment <byte> (new byte[length]);
}
return(Header.Value);
}
public Buffers (BufferManager bigBufferManager, BufferManager smallBufferManager)
{
if (bigBufferManager == null)
throw new ArgumentNullException ("bigBufferManager");
if (smallBufferManager == null)
throw new ArgumentNullException ("smallBufferManager");
this.bigBufferManager = bigBufferManager;
this.smallBufferManager = smallBufferManager;
Header = smallBufferManager.ClaimBuffer ();
Body = bigBufferManager.ClaimBuffer ();
Padding = smallBufferManager.ClaimBuffer ();
}
public void TestCase ()
{
var test = new CompatArraySegment<int> (new int[1]);
test [0] = -3;
Assert.AreEqual (-3, test [0]);
try {
var test2 = new CompatArraySegment<int> (new int[1]);
test2 [1] = 0;
Assert.Fail ("Out of range access");
} catch (ArgumentOutOfRangeException) {
}
}
public void TestCase()
{
var test = new CompatArraySegment <int> (new int[1]);
test [0] = -3;
Assert.AreEqual(-3, test [0]);
try {
var test2 = new CompatArraySegment <int> (new int[1]);
test2 [1] = 0;
Assert.Fail("Out of range access");
} catch (ArgumentOutOfRangeException) {
}
}
static void SendAll(Socket socket, CompatArraySegment <byte>?data, int length)
{
if (length <= 0 || data == null)
{
return;
}
int total = 0;
while (total < length)
{
total += socket.Send(data.Value.Array, data.Value.Offset + total,
length - total, System.Net.Sockets.SocketFlags.None);
}
}
static void ReceiveAll(Socket socket, CompatArraySegment <byte> data, int length)
{
if (length <= 0)
{
return;
}
int total = 0;
while (total < length)
{
total += socket.Receive(data.Array, total + data.Offset,
length - total,
System.Net.Sockets.SocketFlags.None);
}
}
public void SendRecord(RecordType type, ushort requestID,
byte [] bodyData, int bodyIndex,
int bodyLength)
{
if (IsConnected)
{
lock (send_lock) {
try {
CompatArraySegment <byte> body = send_buffers.EnforceBodyLength(bodyLength);
Array.Copy(bodyData, bodyIndex, body.Array, body.Offset, bodyLength);
var record = new NRecord(1, type, requestID, bodyLength, send_buffers);
record.Send(socket);
} catch (System.Net.Sockets.SocketException) {
}
}
}
}
public Buffers(BufferManager bigBufferManager, BufferManager smallBufferManager)
{
if (bigBufferManager == null)
{
throw new ArgumentNullException("bigBufferManager");
}
if (smallBufferManager == null)
{
throw new ArgumentNullException("smallBufferManager");
}
this.bigBufferManager = bigBufferManager;
this.smallBufferManager = smallBufferManager;
Header = smallBufferManager.ClaimBuffer();
Body = bigBufferManager.ClaimBuffer();
Padding = smallBufferManager.ClaimBuffer();
}
public static Process SpawnOndemandChild(string socketFile)
{
CompatArraySegment <byte>?torelease = null;
try {
Logger.Write(LogLevel.Debug, "Spawning via the shim {0}", socketFile);
var client = new UnixClient();
client.Connect(socketFile);
CompatArraySegment <byte> buffer = buffers.ClaimBuffer();
torelease = buffer;
int receivedCount;
using (NetworkStream socket = client.GetStream()) {
socket.Write(spawnString, 0, spawnString.Length);
receivedCount = socket.Read(buffer.Array, buffer.Offset, buffer.Count);
if (receivedCount < 0)
{
throw new Exception("Didn't receive the child pid");
}
}
string received = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, receivedCount);
string clean = received.Trim();
int pid;
if (!Int32.TryParse(clean, out pid))
{
throw new Exception("Couldn't parse the pid \"" + clean + "\"");
}
if (pid < 0)
{
throw new Exception("Invalid pid: " + pid);
}
return(Process.GetProcessById(pid));
} catch (Exception e) {
Logger.Write(LogLevel.Error, "Error while talking to the shim for socket file {0}", socketFile);
Logger.Write(e);
return(null);
} finally {
if (torelease != null)
{
buffers.ReturnBuffer(torelease.Value);
}
}
}
internal static void SendAll(Socket socket, CompatArraySegment <byte>?data, int length)
{
if (length <= 0 || data == null)
{
return;
}
int total = 0;
while (total < length)
{
int written = socket.Send(data.Value.Array, data.Value.Offset + total,
length - total, System.Net.Sockets.SocketFlags.None);
if (written <= 0)
{
throw new System.Net.Sockets.SocketException();
}
total += written;
}
}
internal static void ReceiveAll(Socket socket, CompatArraySegment <byte> data, int length)
{
if (length <= 0)
{
return;
}
int total = 0;
while (total < length)
{
int read = socket.Receive(data.Array, total + data.Offset,
length - total,
System.Net.Sockets.SocketFlags.None);
if (read <= 0)
{
throw new System.Net.Sockets.SocketException();
}
total += read;
}
}
public Record(Socket socket, Buffers receive_buffer) : this()
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
CompatArraySegment <byte> header_buffer = receive_buffer.EnforceHeaderLength(HeaderSize);
// Read the 8 byte record header.
ReceiveAll(socket, header_buffer, HeaderSize);
// Read the values from the data.
version = header_buffer [0];
type = (RecordType)header_buffer [1];
request_id = ReadUInt16(header_buffer, 2);
BodyLength = ReadUInt16(header_buffer, 4);
byte padding_length = header_buffer [6];
CompatArraySegment <byte> body_buffer = receive_buffer.EnforceBodyLength(BodyLength);
// Read the record data, and throw an exception if the
// complete data cannot be read.
if (BodyLength > 0)
{
ReceiveAll(socket, body_buffer, BodyLength);
}
CompatArraySegment <byte> padding_buffer = receive_buffer.EnforcePaddingLength(padding_length);
if (padding_length > 0)
{
ReceiveAll(socket, padding_buffer, padding_length);
}
buffers = receive_buffer;
Logger.Write(LogLevel.Debug, Strings.Record_Received, Type, RequestID, BodyLength);
}
public static Record Receive(Socket socket, Buffers buffers)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
CompatArraySegment <byte> header_buffer = buffers.EnforceHeaderLength(HEADER_SIZE);
// Read the 8 byte record header.
ReceiveAll(socket, header_buffer, HEADER_SIZE);
// Read the values from the data.
var version = header_buffer [0];
var type = (RecordType)header_buffer [1];
var requestID = ReadUInt16(header_buffer, 2);
var bodyLength = ReadUInt16(header_buffer, 4);
byte padding_length = header_buffer [6];
CompatArraySegment <byte> body_buffer = buffers.EnforceBodyLength(bodyLength);
// Read the record data, and throw an exception if the
// complete data cannot be read.
if (bodyLength > 0)
{
ReceiveAll(socket, body_buffer, bodyLength);
}
CompatArraySegment <byte> padding_buffer = buffers.EnforcePaddingLength(padding_length);
if (padding_length > 0)
{
ReceiveAll(socket, padding_buffer, padding_length);
}
Logger.Write(LogLevel.Debug, Strings.Record_Received, type, requestID, bodyLength);
return(new Record(version, type, requestID, bodyLength, buffers));
}
public void Return()
{
if (smallBufferManager != null)
{
if (Header != null)
{
smallBufferManager.ReturnBuffer(Header.Value);
Header = null;
}
if (Padding != null)
{
smallBufferManager.ReturnBuffer(Padding.Value);
Padding = null;
}
}
if (bigBufferManager == null || Body == null)
{
return;
}
bigBufferManager.ReturnBuffer(Body.Value);
Body = null;
}
public Buffers(byte[] buffer, int headerSize, int bodySize) : this()
{
Header = MaybeSegment(buffer, 0, headerSize);
Body = MaybeSegment(buffer, headerSize, bodySize);
Padding = MaybeSegment(buffer, headerSize + bodySize);
}
public Buffers (byte[] buffer, int headerSize, int bodySize)
{
Header = MaybeSegment (buffer, 0, headerSize);
Body = MaybeSegment (buffer, headerSize, bodySize);
Padding = MaybeSegment (buffer, headerSize + bodySize);
}
internal static void ReceiveAll (Socket socket, CompatArraySegment<byte> data, int length)
{
if (length <= 0)
return;
int total = 0;
while (total < length) {
total += socket.Receive (data.Array, total + data.Offset,
length - total,
System.Net.Sockets.SocketFlags.None);
}
}
internal static void SendAll (Socket socket, CompatArraySegment<byte>? data, int length)
{
if (length <= 0 || data == null)
return;
int total = 0;
while (total < length) {
total += socket.Send (data.Value.Array, data.Value.Offset + total,
length - total, System.Net.Sockets.SocketFlags.None);
}
}
public void Return()
{
if (smallBufferManager != null) {
if (Header != null) {
smallBufferManager.ReturnBuffer (Header.Value);
Header = null;
}
if (Padding != null) {
smallBufferManager.ReturnBuffer (Padding.Value);
Padding = null;
}
}
if (bigBufferManager == null || Body == null)
return;
bigBufferManager.ReturnBuffer (Body.Value);
Body = null;
}
public CompatArraySegment<byte> EnforcePaddingLength(int length)
{
if (Padding == null || Padding.Value.Count < length) {
if (Padding != null)
smallBufferManager.ReturnBuffer (Padding.Value);
Padding = new CompatArraySegment<byte> (new byte[length]);
}
return Padding.Value;
}
