public void Group() { lock (_groupingLock) { if (_hasGrouped) { return; } _calls.Where(x => TypeExtensions.IsConcrete(x.MessageType)) .GroupBy(x => x.MessageType) .Select(group => new HandlerChain(@group)) .Each(chain => { _chains = _chains.AddOrUpdate(chain.MessageType, chain); }); _calls.Where(x => !TypeExtensions.IsConcrete(x.MessageType)) .Each(call => { Chains .Where(c => call.CouldHandleOtherMessageType(c.MessageType)) .Each(c => { c.AddAbstractedHandler(call); }); }); _hasGrouped = true; } }
public HandlerGraph() { // All of this is to seed the handler and its associated retry policies // for scheduling outgoing messages _handlers = _handlers.AddOrUpdate(typeof(Envelope), new ScheduledSendEnvelopeHandler()); GlobalPolicy <SagaFramePolicy>(); }
public void PopulateImHashMap() { var keys = _keys; for (var i = 0; i < ItemCount; i++) { Interlocked.Exchange(ref _imMap, _imMap.AddOrUpdate(keys[i], "a")); } Interlocked.Exchange(ref _imMap, _imMap.AddOrUpdate(_key, _value)); }
/// <summary> /// Register a database that will hold data for multiple conjoined tenants /// </summary> /// <param name="connectionString"></param> /// <param name="databaseIdentifier">A descriptive name for this database. If omitted, this will be derived from the connection string</param> /// <returns></returns> public IDatabaseExpression AddMultipleTenantDatabase(string connectionString, string databaseIdentifier = null) { var builder = new NpgsqlConnectionStringBuilder(connectionString); var identifier = databaseIdentifier ?? $"{builder.Database}@{builder.Host}"; var database = new MartenDatabase(Options, new ConnectionFactory(connectionString), identifier); _databases = _databases.AddOrUpdate(identifier, database); return(new DatabaseExpression(this, database)); }
private void buildInitialSendingAgents(IMessagingRoot root) { foreach (var subscriberAddress in root.Settings.KnownSubscribers) { var transport = _transports[subscriberAddress.Uri.Scheme]; var agent = transport.BuildSendingAgent(subscriberAddress.Uri, root, _settings.Cancellation); var channel = new Channel(_logger, subscriberAddress, transport.LocalReplyUri, agent); _channels = _channels.AddOrUpdate(subscriberAddress.Uri, channel); } }
private static long ImHashMapAddIntKey <V>(ref ImHashMap <int, V> tree, int[] keys, int key, V value) { var ignored = default(V); var treeTime = Stopwatch.StartNew(); for (var i = 0; i < keys.Length; i++) { Interlocked.Exchange(ref tree, tree.AddOrUpdate(keys[i], ignored)); } Interlocked.Exchange(ref tree, tree.AddOrUpdate(key, value)); treeTime.Stop(); GC.Collect(); return(treeTime.ElapsedMilliseconds); }
private IAggregateFetchPlan <TDoc, TId> determineFetchPlan <TDoc, TId>() where TDoc : class { if (_fetchStrategies.TryFind(typeof(TDoc), out var stored)) { return((IAggregateFetchPlan <TDoc, TId>)stored); } // All the IDocumentStorage types are codegen'd // ReSharper disable once SuspiciousTypeConversion.Global var documentProvider = _store.Options.Providers.StorageFor <TDoc>(); var storage = (IDocumentStorage <TDoc, TId>)documentProvider.IdentityMap; IAggregateFetchPlan <TDoc, TId> plan; if (_store.Options.Projections.DoesPersistAggregate(typeof(TDoc))) { plan = new FetchInlinedPlan <TDoc, TId>(_store.Events, (IEventIdentityStrategy <TId>) this, storage); } else { plan = new FetchLivePlan <TDoc, TId>(_store.Events, (IEventIdentityStrategy <TId>) this, storage); } _fetchStrategies = _fetchStrategies.AddOrUpdate(typeof(TDoc), plan); return(plan); }
public Cache(IDictionary <TKey, TValue> dictionary) { foreach (var pair in dictionary) { _values = _values.AddOrUpdate(pair.Key, pair.Value); } }
public void Init() { var r = new Random(4); _keys = new List <T>(); _immDict = ImmutableDictionary <T, int> .Empty; _sasaTrie = Trie <T, int> .Empty; _sGuh = ImmutableTrieDictionary.Create <T, int>(); _tvl = ImmutableTreeDictionary <T, int> .Empty; _imToolsHashMap = ImHashMap <T, int> .Empty; _apexHashMap = HashMap <T, int> .Empty; for (int i = 0; i < Count; ++i) { var k = GenerateValue(r); _immDict = _immDict.SetItem(k, i); _sasaTrie = _sasaTrie.Add(k, i); _sGuh = _sGuh.Add(k, i); _tvl = _tvl.Add(k, i); _imToolsHashMap = _imToolsHashMap.AddOrUpdate(k, i); _apexHashMap = _apexHashMap.SetItem(k, i); _keys.Add(k); } int n = _keys.Count; while (n > 1) { n--; int k = r.Next(n + 1); var value = _keys[k]; _keys[k] = _keys[n]; _keys[n] = value; } }
private void buildInitialSendingAgents(IMessagingRoot root) { var groups = root.Settings.Subscriptions.GroupBy(x => x.Uri); foreach (var @group in groups) { var subscriber = new Subscriber(@group.Key, @group); var transport = _transports[subscriber.Uri.Scheme]; var agent = transport.BuildSendingAgent(subscriber.Uri, root, _settings.Cancellation); subscriber.StartSending(_logger, agent, transport.ReplyUri); _subscribers = _subscribers.AddOrUpdate(subscriber.Uri, subscriber); } }
internal ICompiledQuerySource GetCompiledQuerySourceFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, QuerySession session) { if (_querySources.TryFind(query.GetType(), out var source)) { return(source); } if (typeof(TOut).CanBeCastTo <Task>()) { throw InvalidCompiledQueryException.ForCannotBeAsync(query.GetType()); } var plan = QueryCompiler.BuildPlan(session, query, _store.Options); var file = new CompiledQueryCodeFile(query.GetType(), _store, plan, _tracking); var rules = _store.Options.CreateGenerationRules(); rules.ReferenceTypes(typeof(TDoc), typeof(TOut), query.GetType()); file.InitializeSynchronously(rules, _store, null); source = file.Build(rules); _querySources = _querySources.AddOrUpdate(query.GetType(), source); return(source); }
public DocumentProvider <T> StorageFor <T>() where T : notnull { var documentType = typeof(T); if (_storage.TryFind(documentType, out var stored)) { return(stored.As <DocumentProvider <T> >()); } if (documentType == typeof(IEvent)) { var slot = EventDocumentStorageGenerator.BuildProvider(_options); _storage = _storage.AddOrUpdate(documentType, slot); return(slot.As <DocumentProvider <T> >()); } var mapping = _options.Storage.FindMapping(documentType); switch (mapping) { case DocumentMapping m: { var builder = new DocumentPersistenceBuilder(m, _options); var slot = builder.Generate <T>(); _storage = _storage.AddOrUpdate(documentType, slot); return(slot); } case SubClassMapping s: { var loader = typeof(SubClassLoader <, ,>).CloseAndBuildAs <ISubClassLoader <T> >(mapping.Root.DocumentType, documentType, mapping.IdType); var slot = loader.BuildPersistence(this, s); _storage = _storage.AddOrUpdate(documentType, slot); return(slot); } case EventMapping em: { var storage = (IDocumentStorage <T>)em; var slot = new DocumentProvider <T> { Lightweight = storage, IdentityMap = storage, DirtyTracking = storage, QueryOnly = storage }; _storage = _storage.AddOrUpdate(documentType, slot); return(slot); } default: throw new NotSupportedException("Unable to build document persistence handlers for " + mapping.DocumentType.FullNameInCode()); } }
private static long TreeAdd <V>(ref ImHashMap <Type, V> tree, Type[] keys, Type key, V value) { var ignored = default(V); var treeTime = Stopwatch.StartNew(); for (var i = 0; i < keys.Length; i++) { var k = keys[i]; Interlocked.Exchange(ref tree, tree.AddOrUpdate(k, ignored)); } Interlocked.Exchange(ref tree, tree.AddOrUpdate(key, value)); treeTime.Stop(); GC.KeepAlive(ignored); GC.Collect(); return(treeTime.ElapsedMilliseconds); }
public void RouteToDestination(Envelope envelope) { if (!_destinations.TryFind(envelope.Destination, out var route)) { route = DetermineDestinationRoute(envelope.Destination); _destinations = _destinations.AddOrUpdate(envelope.Destination, route); } route.Configure(envelope); }
private ISendingAgent addQueue(IMessagingRoot root, ITransportRuntime runtime, LocalQueueSettings queue) { queue.Agent = buildAgent(queue, root); _agents = _agents.AddOrUpdate(queue.Name, buildAgent(queue, root)); runtime.AddSendingAgent(buildAgent(queue, root)); runtime.AddSubscriber(queue); return(queue.Agent); }
public MessageHandler HandlerFor(Type messageType) { if (_handlers.TryFind(messageType, out var handler)) { return(handler); } if (_chains.TryFind(messageType, out var chain)) { if (chain.Handler != null) { handler = chain.Handler; } else { lock (chain) { if (chain.Handler == null) { var generatedAssembly = new GeneratedAssembly(_generation); chain.AssembleType(generatedAssembly, _generation); _container.CompileWithInlineServices(generatedAssembly); handler = chain.CreateHandler(_container); } else { handler = chain.Handler; } } } _handlers = _handlers.AddOrUpdate(messageType, handler); return(handler); } // memoize the "miss" _handlers = _handlers.AddOrUpdate(messageType, null); return(null); }
public ISubscriber GetOrBuild(Uri address) { assertValidTransport(address); if (_subscribers.TryFind(address, out var channel)) { return(channel); } lock (_channelLock) { if (!_subscribers.TryFind(address, out channel)) { channel = buildChannel(address); _subscribers = _subscribers.AddOrUpdate(address, channel); } return(channel); } }
public Tenant GetTenant(string tenantId) { if (_tenants.TryFind(tenantId, out var tenant)) { return(tenant); } if (!_tenantToDatabase.TryGetValue(tenantId, out var databaseName)) { databaseName = tenantId; } var database = FindOrCreateDatabase(databaseName).AsTask() .GetAwaiter().GetResult(); tenant = new Tenant(tenantId, database); _tenants = _tenants.AddOrUpdate(tenantId, tenant); return(tenant); }
public MessageRoute[] Route(Type messageType) { if (_routes.TryFind(messageType, out var routes)) { return(routes); } routes = compileRoutes(messageType).ToArray(); _routes = _routes.AddOrUpdate(messageType, routes); return(routes); }
internal IEnumerable <Type> GetTypeDependencies(Type type) { if (_typeDependencies.TryFind(type, out var deps)) { return(deps); } deps = determineTypeDependencies(type); _typeDependencies = _typeDependencies.AddOrUpdate(type, deps); return(deps); }
public async Task <MessageRoute[]> Route(Type messageType) { if (_routes.TryFind(messageType, out var routes)) { return(routes); } routes = (await compileRoutes(messageType)).ToArray(); _routes = _routes.AddOrUpdate(messageType, routes); return(routes); }
public static Task <AssemblyTypes> ForAssembly(Assembly assembly) { if (_assemblies.TryFind(assembly, out var types)) { return(types); } types = Task.Factory.StartNew(() => new AssemblyTypes(assembly)); _assemblies = _assemblies.AddOrUpdate(assembly, types); return(types); }
public void GlobalSetup() { var keys = _keys; for (var i = 0; i < ItemCount; i++) { var key = keys[i]; _concurrentDict.TryAdd(key, "a"); Interlocked.Exchange(ref _imMap, _imMap.AddOrUpdate(key, "a")); _mapLinearWithDistanceBuffer.AddOrUpdate(key, "a"); _mapLeapfrogWithDistanceBuffer.AddOrUpdate(key, "a"); _mapLinear.AddOrUpdate(key, "a"); } _concurrentDict.TryAdd(_key, _value); Interlocked.Exchange(ref _imMap, _imMap.AddOrUpdate(_key, _value)); _mapLinearWithDistanceBuffer.AddOrUpdate(_key, _value); _mapLeapfrogWithDistanceBuffer.AddOrUpdate(_key, _value); _mapLinear.AddOrUpdate(_key, _value); }
public ReaderCollection <TReader> ReaderFor(string messageType) { if (_modelReaders.TryFind(messageType, out var reader)) { return(reader); } var modelReader = compileReader(messageType); _modelReaders = _modelReaders.AddOrUpdate(messageType, modelReader); return(modelReader); }
public WriterCollection <TWriter> WriterFor(Type messageType) { if (_modelWriters.TryFind(messageType, out var writer)) { return(writer); } var modelWriter = compileWriter(messageType); _modelWriters = _modelWriters.AddOrUpdate(messageType, modelWriter); return(modelWriter); }
/// <summary> /// These mappings should only be used for Linq querying within the SelectMany() body /// </summary> /// <param name="type"></param> /// <returns></returns> internal IFieldMapping ChildTypeMappingFor(Type type) { if (_childFieldMappings.TryFind(type, out var mapping)) { return(mapping); } mapping = new FieldMapping("d.data", type, this); _childFieldMappings = _childFieldMappings.AddOrUpdate(type, mapping); return(mapping); }
// Creating a new registry with +1 registration and the new reference to cache value public Registry With(Type serviceType, Factory implFactory) { return(new Registry { _registrations = _registrations.AddOrUpdate(serviceType, implFactory), // Here is the most interesting part: // // We are creating a new independent reference pointing to the cache value, // isolating it from any possible parallel resolutions, with will proceed to work with the old cache. // _resolutionCache = Ref.Of(_resolutionCache.Value) }); }
public DocumentProvider <T> StorageFor <T>() { if (_storage.TryFind(typeof(T), out var stored)) { return(stored.As <DocumentProvider <T> >()); } Tenant.EnsureStorageExists(typeof(T)); var persistence = _inner.StorageFor <T>(); _storage = _storage.AddOrUpdate(typeof(T), persistence); return(persistence); }
internal ICompiledQuerySource GetCompiledQuerySourceFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, IMartenSession session) { if (_querySources.TryFind(query.GetType(), out var source)) { return(source); } var plan = QueryCompiler.BuildPlan(session, query, this); source = new CompiledQuerySourceBuilder(plan, this).Build(); _querySources = _querySources.AddOrUpdate(query.GetType(), source); return(source); }
public static string DetermineTopicName(Type messageType) { if (_topics.TryFind(messageType, out var topic)) { return(topic); } topic = messageType.HasAttribute <TopicAttribute>() ? messageType.GetAttribute <TopicAttribute>().TopicName : messageType.ToMessageTypeName(); _topics = _topics.AddOrUpdate(messageType, topic); return(topic); }