/// <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); }