internal static byte[] serializeMessage(Message msg)
{
int len = 0;
byte[] buffie;
FlagsByte flags = new FlagsByte();
msg.Dest = null;
msg.Dests = null;
RequestCorrelator.HDR rqHeader = (RequestCorrelator.HDR)msg.getHeader(HeaderType.REQUEST_COORELATOR);
if (rqHeader != null)
{
rqHeader.serializeFlag = false;
}
Stream stmOut = new MemoryStream();
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);
stmOut.Position = 0;
buffie = new byte[len + 4 - payloadLength];
stmOut.Read(buffie, 0, len + 4 - payloadLength);
stmOut.Position = 0;
return(buffie);
}
/// <summary>
/// Gets the deflatted value of the of the object in the value. It does not
/// deflatten the actual object.
/// </summary>
internal object DeflattedValue(string cacheContext)
{
object obj = Value;
//There is possibility that two threads simultaneously do deserialization; therefore
//we must deserialize the entry in synchronized fashion.
lock (this)
{
if (IsFlattened)
{
// Setting the Value resets the Flat flag!
UserBinaryObject ub = null;
CallbackEntry cbEntry = obj as CallbackEntry;
if (cbEntry != null)
{
ub = cbEntry.Value as UserBinaryObject;
}
else
{
ub = obj as UserBinaryObject;
}
byte[] data = ub.GetFullObject();
_size = data.Length;
obj = CompactBinaryFormatter.FromByteBuffer(data, cacheContext);
if (cbEntry != null)
{
cbEntry.Value = obj;
obj = cbEntry;
}
}
}
return(obj);
}
public static object SafeDeserialize(object serializedObject, string serializationContext, BitSet flag)
{
object deserialized = serializedObject;
try
{
if (!flag.IsBitSet(BitSetConstants.BinaryData))
{
if (serializedObject is byte[])
{
deserialized = CompactBinaryFormatter.FromByteBuffer((byte[])serializedObject, serializationContext);
}
else if (serializedObject is UserBinaryObject)
{
deserialized = CompactBinaryFormatter.FromByteBuffer(((UserBinaryObject)serializedObject).GetFullObject(), serializationContext);
}
}
}
catch (Exception ex)
{
//Kill the exception; it is possible that object was serialized by Java
//or from any other domain which can not be deserialized by us.
deserialized = serializedObject;
}
return(deserialized);
}
internal void RecreateMetaInfo(Stream stream, long offset)
{
long _startingOffset = offset;
try
{
stream.Seek(_startingOffset, SeekOrigin.Begin);
// read header length
byte[] len = new byte[4];
if (stream.Read(len, 0, 4) > 0)
{
int length = BitConverter.ToInt32(len, 0);
byte[] data = new byte[length];
stream.Read(data, 0, length);
_segmentHeader = CompactBinaryFormatter.FromByteBuffer(data, string.Empty) as Segment.Header;
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("Segment.RecreateMeta()", ex.ToString());
}
}
}
protected void RegenerateFileMetadata()
{
//_metadataPersister.CreateCollection("FileMetadata");
//ITransaction regenTransaction = _metadataPersister.BeginTransaction(null, false);
//ITransaction iterationTransaction = _MetadataPersistner.Provider.BeginTransaction(null, true);
IDataReader <string, byte[]> dataReader = _metadataPersister.GetAllDocuments <string, byte[]>("FileMetadata");
while (dataReader.MoveNext())
{
KeyValuePair <string, byte[]> kvp = dataReader.Current();
//inMemory StoreKeyMetadata
FileMetadata <long, byte[]> fileMetadata =
(FileMetadata <long, byte[]>)CompactBinaryFormatter.FromByteBuffer(kvp.Value, "");
fileMetadata.Provider = ProviderFactory.CreateProvider(fileMetadata.ProviderType);
StorageConfiguration clone = (StorageConfiguration)_userConfig.Clone();
clone.StorageProvider.DatabaseId = fileMetadata.DatabaseId;
clone.StorageProvider.DatabasePath =
_userConfig.StorageProvider.DatabasePath + _userConfig.StorageProvider.DatabaseId;
clone.StorageProvider.DatabasePath += "\\";
//clone.StorageProvider.DatabasePath = fileMetadata.FilePath;
fileMetadata.Provider.Initialize(clone);
_dbIndex++;
_fileMetadataDictionary[kvp.Key] = fileMetadata;
}
dataReader.Dispose();
//_metadataPersister.Commit(regenTransaction);
}
public object OnRequest(IRequest request)
{
if (request.Message is ManagementCommand)
{
ManagementCommand command = request.Message as ManagementCommand;
if (command == null)
{
return(null);
}
ManagementResponse response = new ManagementResponse();
response.MethodName = command.MethodName;
response.Version = command.CommandVersion;
response.RequestId = command.RequestId;
byte[] arguments = CompactBinaryFormatter.ToByteBuffer(command.Parameters, null);
try
{
response.ResponseMessage = _rpcService.InvokeMethodOnTarget(command.MethodName,
command.Overload, GetTargetMethodParameters(arguments));
}
catch (System.Exception ex)
{
response.Exception = ex;
}
return(response);
}
else
{
return(null);
}
}
/// <summary>
/// Tries to get the value against the specified key from session.
/// </summary>
/// <param name="session">The session object</param>
/// <param name="key">Key against which the value is required</param>
/// <param name="value">The deserialized value against the key</param>
/// <returns>A boolean that specifies whether the operation was successful or not. </returns>
public static bool TryGetValue(this ISession session, string key, out object value)
{
value = null;
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key));
}
byte[] data;
if (session.TryGetValue(key, out data))
{
try
{
value = CompactBinaryFormatter.FromByteBuffer(data, string.Empty);
}
catch
{
return(false);
}
return(true);
}
return(false);
}
protected CommandInfo ParseCommand(Alachisoft.NCache.Common.Protobuf.Command command, ClientManager clientManager, string cacheId)
{
CommandInfo cmdInfo = new CommandInfo();
Common.Protobuf.InvokeEntryProcessorCommand invokeEntryProcessorCommand = command.invokeEntryProcessorCommand;
cmdInfo.keys = invokeEntryProcessorCommand.keys.ToArray();
cmdInfo.entryProcessor = (IEntryProcessor)CompactBinaryFormatter.FromByteBuffer(invokeEntryProcessorCommand.entryprocessor, cacheId);
cmdInfo.arguments = new object[invokeEntryProcessorCommand.arguments.Count];
int counter = 0;
List <byte[]> arguments = invokeEntryProcessorCommand.arguments;
if (arguments.Count != 0)
{
foreach (byte[] argument in invokeEntryProcessorCommand.arguments)
{
cmdInfo.arguments[counter] = CompactBinaryFormatter.FromByteBuffer(argument, cacheId);
counter++;
}
}
else
{
cmdInfo.arguments = null;
}
cmdInfo.readOptionFlag = new BitSet((byte)invokeEntryProcessorCommand.dsReadOption);
cmdInfo.defaultReadThru = invokeEntryProcessorCommand.defaultReadThru;
cmdInfo.writeOptionFlag = new BitSet((byte)invokeEntryProcessorCommand.dsWriteOption);
cmdInfo.defaultWriteThru = invokeEntryProcessorCommand.defaultWriteThru;
cmdInfo.requestId = command.requestID;
cmdInfo.clientLastViewId = command.clientLastViewId;
cmdInfo.CommandVersion = command.version;
return(cmdInfo);
}
/// <summary>
/// Fills the system ASP.NET session from NCache.
/// </summary>
/// <param name="session"></param>
/// <param name="cache"></param>
/// <param name="strict"></param>
void IDistributionStrategy.FillSessionFromCache(ISessionCache cache, HttpSessionState session, NSessionStateModule module, bool strict)
{
string sessionId = session.SessionID;
SessionKey key = new SessionKey(sessionId, module.ApplicationId);
if (strict)
{
session.Clear();
}
/// save the binary form of data, for comparision on FillCacheFromAspNet()
_table = (byte[])cache.Get(key.ToString());
if (_table == null)
{
_isNewSession = true;
return;
}
Hashtable ht = (Hashtable)CompactBinaryFormatter.FromByteBuffer(_table, module.CacheID);
if (ht == null)
{
return;
}
IDictionaryEnumerator i = ht.GetEnumerator();
while (i.MoveNext())
{
session[i.Key.ToString()] = i.Value;
}
}
/// <summary>
/// Fills NCache from the system ASP.NET session.
/// </summary>
/// <param name="cache"></param>
/// <param name="session"></param>
/// <param name="strict"></param>
/// <param name="async"></param>
void IDistributionStrategy.FillCacheFromSession(ISessionCache cache, HttpSessionState session, NSessionStateModule module, bool strict, bool isAbandoned)
{
string sessionId = session.SessionID;
SessionKey key = new SessionKey(sessionId, module.ApplicationId);
try
{
if (session.IsReadOnly && cache.Contains(sessionId, key.ToString()) && !isAbandoned)
{
return;
}
if (/*session.Count == 0 ||*/ isAbandoned)//[Ata]: Session is not removed from store if it is cleared
{
cache.Remove(sessionId, key.ToString(), false);
if (module.DetailedLogsEnabled)
{
NSessionStateModule.NCacheLog.Debug(sessionId + " :session removed from cache");
}
return;
}
//use-case: A session my get emptied while doing different updates... although whien added first time is is not empty
//So we must update that session rather doing no operation thinking it is empty session and need not to be added.
if (session.Count == 0 && _isNewSession) //We need not to keep any new empty session in the cache. [Asif Imam] April 09, 08
{
return;
}
IDictionary ht = new Hashtable();
foreach (string skey in session.Keys)
{
ht[skey] = session[skey];
}
byte[] _stable = CompactBinaryFormatter.ToByteBuffer(ht, module.CacheID);
if (_table != null)
{
if (BinaryComparer(_stable, _table))
{
return;
}
}
CacheItem sessionItem = new CacheItem(_stable);
sessionItem.Priority = CacheItemPriority.NotRemovable;
sessionItem.Expiration = new Runtime.Caching.Expiration(Runtime.Caching.ExpirationType.Sliding, TimeSpan.FromMinutes(session.Timeout));
cache.Insert(sessionId, key.ToString(), sessionItem, false);
}
finally
{
if (session != null && strict)
{
session.Clear();
}
}
}
/// <summary>
/// Deserialises an Object from the payload
/// </summary>
/// <returns>Deserialised Object</returns>
public Object getObject()
{
if (buf == null)
{
return(null);
}
return(CompactBinaryFormatter.FromByteBuffer(buf, null));
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
Decimal[] array = (Decimal[])graph;
for (int i = 0; i < array.Length; i++)
{
CompactBinaryFormatter.Deserialize(reader, reader.CacheContext, true);
}
}
public void WriteTo(AttributeValue value, System.IO.Stream stream)
{
byte[] data = CompactBinaryFormatter.ToByteBuffer(value, "");
int size = data.Length;
PrimitiveSerializer.Int32.WriteTo(size, stream);
stream.Write(data, 0, size);
}
/// <summary>
/// Realiza a serilização segura do objeto
/// </summary>
/// <param name="serializableObject"></param>
/// <param name="serializationContext"></param>
/// <param name="flag"></param>
/// <returns></returns>
public static object SafeSerialize(object serializableObject, string serializationContext, ref BitSet flag)
{
if (serializableObject != null)
{
serializableObject = CompactBinaryFormatter.ToByteBuffer(serializableObject, serializationContext);
}
return(serializableObject);
}
/// <summary>
/// Fills NCache from the system ASP.NET session.
/// </summary>
/// <param name="cache"></param>
/// <param name="session"></param>
/// <param name="strict"></param>
/// <param name="async"></param>
void IDistributionStrategy.FillCacheFromSession(ISessionCache cache, HttpSessionState session, NSessionStateModule module, bool strict, bool isAbandoned)
{
string sessionId = session.SessionID;
SessionKey key = new SessionKey(sessionId, module.ApplicationId);
try
{
if (session.IsReadOnly && cache.Contains(sessionId, key.ToString()) && !isAbandoned)
{
return;
}
if (isAbandoned)// Session is not removed from store if it is cleared
{
cache.Remove(sessionId, key.ToString(), false);
if (module.DetailedLogsEnabled)
{
NSessionStateModule.NCacheLog.Debug(sessionId + " :session removed from cache");
}
return;
}
if (session.Count == 0 && _isNewSession) //We need not to keep any new empty session in the cache.
{
return;
}
IDictionary ht = new Hashtable();
foreach (string skey in session.Keys)
{
ht[skey] = session[skey];
}
byte[] _stable = CompactBinaryFormatter.ToByteBuffer(ht, module.CacheID);
if (_table != null)
{
if (BinaryComparer(_stable, _table))
{
return;
}
}
CacheItem sessionItem = new CacheItem(_stable);
sessionItem.Priority = CacheItemPriority.NotRemovable;
sessionItem.SlidingExpiration = TimeSpan.FromMinutes(session.Timeout);
cache.Insert(sessionId, key.ToString(), sessionItem, false);
}
finally
{
if (session != null && strict)
{
session.Clear();
}
}
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
Decimal[] array = (Decimal[])graph;
for (int i = 0; i < array.Length; i++)
{
array[i] = (decimal)CompactBinaryFormatter.Deserialize(reader, reader.CacheContext, false);
}
return(array);
}
public override void WriteDirect(CompactBinaryWriter writer, object graph)
{
Decimal[] array = (Decimal[])graph;
writer.Write(array.Length);
for (int i = 0; i < array.Length; i++)
{
CompactBinaryFormatter.Serialize(writer, ((decimal)array[i]).ToString(), writer.CacheContext);
}
}
/// <summary>
/// Reencontra o valor do objeto
/// </summary>
/// <param name="cacheContext"></param>
/// <returns></returns>
internal object DeflattenObject(string cacheContext)
{
lock (this)
if (IsFlattened)
{
Value = CompactBinaryFormatter.FromByteBuffer(this.UserData as byte[], cacheContext);
}
return(this.Value);
}
/// <summary>
/// Create a File and serialize the object in to.
/// </summary>
private void WriteObjectToFile(string fileName, object value, string serializationContext)
{
fileName = GetPathForFile(fileName);
using (FileStream stream = new FileStream(fileName, FileMode.Create))
{
CompactBinaryFormatter.Serialize(stream, value, serializationContext);
stream.Close();
}
}
public AttributeValue ReadFrom(System.IO.Stream stream)
{
int size = PrimitiveSerializer.Int32.ReadFrom(stream);
byte[] data = new byte[size];
stream.Read(data, 0, size);
AttributeValue value = CompactBinaryFormatter.FromByteBuffer(data, "") as AttributeValue;
return(value);
}
public object Deserialize(byte[] buffer)
{
IChannelMessage response = null;
if (buffer != null)
{
response = (IChannelMessage)CompactBinaryFormatter.FromByteBuffer(buffer, null);
}
return(response);
}
/// <summary>
/// Lê o objeto do arquivo.
/// </summary>
/// <param name="fileName">Nome do arquivo.</param>
/// <param name="serializationContext">Nome do contexto de serialização.</param>
/// <returns></returns>
private object ReadObjectFromFile(string fileName, string serializationContext)
{
fileName = this.GetPathForFile(fileName);
if (!File.Exists(fileName))
{
return(null);
}
using (FileStream stream = new FileStream(fileName, FileMode.Open))
return(CompactBinaryFormatter.Deserialize(stream, serializationContext));
}
/// <summary>
/// Do not Use this! Actually. DO NOT use ICustomSerializable.
/// Use Read(bool useCompression), and convert your domain object to ICustomSerializable.
/// </summary>
/// <typeparam name="T">object to be deserialized</typeparam>
/// <returns>object deserialized</returns>
public T Read <T>() where T : new()
{
if (Serializer.IsSerializable(typeof(T)) == true)
{
return(Serializer.Deserialize <T>(this));
}
else
{
return((T)CompactBinaryFormatter.Deserialize(this));
}
}
/// <summary>
/// Writes <paramref name="graph"/> to the current stream and advances the stream position.
/// If T implements ICustomSerializable, it will be used.
///
/// Do not Use this! Actually. No NOT use ICustomSerializable.
/// Use Write<T>(T graph, bool useCompression), and convert your domain object to IVersionSerializable.
/// </summary>
/// <typeparam name="T">A newable type</typeparam>
/// <param name="graph">Object to write</param>
public void Write <T>(T graph)
{
if (graph is ICustomSerializable)
{
Serializer.Serialize(this, graph, SerializerFlags.Default);
}
else
{
CompactBinaryFormatter.Serialize(this, graph);
}
}
/// <summary>
/// Serializes the object using CompactSerialization Framwork.
/// </summary>
/// <param name="graph"></param>
/// <returns></returns>
public static object CompactSerialize(object graph, string cacheContext)
{
if (graph != null && graph is ICompactSerializable)
{
System.IO.MemoryStream stream = new System.IO.MemoryStream();
stream.Write(NCHeader.Version, 0, NCHeader.Length);
CompactBinaryFormatter.Serialize(stream, graph, cacheContext);
return(stream.ToArray());
}
return(graph);
}
/// <summary>
/// Sets a value against the specified key in the session.
/// </summary>
/// <param name="session">The session object</param>
/// <param name="key">Key against which the value is required</param>
/// <param name="value">The value against the key which is serialized using NCache Compact Serialization</param>
public static void Set(this ISession session, string key, object value)
{
//Note: This might require registering the compact types first if the user decides to use these extensions on the default session object
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key));
}
var data = CompactBinaryFormatter.ToByteBuffer(value, string.Empty);
session.Set(key, data);
}
/// <summary>
/// Serialises an object in to the payload
/// </summary>
/// <param name="obj">Object to serialise</param>
public void setObject(Object obj)
{
if (buf != null)
{
return;
}
if (!obj.GetType().IsSerializable)
{
throw new Exception("Specified object for message is not serializable");
}
setBuffer(CompactBinaryFormatter.ToByteBuffer(obj, null));
}
/// <summary>
/// DeFalttens, i.e. deserializes the object contained in value.
/// </summary>
internal object DeflattenObject(string cacheContext)
{
lock (this)
{
if (IsFlattened)
{
// Setting the Value resets the Flat flag!
Value = CompactBinaryFormatter.FromByteBuffer(UserData as byte[], cacheContext);
}
}
return(Value);
}
public byte[] Serialize(object graph)
{
try
{
IChannelMessage command = graph as IChannelMessage;
return(CompactBinaryFormatter.ToByteBuffer(command, null));
}
catch (Exception ex)
{
throw ex;
}
//byte[] buffer = null;
//CommandBase command = null;
//if (graph is IRequest)
//{
// IRequest request = graph as IRequest;
// command = request.Message as CommandBase;
//}
//else if (graph is IResponse)
//{
// ChannelResponse res = graph as ChannelResponse;
// command = res.ResponseMessage as CommandBase;
//}
//if (command != null)
//{
// if (command.commandType == CommandBase.CommandType.RESPONSE)
// {
// if (command.response.ResponseMessage != null)
// command.response.returnVal = CompactBinaryFormatter.ToByteBuffer(command.response.ResponseMessage, null);
// }
// else
// {
// if (command.command.Parameters != null)
// command.command.arguments = CompactBinaryFormatter.ToByteBuffer(command.command.Parameters, null);
// }
// using (MemoryStream stream = new MemoryStream())
// {
// ProtoBuf.Serializer.Serialize<CommandBase>(stream, command);
// buffer = stream.ToArray();
// }
//}
//return buffer;
}
private byte[] messageToBuffer(Message msg)
{
using (MemoryStream s = new MemoryStream())
{
s.Write(Version.version_id, 0, Version.version_id.Length);
CompactBinaryFormatter.Serialize(s, msg, null);
byte[] buffer = s.ToArray();
s.Close();
return(buffer);
}
}
