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