/// <summary>
/// Send Service Initialize Command respose on optimal path if exception occured only for newer clients 4610.
/// Backward compability handled for older version client.
/// </summary>
/// <param name="unOptBuffer"></param>
/// <returns></returns>
private IList GetOptimizedResponse(IList unOptBuffer)
{
if (cmdInfo.clientVersion < 4610)
{
return(unOptBuffer);
}
using (ClusteredMemoryStream stream = new ClusteredMemoryStream())
{
byte[] dataSzBytes = new byte[ConnectionManager.MessageSizeHeader];
stream.Write(dataSzBytes, 0, ConnectionManager.MessageSizeHeader);
int len = 0;
foreach (byte[] buffBytes in unOptBuffer)
{
stream.Write(buffBytes, 0, buffBytes.Length);
len += buffBytes.Length;
}
byte[] lengthBytes = HelperFxn.ToBytes(len.ToString());
stream.Seek(0, SeekOrigin.Begin);
stream.Write(lengthBytes, 0, lengthBytes.Length);
return(stream.GetInternalBuffer());
}
}
/// <summary>
/// Reads a single single response from the stream and processes it.
/// </summary>
/// <param name="stream"></param>
private void ProcessResponse(byte[] cmdBytes)
{
Response response;
using (Stream tempStream = new ClusteredMemoryStream(cmdBytes))
{
response = ProtoBuf.Serializer.Deserialize <Response>(tempStream);
}
CommandResponse cmdRespose = null;
if (response != null)
{
cmdRespose = new CommandResponse(false, new Address());
cmdRespose.CacheId = _cacheId;
cmdRespose.Result = response;
}
if (_perfStatsColl.IsEnabled)
{
_perfStatsColl.IncrementClientResponsesPerSecStats(1);
}
if (cmdRespose != null)
{
_container.ProcessResponse(cmdRespose, _serverAddress);
}
}
public static string DecryptText(string encryptedText)
{
byte[] decryptedBytes;
byte[] bytesToBeDecrypted = Convert.FromBase64String(encryptedText);
byte[] saltBytes = { 1, 2, 3, 4, 5, 6, 7, 8 };
using (var ms = new ClusteredMemoryStream())
{
using (var aes = new RijndaelManaged())
{
aes.KeySize = 256;
aes.BlockSize = 128;
var encryptionKeyBytes = Encoding.UTF8.GetBytes(s_iv);
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(encryptionKeyBytes, saltBytes, 1000);
aes.Key = key.GetBytes(aes.KeySize / 8);
aes.IV = key.GetBytes(aes.BlockSize / 8);
aes.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(bytesToBeDecrypted, 0, bytesToBeDecrypted.Length);
cs.Close();
}
decryptedBytes = ms.ToArray();
}
}
return(Encoding.UTF8.GetString(decryptedBytes));
}
/// <summary>
/// Deserializes the binary representation of an object.
/// </summary>
/// <param name="buffer">binary representation of the object</param>
/// <returns>deserialized object</returns>
static public object FromByteBuffer(byte[] buffer, string cacheContext)
{
using (var stream = new ClusteredMemoryStream(buffer))
{
return(Deserialize(stream, cacheContext));
}
}
private void InitializePerviouslyStoredCollections()
{
//needed to ensure that internalMetadataCollection exists so that argument exception is not thrown by LMDB.
_collectionTable[METADATA_COLLECTION] = new LMDBCollection(CreateCollectionInternal(METADATA_COLLECTION, typeof(string)));
//ITransaction transaction = BeginTransaction(null, true);
StorageResult <byte[]> result = GetDocument <string, byte[]>(METADATA_COLLECTION, "collections");
if (result.Document != null)
{
Dictionary <string, LMDBCollection> collectionList;
using (ClusteredMemoryStream ms = new ClusteredMemoryStream(result.Document))
{
using (CompactReader reader = new CompactBinaryReader(ms))
{
collectionList = SerializationUtility.DeserializeDictionary <string, LMDBCollection>(reader);
}
}
foreach (var col in collectionList)
{
CreateCollection(col.Key, null, null);
if (LoggerManager.Instance.StorageLogger != null && LoggerManager.Instance.StorageLogger.IsInfoEnabled)
{
LoggerManager.Instance.StorageLogger.Info("LMDB.Initialize", "Previously stored collection :" + col.Key + " initialized successfully. ");
}
_collectionTable[col.Key].Stats.DataSize = col.Value.Stats.DataSize;
_collectionTable[col.Key].Stats.DocumentCount = col.Value.Stats.DocumentCount;
}
}
}
/// <summary>
/// Serializes an object and returns its binary representation.
/// </summary>
/// <param name="graph">object to serialize</param>
/// <returns>binary form of object</returns>
static public byte[] ToByteBuffer(object graph, string cacheContext)
{
using (var stream = new ClusteredMemoryStream())
{
Serialize(stream, graph, cacheContext);
return(stream.ToArray());
}
}
/// <summary>
/// Reads a single single response from the stream and processes it.
/// </summary>
/// <param name="stream"></param>
private void ProcessResponse(Stream stream)
{
Response response;
long requestId = 0;
if (WriteRequestIdInResponse)
{
byte[] requestIdBytes = new byte[sizeof(long)];
stream.Read(requestIdBytes, 0, requestIdBytes.Length);
requestId = BitConverter.ToInt64(requestIdBytes, 0);
}
byte[] responseTypeBytes = new byte[2];
stream.Read(responseTypeBytes, 0, responseTypeBytes.Length);
Response.Type responseType = (Response.Type)BitConverter.ToInt16(responseTypeBytes, 0);
//Reading a response's header...
byte[] cmdSzBytes = new byte[CmdSizeHolderBytesCount];
stream.Read(cmdSzBytes, 0, CmdSizeHolderBytesCount);
int commandSize = HelperFxn.ToInt32(cmdSzBytes, 0, CmdSizeHolderBytesCount);
byte[] cmdBytes = new byte[commandSize];
stream.Read(cmdBytes, 0, commandSize);
CommandResponse cmdRespose = new CommandResponse(false, new Address());
cmdRespose.CacheId = _cacheId;
cmdRespose.Src = this.ServerAddress;
if (WriteRequestIdInResponse)
{
cmdRespose.NeedsDeserialization = true;
cmdRespose.RequestId = requestId;
cmdRespose.SerializedResponse = cmdBytes;
cmdRespose.Type = responseType;
}
else
{
using (Stream tempStream = new ClusteredMemoryStream(cmdBytes))
response = ResponseHelper.DeserializeResponse(responseType, tempStream);
cmdRespose.NeedsDeserialization = false;
if (response != null)
{
cmdRespose.Result = response;
}
}
if (_perfStatsColl.IsEnabled)
{
_perfStatsColl.IncrementClientResponsesPerSecStats(1);
}
if (cmdRespose != null)
{
_container.ProcessResponse(cmdRespose, _serverAddress);
}
}
private void RecieveThread(object clientSocket)
{
while (true)
{
try
{
byte[] cmdBytes;
Socket client = null;
if (clientSocket != null && clientSocket is Socket)
{
client = clientSocket as Socket;
}
cmdBytes = AssureRecieve(client, false);
using (Stream tempStream = new ClusteredMemoryStream(cmdBytes))
{
tempStream.Position = 0;
while (tempStream.Position < tempStream.Length)
{
ProcessResponse(tempStream);
}
}
}
catch (SocketException se)
{
OnConnectionBroken(se, ExType.Socket);
break;
}
catch (IOException ie)
{
//System.IOException is going to thrown in the case SslStream when the connection gets forcibly closed.
//Thus we are going to handle it as a SocketException....
OnConnectionBroken(ie, ExType.Socket);
break;
}
catch (ConnectionException ce)
{
OnConnectionBroken(ce, ExType.Connection);
break;
}
catch (ThreadAbortException te)
{
OnConnectionBroken(te, ExType.Abort);
break;
}
catch (ThreadInterruptedException tae)
{
OnConnectionBroken(tae, ExType.Interrupt);
break;
}
catch (Exception e)
{
OnConnectionBroken(e, ExType.General);
}
}
}
internal static IList serializeMessage(Message msg)
{
int len = 0;
byte[] buffie;
FlagsByte flags = new FlagsByte();
msg.Dest = null;
msg.Dests = null;
RequestCorrelatorHDR rqHeader = (RequestCorrelatorHDR)msg.getHeader(HeaderType.REQUEST_COORELATOR);
if (rqHeader != null)
{
rqHeader.serializeFlag = false;
}
ClusteredMemoryStream stmOut = new ClusteredMemoryStream();
stmOut.Write(Util.WriteInt32(len), 0, 4);
stmOut.Write(Util.WriteInt32(len), 0, 4);
if (msg.IsUserMsg)
{
BinaryWriter msgWriter = new BinaryWriter(stmOut, new UTF8Encoding(true));
flags.SetOn(FlagsByte.Flag.TRANS);
msgWriter.Write(flags.DataByte);
msg.SerializeLocal(msgWriter);
}
else
{
flags.SetOff(FlagsByte.Flag.TRANS);
stmOut.WriteByte(flags.DataByte);
CompactBinaryFormatter.Serialize(stmOut, msg, null, false);
}
len = (int)stmOut.Position - 4;
int payloadLength = 0;
// the user payload size. payload is passed on untill finally send on the socket.
if (msg.Payload != null)
{
for (int i = 0; i < msg.Payload.Length; i++)
{
payloadLength += ((byte[])msg.Payload.GetValue(i)).Length;
}
len += payloadLength;
}
stmOut.Position = 0;
stmOut.Write(Util.WriteInt32(len), 0, 4);
stmOut.Write(Util.WriteInt32(len - 4 - payloadLength), 0, 4);
return(stmOut.GetInternalBuffer());
}
/// <summary>
/// Decompresses a stream of compressed bytes using DeflateStream
/// </summary>
/// <param name="inputStream">A Seekable Stream</param>
/// <returns></returns>
public static ClusteredMemoryStream Decompress(Stream inputStream)
{
var ms = new ClusteredMemoryStream();
using (var decompressor = new DeflateStream(inputStream, CompressionMode.Decompress, true))
{
decompressor.CopyTo(ms);
inputStream.Dispose();
}
ms.Seek(0, SeekOrigin.Begin);
return(ms);
}
// Encrypt the string.
public static byte[] Encrypt(string PlainText)
{
try
{
if (PlainText == null)
{
return(null);
}
s_des = new TripleDESCryptoServiceProvider();
int block = s_des.BlockSize;
int j = s_des.KeySize;
//s_iv = RandomString(block);
byte[] k = ConvertStringToByteArray(s_key);
byte[] iv = ConvertStringToByteArray(s_iv);
//s_des.Key = ConvertStringToByteArray(s_key);
//s_des.IV = ConvertStringToByteArray(s_iv);
// Create a memory stream.
ClusteredMemoryStream ms = new ClusteredMemoryStream();
// Create a CryptoStream using the memory stream and the
// CSP DES key.
CryptoStream encStream = new CryptoStream(ms, s_des.CreateEncryptor(k, iv), CryptoStreamMode.Write);
// Create a StreamWriter to write a string
// to the stream.
StreamWriter sw = new StreamWriter(encStream);
// Write the plaintext to the stream.
sw.WriteLine(PlainText);
// Close the StreamWriter and CryptoStream.
sw.Close();
encStream.Close();
// Get an array of bytes that represents
// the memory stream.
byte[] buffer = ms.ToArray();
// Close the memory stream.
ms.Close();
// Return the encrypted byte array.
return(buffer);
}
catch (Exception exception)
{
throw exception;
}
return(null);
}
private JSONDocument DeserializeDocument(byte[] data)
{
var stream = new ClusteredMemoryStream(data);
int header = stream.ReadByte();
if ((header & (long)PersistenceBits.Compressed) == (decimal)PersistenceBits.Compressed)
{
stream = CompressionUtil.Decompress(stream);
}
var document = JSONDocument.Deserialize(stream);// CompactBinaryFormatter.Deserialize(stream, string.Empty);
stream.Dispose();
return(document as JSONDocument);
}
public bool SendMessage(object message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
//first serialize the message using channel formatter
byte[] serailizedMessage = _formatter.Serialize(message);
byte[] msgLength = UTF8Encoding.UTF8.GetBytes(serailizedMessage.Length.ToString());
//message is written in a specific order as expected by Socket server
ClusteredMemoryStream stream = new ClusteredMemoryStream();
//stream.Position = 20;//skip discarding buffer
stream.Write(msgLength, 0, msgLength.Length);
stream.Position = 10;
stream.Write(serailizedMessage, 0, serailizedMessage.Length);
byte[] finalBuffer = stream.ToArray();
stream.Close();
try
{
if (EnsureConnected())
{
try
{
_connection.Send(finalBuffer, 0, finalBuffer.Length);
return(true);
}
catch (ConnectionException)
{
if (EnsureConnected())
{
_connection.Send(finalBuffer, 0, finalBuffer.Length);
return(true);
}
}
}
}
catch (Exception e)
{
throw new ChannelException(e.Message, e);
}
return(false);
}
private void DeserializeRawResponsesIfPresent()
{
if (_rawResponses != null && _rawResponses.Count > 0)
{
for (int i = 0; i < _rawResponses.Count; i++)
{
CommandResponse respnse = _rawResponses[i];
using (Stream tempStream = new ClusteredMemoryStream(respnse.SerializedResponse))
respnse.Result = ResponseHelper.DeserializeResponse(respnse.Type, tempStream);
respnse.NeedsDeserialization = false;
AddResponse(respnse.Src, respnse);
}
_rawResponses.Clear();
}
}
public static ClusteredArrayList SerializeResponse(Alachisoft.NCache.Common.Protobuf.ManagementResponse command)
{
using (ClusteredMemoryStream stream = new ClusteredMemoryStream())
{
//TODO
byte[] size = new byte[10];
stream.Write(size, 0, size.Length);
Serializer.Serialize <Alachisoft.NCache.Common.Protobuf.ManagementResponse>(stream, command);
int messageLen = (int)stream.Length - size.Length;
size = UTF8Encoding.UTF8.GetBytes(messageLen.ToString());
stream.Position = 0;
stream.Write(size, 0, size.Length);
ClusteredArrayList byteList = stream.GetInternalBuffer();
return(byteList);
}
}
/// <summary>
/// Encrypt user provided key with the default key stored; This key is obfuscated
/// </summary>
/// <param name="key">Key</param>
/// <returns>encrypted string</returns>
internal static byte[] EncryptData(byte[] data)
{
try
{
//byte[] data = ASCIIEncoding.ASCII.GetBytes(key);
s_des = new TripleDESCryptoServiceProvider();
int i = s_des.BlockSize;
int j = s_des.KeySize;
byte[] k = ConvertStringToByteArray(s_key);
byte[] IV = ConvertStringToByteArray(s_iv);
//s_des.Key = ConvertStringToByteArray(key);
//s_des.IV = ConvertStringToByteArray(s_iv);
// Create a memory stream.
ClusteredMemoryStream ms = new ClusteredMemoryStream();
// Create a CryptoStream using the memory stream and the
// CSP DES key.
CryptoStream encStream = new CryptoStream(ms, s_des.CreateEncryptor(k, IV), CryptoStreamMode.Write);
encStream.Write(data, 0, data.Length);
encStream.FlushFinalBlock();
// Get an array of bytes from the
// MemoryStream that holds the
// encrypted data.
byte[] ret = ms.ToArray();
// Close the memory stream.
ms.Close();
encStream.Close();
// Return the encrypted byte array.
//string temp = Convert.ToBase64String(ret, Base64FormattingOptions.None);
// temp = System.Security.SecurityElement.Escape(temp);
return(ret);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Stores the collection info to Disk, If collection is Null then stores the current Collection created
/// </summary>
/// <param name="collection">Store This collection along with current collections</param>
/// <param name="transaction">provide a writer transaction to store data</param>
private void StoreCollectionInfo(string collection, ITransaction transaction)
{
Dictionary <string, LMDBCollection> tobeStored = new Dictionary <string, LMDBCollection>();
foreach (KeyValuePair <string, LMDBCollection> lmdbCollection in _collectionTable)
{
tobeStored.Add(lmdbCollection.Key, (LMDBCollection)lmdbCollection.Value.Clone());
}
if (!string.IsNullOrEmpty(collection) && !tobeStored.ContainsKey(collection))
{
tobeStored.Add(collection, new LMDBCollection(null));
}
using (ClusteredMemoryStream stream = new ClusteredMemoryStream())
{
using (CompactWriter writer = new CompactBinaryWriter(stream))
{
SerializationUtility.SerializeDictionary <string, LMDBCollection>(tobeStored, writer);
UpdateDocumentInternal(transaction, METADATA_COLLECTION, "collections", stream.ToArray());
}
}
}
public static object DeserailizeResponse(object response, string context)
{
object result = null;
if (response is byte[])
{
result = CompactBinaryFormatter.FromByteBuffer((byte[])response, context);
}
else if (response is IList)
{
IList buffers = response as IList;
ClusteredMemoryStream stream = new ClusteredMemoryStream(0);
foreach (byte[] buffer in buffers)
{
stream.Write(buffer, 0, buffer.Length);
}
stream.Position = 0;
result = CompactBinaryFormatter.Deserialize(stream, context);
}
return(result);
}
private byte[] SerializeDocument(JSONDocument document)
{
Stream stream = new ClusteredMemoryStream();
JSONDocument.Serialize(stream, document);
stream.Position = 0;
if (enableCompression)
{
stream = CompressionUtil.Compress(stream);
}
var array = new byte[stream.Length + 1];
if (enableCompression)
{
array[0] |= (byte)PersistenceBits.Compressed;
}
stream.Read(array, 1, (int)stream.Length);
stream.Dispose();
return(array);
}
/// <summary>
/// Reads a single single response from the stream and processes it.
/// </summary>
/// <param name="stream"></param>
private void ProcessResponse(Stream stream)
{
Response response;
//Reading a response's header...
byte[] cmdSzBytes = new byte[CmdSizeHolderBytesCount];
stream.Read(cmdSzBytes, 0, CmdSizeHolderBytesCount);
int commandSize = HelperFxn.ToInt32(cmdSzBytes, 0, CmdSizeHolderBytesCount);
byte[] cmdBytes = new byte[commandSize];
stream.Read(cmdBytes, 0, commandSize);
using (Stream tempStream = new ClusteredMemoryStream(cmdBytes))
{
response = ProtoBuf.Serializer.Deserialize <Response>(tempStream);
}
CommandResponse cmdRespose = null;
if (response != null)
{
cmdRespose = new CommandResponse(false, new Address());
cmdRespose.CacheId = _cacheId;
cmdRespose.Result = response;
}
if (_perfStatsColl.IsEnabled)
{
_perfStatsColl.IncrementClientResponsesPerSecStats(1);
}
if (cmdRespose != null)
{
_container.ProcessResponse(cmdRespose, _serverAddress);
}
}
public static byte[] DecryptData(byte[] encodedData)
{
try
{
// byte[] data = Convert.FromBase64String(encodedkey);
s_des = new TripleDESCryptoServiceProvider();
byte[] k = ConvertStringToByteArray(s_key);
byte[] IV = ConvertStringToByteArray(s_iv);
// Create a memory stream to the passed buffer.
ClusteredMemoryStream ms = new ClusteredMemoryStream(encodedData);
// Create a CryptoStream using the memory stream and the
// CSP DES key.
CryptoStream encStream = new CryptoStream(ms, s_des.CreateDecryptor(k, IV), CryptoStreamMode.Read);
byte[] fromEncrypt = new byte[encodedData.Length];
// Read the decrypted data out of the crypto stream
// and place it into the temporary buffer.
int length = encStream.Read(fromEncrypt, 0, fromEncrypt.Length);
// Close the streams.
encStream.Close();
ms.Close();
byte[] ret = new byte[length];
Array.Copy(fromEncrypt, ret, length);
return(ret);//ASCIIEncoding.ASCII.GetString(ret);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>Removes events from mq and calls handler.down(evt) </summary>
override public void Run()
{
bool connectionCloseNotified = false;
try
{
ArrayList msgList = new ArrayList();
byte[] tmpBuffer = null;
int totalMsgSize = 4;
int noOfMsgs = 0;
int offset = 8;
bool resendMessage = false;
ArrayList msgsTobeSent = new ArrayList();
ClusteredMemoryStream stream = null;
while (!mq.Closed)
{
try
{
if (resendMessage)
{
if (stream != null && stream.Length > 0)
{
peerConnection.send(stream.GetInternalBuffer(), null, totalMsgSize + 4);
}
resendMessage = false;
continue;
}
msgsTobeSent.Clear();
stream = new ClusteredMemoryStream();
lock (sync_lock)
{
tmpBuffer = sendBuffer;
totalMsgSize = 4;
noOfMsgs = 0;
offset = 8;
stream.Seek(8, System.IO.SeekOrigin.Begin);
BinaryMessage bMsg = (BinaryMessage)mq.remove();
if (bMsg != null)
{
if (!peerConnection.IsPrimary)
{
msgsTobeSent.Add(bMsg);
}
noOfMsgs++;
totalMsgSize += bMsg.Size;
foreach (byte[] buffer in bMsg.Buffer)
{
stream.Write(buffer, 0, buffer.Length);
}
if (bMsg.UserPayLoad != null)
{
byte[] buf = null;
for (int i = 0; i < bMsg.UserPayLoad.Length; i++)
{
buf = bMsg.UserPayLoad.GetValue(i) as byte[];
stream.Write(buf, 0, buf.Length);
offset += buf.Length;
}
}
}
bMsg = null;
}
byte[] bTotalLength = Util.Util.WriteInt32(totalMsgSize);
stream.Seek(0, System.IO.SeekOrigin.Begin);
stream.Write(bTotalLength, 0, bTotalLength.Length);
byte[] bNoOfMsgs = Util.Util.WriteInt32(noOfMsgs);
stream.Write(bNoOfMsgs, 0, bNoOfMsgs.Length);
peerConnection.send(stream.GetInternalBuffer(), null, totalMsgSize + 4);
stream = null;
}
catch (ExtSocketException e)
{
connectionCloseNotified = false;
NCacheLog.Error(Name, e.ToString());
if (peerConnection.IsPrimary)
{
if (peerConnection.LeavingGracefully)
{
NCacheLog.Error("DmSender.Run", peerConnection.peer_addr + " left gracefully");
break;
}
NCacheLog.Error("DMSender.Run", "Connection broken with " + peerConnection.peer_addr + ". node left abruptly");
Connection connection = peerConnection.Enclosing_Instance.Reconnect(peerConnection.peer_addr, out connectionCloseNotified);
if (connection != null)
{
Thread.Sleep(3000);
resendMessage = true;
continue;
}
else
{
NCacheLog.Error("DMSender.Run", Name + ". Failed to re-establish connection with " + peerConnection.peer_addr);
break;
}
}
else
{
NCacheLog.Error("DmSender.Run", "secondary connection broken; peer_addr : " + peerConnection.peer_addr);
try
{
foreach (BinaryMessage bMsg in msgsTobeSent)
{
try
{
if (bMsg != null && mq != null && !mq.Closed)
{
mq.add(bMsg);
}
}
catch (Exception ex)
{
NCacheLog.Error("DmSender.Run", "an error occurred while requing the messages. " + ex.ToString());
}
}
}
catch (Exception) { }
}
break;
}
catch (QueueClosedException e)
{
connectionCloseNotified = false;
break;
}
catch (ThreadInterruptedException e)
{
connectionCloseNotified = false;
break;
}
catch (ThreadAbortException)
{
break;
}
catch (System.Exception e)
{
connectionCloseNotified = false;
NCacheLog.Error(Name + "", Name + " exception is " + e.ToString());
}
}
}
catch (ThreadInterruptedException) { }
catch (ThreadAbortException) { }
catch (Exception ex)
{
connectionCloseNotified = false;
NCacheLog.Error(Name + "", "exception=" + ex.ToString());
}
try
{
if (!connectionCloseNotified)
{
peerConnection.Enclosing_Instance.notifyConnectionClosed(peerConnection.peer_addr);
}
else
{
NCacheLog.CriticalInfo("DmSender.Run", "no need to notify about connection close");
}
peerConnection.Enclosing_Instance.remove(peerConnection.peer_addr, peerConnection.IsPrimary);
}
catch (Exception e)
{
//who cares...
}
}
