/// <summary>
/// Processes the provided assembly.
/// </summary>
/// <param name="assembly">The assembly to process.</param>
private static void ProcessAssembly(Assembly assembly)
{
string assemblyName = assembly.GetName().Name;
if (Logger.IsVerbose3)
{
Logger.Verbose3("Processing assembly {0}", assemblyName);
}
// If the assembly is loaded for reflection only avoid processing it.
if (assembly.ReflectionOnly)
{
return;
}
// Don't bother re-processing an assembly we've already scanned
lock (ProcessedAssemblies)
{
if (!ProcessedAssemblies.Add(assembly))
{
return;
}
}
// If the assembly does not reference Orleans, avoid generating code for it.
if (TypeUtils.IsOrleansOrReferencesOrleans(assembly))
{
// Code generation occurs in a self-contained assembly, so invoke it separately.
CodeGeneratorManager.GenerateAndCacheCodeForAssembly(assembly);
}
// Process each type in the assembly.
var shouldProcessSerialization = SerializationManager.ShouldFindSerializationInfo(assembly);
var assemblyTypes = TypeUtils.GetDefinedTypes(assembly, Logger).ToArray();
// Process each type in the assembly.
List <Type> typesToFind = new List <Type>(assemblyTypes.Length);
foreach (TypeInfo typeInfo in assemblyTypes)
{
try
{
var type = typeInfo.AsType();
string typeName = typeInfo.FullName;
if (Logger.IsVerbose3)
{
Logger.Verbose3("Processing type {0}", typeName);
}
if (shouldProcessSerialization)
{
typesToFind.Add(type);
}
GrainFactory.FindSupportClasses(type);
}
catch (Exception exception)
{
Logger.Error(ErrorCode.SerMgr_TypeRegistrationFailure, "Failed to load type " + typeInfo.FullName + " in assembly " + assembly.FullName + ".", exception);
}
}
SerializationManager.FindSerializationInfo(typesToFind);
}
private async Task OnRefreshClusterMapTimer(object _)
{
// Check if we have to refresh
if (!hasToRefreshClusterGrainInterfaceMap)
{
logger.Verbose3("OnRefreshClusterMapTimer: no refresh required");
return;
}
hasToRefreshClusterGrainInterfaceMap = false;
logger.Info("OnRefreshClusterMapTimer: refresh start");
var activeSilos = statusOracle.GetApproximateSiloStatuses(onlyActive: true);
var knownSilosClusterGrainInterfaceMap = grainTypeManager.GrainInterfaceMapsBySilo;
// Build the new map. Always start by himself
var newSilosClusterGrainInterfaceMap = new Dictionary <SiloAddress, GrainInterfaceMap>
{
{ this.Silo, grainTypeManager.GetTypeCodeMap() }
};
var getGrainInterfaceMapTasks = new List <Task <KeyValuePair <SiloAddress, GrainInterfaceMap> > >();
foreach (var siloAddress in activeSilos.Keys)
{
if (siloAddress.Equals(this.Silo))
{
continue;
}
GrainInterfaceMap value;
if (knownSilosClusterGrainInterfaceMap.TryGetValue(siloAddress, out value))
{
logger.Verbose3($"OnRefreshClusterMapTimer: value already found locally for {siloAddress}");
newSilosClusterGrainInterfaceMap[siloAddress] = value;
}
else
{
// Value not found, let's get it
logger.Verbose3($"OnRefreshClusterMapTimer: value not found locally for {siloAddress}");
getGrainInterfaceMapTasks.Add(GetTargetSiloGrainInterfaceMap(siloAddress));
}
}
if (getGrainInterfaceMapTasks.Any())
{
foreach (var keyValuePair in await Task.WhenAll(getGrainInterfaceMapTasks))
{
if (keyValuePair.Value != null)
{
newSilosClusterGrainInterfaceMap.Add(keyValuePair.Key, keyValuePair.Value);
}
}
}
grainTypeManager.SetInterfaceMapsBySilo(newSilosClusterGrainInterfaceMap);
if (this.versionStore.IsEnabled)
{
await this.GetAndSetDefaultCompatibilityStrategy();
foreach (var kvp in await GetStoredCompatibilityStrategies())
{
this.versionSelectorManager.CompatibilityDirectorManager.SetStrategy(kvp.Key, kvp.Value);
}
await this.GetAndSetDefaultSelectorStrategy();
foreach (var kvp in await GetSelectorStrategies())
{
this.versionSelectorManager.VersionSelectorManager.SetSelector(kvp.Key, kvp.Value);
}
}
versionSelectorManager.ResetCache();
}
public bool TryDecodeMessage(out Message msg)
{
msg = null;
// Is there enough read into the buffer to continue (at least read the lengths?)
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// parse lengths if needed
if (headerLength == 0 || bodyLength == 0)
{
// get length segments
List <ArraySegment <byte> > lenghts = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, decodeOffset, Message.LENGTH_HEADER_SIZE);
// copy length segment to buffer
int lengthBufferoffset = 0;
foreach (ArraySegment <byte> seg in lenghts)
{
Buffer.BlockCopy(seg.Array, seg.Offset, lengthBuffer, lengthBufferoffset, seg.Count);
lengthBufferoffset += seg.Count;
}
// read lengths
headerLength = BitConverter.ToInt32(lengthBuffer, 0);
bodyLength = BitConverter.ToInt32(lengthBuffer, 4);
}
// If message is too big for current buffer size, grow
while (decodeOffset + CalculateKnownMessageSize() > currentBufferSize)
{
GrowBuffer();
}
// Is there enough read into the buffer to read full message
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// decode header
int headerOffset = decodeOffset + Message.LENGTH_HEADER_SIZE;
List <ArraySegment <byte> > header = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, headerOffset, headerLength);
// decode body
int bodyOffset = headerOffset + headerLength;
List <ArraySegment <byte> > body = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, bodyOffset, bodyLength);
// need to maintain ownership of buffer, so if we are supporting forwarding we need to duplicate the body buffer.
if (supportForwarding)
{
body = DuplicateBuffer(body);
}
// build message
msg = new Message(header, body, !supportForwarding);
MessagingStatisticsGroup.OnMessageReceive(msg, headerLength, bodyLength);
if (headerLength + bodyLength > Message.LargeMessageSizeThreshold)
{
Log.Info(ErrorCode.Messaging_LargeMsg_Incoming, "Receiving large message Size={0} HeaderLength={1} BodyLength={2}. Msg={3}",
headerLength + bodyLength, headerLength, bodyLength, msg.ToString());
if (Log.IsVerbose3)
{
Log.Verbose3("Received large message {0}", msg.ToLongString());
}
}
// update parse receiveOffset and clear lengths
decodeOffset = bodyOffset + bodyLength;
headerLength = 0;
bodyLength = 0;
AdjustBuffer();
return(true);
}
public bool TryDecodeMessage(out Message msg)
{
msg = null;
// Is there enough read into the buffer to continue (at least read the lengths?)
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// parse lengths if needed
if (headerLength == 0 || bodyLength == 0)
{
// get length segments
List <ArraySegment <byte> > lenghts = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, decodeOffset, Message.LENGTH_HEADER_SIZE);
// copy length segment to buffer
int lengthBufferoffset = 0;
foreach (ArraySegment <byte> seg in lenghts)
{
Buffer.BlockCopy(seg.Array, seg.Offset, lengthBuffer, lengthBufferoffset, seg.Count);
lengthBufferoffset += seg.Count;
}
// read lengths
headerLength = BitConverter.ToInt32(lengthBuffer, 0);
bodyLength = BitConverter.ToInt32(lengthBuffer, 4);
}
// If message is too big for current buffer size, grow
while (decodeOffset + CalculateKnownMessageSize() > currentBufferSize)
{
GrowBuffer();
}
// Is there enough read into the buffer to read full message
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// decode header
int headerOffset = decodeOffset + Message.LENGTH_HEADER_SIZE;
List <ArraySegment <byte> > header = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, headerOffset, headerLength);
// decode body
int bodyOffset = headerOffset + headerLength;
List <ArraySegment <byte> > body = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, bodyOffset, bodyLength);
// build message
this.deserializationContext.Reset();
this.deserializationContext.StreamReader.Reset(header);
msg = new Message
{
Headers = SerializationManager.DeserializeMessageHeaders(this.deserializationContext)
};
try
{
if (this.supportForwarding)
{
// If forwarding is supported, then deserialization will be deferred until the body value is needed.
// Need to maintain ownership of buffer, so we need to duplicate the body buffer.
msg.SetBodyBytes(this.DuplicateBuffer(body));
}
else
{
// Attempt to deserialize the body immediately.
msg.DeserializeBodyObject(this.serializationManager, body);
}
}
finally
{
MessagingStatisticsGroup.OnMessageReceive(msg, headerLength, bodyLength);
if (headerLength + bodyLength > Message.LargeMessageSizeThreshold)
{
Log.Info(
ErrorCode.Messaging_LargeMsg_Incoming,
"Receiving large message Size={0} HeaderLength={1} BodyLength={2}. Msg={3}",
headerLength + bodyLength,
headerLength,
bodyLength,
msg.ToString());
if (Log.IsVerbose3)
{
Log.Verbose3("Received large message {0}", msg.ToLongString());
}
}
// update parse receiveOffset and clear lengths
decodeOffset = bodyOffset + bodyLength;
headerLength = 0;
bodyLength = 0;
AdjustBuffer();
}
return(true);
}
