public MessageSerializer( Serializer <object> bodySerializer, SerializerSessionPool sessionPool, SharedMemoryPool memoryPool, IServiceProvider services, Serializer <GrainAddress> activationAddressSerializer, ICodecProvider codecProvider, int maxHeaderSize, int maxBodySize) { _readerSiloAddressCodec = new CachingSiloAddressCodec(); _writerSiloAddressCodec = new CachingSiloAddressCodec(); _readerIdSpanCodec = new CachingIdSpanCodec(); _writerIdSpanCodec = new CachingIdSpanCodec(); _serializer = ActivatorUtilities.CreateInstance <Serializer>(services); _activationAddressCodec = activationAddressSerializer; _serializationSession = sessionPool.GetSession(); _deserializationSession = sessionPool.GetSession(); _memoryPool = memoryPool.Pool; _bodySerializer = bodySerializer; _maxHeaderLength = maxHeaderSize; _maxBodyLength = maxBodySize; _sessionPool = sessionPool; _requestContextCodec = OrleansGeneratedCodeHelper.GetService <DictionaryCodec <string, object> >(this, codecProvider); }
/// <summary> /// Initializes a new instance of the <see cref="SerializerConfigurationValidator"/> class. /// </summary> /// <param name="codecProvider"> /// The codec provider. /// </param> /// <param name="options"> /// The type manifest options. /// </param> /// <param name="serviceProvider"> /// The service provider. /// </param> public SerializerConfigurationValidator(ICodecProvider codecProvider, IOptions <TypeManifestOptions> options, IServiceProvider serviceProvider) { _codecProvider = codecProvider; _options = options.Value; var configEnabled = _options.EnableConfigurationAnalysis; if (configEnabled.HasValue) { _enabled = configEnabled.Value; } else { // Enable in development envioronment by default. var environment = serviceProvider.GetService <IHostEnvironment>(); _enabled = environment is not null && environment.IsDevelopment(); } }
/// <summary> /// Unwraps the provided service if it was wrapped. /// </summary> /// <typeparam name="TService">The service type.</typeparam> /// <param name="caller">The caller.</param> /// <param name="codecProvider">The codec provider.</param> /// <returns>The unwrapped service.</returns> public static TService GetService <TService>(object caller, ICodecProvider codecProvider) { var state = ResolutionState.Value; try { state.Enter(caller); foreach (var c in state.Callers) { if (c is TService s && !(c is IServiceHolder <TService>)) { return(s); } } return(Unwrap(ActivatorUtilities.GetServiceOrCreateInstance <TService>(codecProvider.Services))); } finally { state.Exit(); }
/// <summary> /// Analyzes grain interface methods to find parameter types and return types which are not serializable. /// </summary> /// <param name="codecProvider"> /// The codec provider. /// </param> /// <param name="options"> /// The type manifest options. /// </param> /// <returns> /// A collection of types which have serializability issues. /// </returns> public static Dictionary <Type, SerializerConfigurationComplaint> AnalyzeSerializerAvailability(ICodecProvider codecProvider, TypeManifestOptions options) { var allComplaints = new Dictionary <Type, SerializerConfigurationComplaint>(); foreach (var @interface in options.Interfaces) { foreach (var method in @interface.GetMethods()) { if (typeof(Task).IsAssignableFrom(method.ReturnType)) { if (method.ReturnType.IsConstructedGenericType && typeof(Task <>).IsAssignableFrom(method.ReturnType.GetGenericTypeDefinition())) { VisitType(method.ReturnType.GetGenericArguments()[0], method); } } if (method.ReturnType.IsConstructedGenericType && typeof(ValueTask <>).IsAssignableFrom(method.ReturnType.GetGenericTypeDefinition())) { VisitType(method.ReturnType.GetGenericArguments()[0], method); } foreach (var param in method.GetParameters()) { VisitType(param.ParameterType, method); } } } return(allComplaints); void VisitType(Type type, MethodInfo methodInfo) { if (!IsEligibleType(type)) { return; } var hasCodec = codecProvider.TryGetCodec(type) is not null; var hasCopier = codecProvider.TryGetDeepCopier(type) is not null; if (!hasCodec || !hasCopier) { if (!allComplaints.TryGetValue(type, out var complaint)) { complaint = allComplaints[type] = new() { HasSerializer = hasCodec, HasCopier = hasCopier, }; } if (!complaint.Methods.TryGetValue(methodInfo.DeclaringType, out var methodList)) { methodList = complaint.Methods[methodInfo.DeclaringType] = new HashSet <MethodInfo>(); } methodList.Add(methodInfo); } } bool IsEligibleType(Type type) { if (type.IsGenericTypeParameter || type.IsGenericMethodParameter || type.ContainsGenericParameters) { return(false); } return(true); } }
public CodecContributor(ICodecProvider provider) { this.provider = provider; }