internal UnicastBus() { EnableByDefault(); Defaults(s => { /* * string fullPathToStartingExe; * s.SetDefault("NServiceBus.HostInformation.HostId", GenerateDefaultHostId(out fullPathToStartingExe)); */ var HostIdSettingsKey = "NServiceBus.HostInformation.HostId"; var fullPathToStartingExe = PathUtilities.SanitizedPath(Environment.CommandLine); if (!s.HasExplicitValue(HostIdSettingsKey)) { s.SetDefault(HostIdSettingsKey, DeterministicGuid.Create(fullPathToStartingExe, RuntimeEnvironment.MachineName)); } s.SetDefault("NServiceBus.HostInformation.DisplayName", RuntimeEnvironment.MachineName); s.SetDefault("NServiceBus.HostInformation.Properties", new Dictionary <string, string> { { "Machine", RuntimeEnvironment.MachineName }, { "ProcessID", Process.GetCurrentProcess().Id.ToString() }, { "UserName", Environment.UserName }, { "PathToExecutable", fullPathToStartingExe } }); }); }
public void SameProducesSameGuid(KeyValuePair <string, int> testObject) { var first = DeterministicGuid.Create(testObject); var second = DeterministicGuid.Create(testObject); first.Should().Be(second); }
public void DifferntProduceDifferentGuids(KeyValuePair <string, int> firstObject, KeyValuePair <string, int> secondObject) { var first = DeterministicGuid.Create(firstObject); var second = DeterministicGuid.Create(secondObject); first.Should().NotBe(second); }
public static async Task <string> GetOrCreateEssence(DemographicsDocument document, IDatabaseAsync database) { var keys = GetKeys(document); var results = await Task.WhenAll(keys.Select(key => database.StringGetAsync(key)).ToArray()); var maybeMatches = results .Zip(keys, (value, key) => new { Key = key, Value = value }) .ToLookup(x => x.Value.HasValue); var essenceId = maybeMatches[true] .Select(redisValue => (string)redisValue.Value) .GroupBy(_ => _) .OrderByDescending(valueGroup => valueGroup.Count()) .Select(valueGroup => valueGroup.Key) .FirstOrDefault(); essenceId = essenceId ?? EssenceId.Create(document.DocumentId).ToString("N"); var unmatchedKeys = maybeMatches[false].Select(x => x.Key).ToArray(); await Task.WhenAll(unmatchedKeys.Select(key => database.StringSetAsync(key, essenceId))); return(essenceId); }
public void Customize(BusConfiguration configuration) { var endpointName = "Case00030984"; //Hard coded var resourceManagerId = DeterministicGuid.Create(endpointName + "-NServiceBus@" + Environment.MachineName); //replaced with copy of version used by NServiceBus var programDataPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData); var txRecoveryPath = Path.Combine(programDataPath, "NServiceBus.RavenDB", resourceManagerId.ToString()); var store = new DocumentStore() { ConnectionStringName = "ravendb", //hard coded DefaultDatabase = endpointName, ResourceManagerId = resourceManagerId, TransactionRecoveryStorage = new LocalDirectoryTransactionRecoveryStorage(txRecoveryPath) }; store.Initialize(); var logger = LogManager.GetLogger(endpointName); logger.InfoFormat("Recovery path for NServiceBBus raven store: '{0}' set to: '{1}'", store.ResourceManagerId, txRecoveryPath); configuration.EndpointName(endpointName); configuration.UseTransport <MsmqTransport>(); configuration.UseSerialization <XmlSerializer>(); var persistence = configuration.UsePersistence <RavenDBPersistence>().DoNotSetupDatabasePermissions(); persistence.SetDefaultDocumentStore(store); }
private IEnumerable <object> ScopedHandle(Envelope <MessageContext, object> mainEnvelope) { var tenantId = mainEnvelope.Header.MetadataLookup["tenantId"].First() as string; if (tenantId == null) { return new[] { new NotHandled(mainEnvelope) } } ; var scopedDispatcher = new Dispatcher(); scopedDispatcher.Register <WriteToStream>(writeToStream => { var envelope = Envelope.Create(mainEnvelope.Header, writeToStream); Task.WhenAll(EventStoreHandlers.WriteAsync(envelope, _eventStoreConnection)).Wait(); return(Enumerable.Empty <object>()); }); scopedDispatcher.Register <Envelope <MessageContext, ItemPurchased> >(envelope => { var eventId = EventId.Create(mainEnvelope.Header.EventId); return(InventoryProjectionHandlers.Project(envelope.Body, eventId, envelope.Header.StreamContext.EventNumber)); }); var connectionSettingsFactory = new MultitenantSqlConnectionSettingsFactory(tenantId); var connectionStringSettings = connectionSettingsFactory.GetSettings("Projections"); var connectionString = connectionStringSettings.ConnectionString; _hasInitialized.GetOrAdd(tenantId, _ => { var executor = new SqlCommandExecutor(connectionStringSettings); executor.ExecuteNonQuery(InventoryProjectionHandlers.CreateSchema()); return(Nothing.Value); }); var sqlConnection = new SqlConnection(connectionString); sqlConnection.Open(); using (sqlConnection) using (var transaction = sqlConnection.BeginTransaction()) { var sqlExecutor = new ConnectedTransactionalSqlCommandExecutor(transaction); scopedDispatcher.Register <SqlNonQueryCommand>(command => { sqlExecutor.ExecuteNonQuery(command); return(Enumerable.Empty <object>()); }); var typedMainEnvelope = Envelope.CreateGeneric(mainEnvelope.Header, mainEnvelope.Body); var unhandled = scopedDispatcher.DispatchExhaustive(typedMainEnvelope); transaction.Commit(); return(unhandled); } }
/// <summary> /// The format id. /// </summary> /// <param name="messageType"> /// The message type. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string FormatId(MessageType messageType) { Contract.Requires <ArgumentNullException>(messageType != null, "messageType != null"); Contract.Ensures(Contract.Result <string>() != null); var id = DeterministicGuid.Create(messageType.TypeName, "/", messageType.Version.Major); return(string.Format("Subscriptions/{0}", id)); }
public void It_allows_to_generate_a_deterministic_id_using_instance_and_host_names() { var busConfig = new EndpointConfiguration("myendpoint"); busConfig.UniquelyIdentifyRunningInstance().UsingNames("Instance", "Host"); var configuredId = busConfig.Settings.Get <HostingComponent.Settings>().HostId; Assert.AreEqual(DeterministicGuid.Create("Instance", "Host"), configuredId); }
public static HostInformation CreateDefault() { var commandLine = Environment.CommandLine; var fullPathToStartingExe = commandLine.Split('"')[1]; var hostId = DeterministicGuid.Create(fullPathToStartingExe, Environment.MachineName); return(new HostInformation(hostId, Environment.MachineName, String.Format("{0}", fullPathToStartingExe))); }
static async Task Main(string[] args) { var instanceName = args.FirstOrDefault(); if (string.IsNullOrEmpty(instanceName)) { Console.Title = "Destination1"; instanceName = "destination1"; } else { Console.Title = $"{instanceName}"; } var instanceId = DeterministicGuid.Create(instanceName); var endpointConfiguration = new EndpointConfiguration(instanceName); endpointConfiguration.UseTransport <LearningTransport>(); endpointConfiguration.UsePersistence <LearningPersistence>(); endpointConfiguration.EnableInstallers(); endpointConfiguration.UseSerialization <NewtonsoftSerializer>(); endpointConfiguration.SendFailedMessagesTo("error"); endpointConfiguration.AuditProcessedMessagesTo("audit"); // just to show the flexibility var recoverability = endpointConfiguration.Recoverability(); recoverability.Immediate(c => c.NumberOfRetries(3)); recoverability.Delayed(c => c.NumberOfRetries(2).TimeIncrease(new TimeSpan(2))); // this is just here to make it possible to retry a message that went into the error queue endpointConfiguration.Notifications.Errors.MessageSentToErrorQueue += (sender, message) => { Handler.messageIds.TryAdd(message.MessageId, message.MessageId); }; endpointConfiguration.UniquelyIdentifyRunningInstance() .UsingCustomDisplayName(instanceName) .UsingCustomIdentifier(instanceId); var metrics = endpointConfiguration.EnableMetrics(); metrics.SendMetricDataToServiceControl( "Particular.Monitoring", TimeSpan.FromMilliseconds(500) ); var endpoint = await Endpoint.Start(endpointConfiguration); Console.WriteLine($"Started {instanceName}"); Console.ReadLine(); await endpoint.Stop(); }
public void UsingNames() { var context = new Context(); Scenario.Define(context) .WithEndpoint <UsingNames_Endpoint>(e => e.Given(b => b.SendLocal(new MyMessage()))) .Done(c => c.HostId != Guid.Empty) .Run(); Assert.AreEqual(DeterministicGuid.Create(instanceName, hostName), context.HostId); }
public DefaultHostIdGenerator(string commandLine, string machineName) { if (commandLine.StartsWith("\"")) { FullPathToStartingExe = (from Match match in Regex.Matches(commandLine, "\"([^\"]*)\"") select match.ToString()).First().Trim('"'); } else { FullPathToStartingExe = commandLine.Split(' ').First(); } HostId = DeterministicGuid.Create(FullPathToStartingExe, machineName); }
public Task Configure() { SagaIdGenerator = new LearningSagaIdGenerator(); SagaStorage = new LearningSagaPersister(); var sagaManifests = new SagaManifestCollection(SagaMetadataCollection, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ".sagas"), name => DeterministicGuid.Create(name).ToString()); SynchronizedStorage = new LearningSynchronizedStorage(sagaManifests); SynchronizedStorageAdapter = new LearningStorageAdapter(); return(Task.CompletedTask); }
private async Task <IEnumerable <object> > IndexAndQueryBestMatch(Envelope <MessageContext, DemographicsDocument> envelope) { var database = _redisConnection.GetDatabase(); var transaction = database.CreateTransaction(); var document = envelope.Body; var essenceId = await MatchingHandlers.GetOrCreateEssence(document, transaction); var matchedEvent = new DemographicsMatched(document.DocumentId, essenceId); var eventId = EventId.Create(envelope.Header.EventId); var writeEvent = new WriteToStream(eventId, "matched", matchedEvent); return(new[] { writeEvent }); }
internal static HostInformation CreateHostInformation(string commandLine, string machineName) { string fullPathToStartingExe; if (commandLine.StartsWith("\"")) { fullPathToStartingExe = (from Match match in Regex.Matches(commandLine, "\"([^\"]*)\"") select match.ToString()).First().Trim('"'); } else { fullPathToStartingExe = commandLine.Split(' ').First(); } var hostId = DeterministicGuid.Create(fullPathToStartingExe, machineName); return(new HostInformation(hostId, machineName, String.Format("{0}", fullPathToStartingExe))); }
public static HostInformation CreateDefault() { var commandLine = Environment.CommandLine; var commandLineParts = commandLine.Split('"'); var fullPathToStartingExe = ""; if (commandLineParts.Length > 1) { fullPathToStartingExe = commandLineParts[1]; } else if (commandLineParts.Length == 1) { fullPathToStartingExe = commandLineParts[0]; } var hostId = DeterministicGuid.Create(fullPathToStartingExe, Environment.MachineName); return(new HostInformation(hostId, Environment.MachineName, String.Format("{0}", fullPathToStartingExe))); }
public HostInformationFeature() { EnableByDefault(); Defaults(s => { var fullPathToStartingExe = PathUtilities.SanitizedPath(Environment.CommandLine); if (!s.HasExplicitValue(HostIdSettingsKey)) { s.SetDefault(HostIdSettingsKey, DeterministicGuid.Create(fullPathToStartingExe, RuntimeEnvironment.MachineName)); } s.SetDefault("NServiceBus.HostInformation.DisplayName", RuntimeEnvironment.MachineName); s.SetDefault("NServiceBus.HostInformation.Properties", new Dictionary <string, string> { { "Machine", RuntimeEnvironment.MachineName }, #pragma warning disable PC001 { "ProcessID", Process.GetCurrentProcess().Id.ToString() }, #pragma warning restore PC001 { "UserName", Environment.UserName }, { "PathToExecutable", fullPathToStartingExe } }); }); }
static async Task Main(string[] args) { Console.WriteLine(Environment.CommandLine); var id = DeterministicGuid.Create(args[0]); var mutexName = id.ToString("N"); using var appSingleton = new System.Threading.Mutex(false, mutexName, out var createdNew); if (!createdNew) { Console.WriteLine("Single instance!"); return; } Configuration.ConnectionString = args[0]; TelemetryClient telemetryClient = null; if (Configuration.AppInsightKey != null) { var configuration = TelemetryConfiguration.CreateDefault(); configuration.InstrumentationKey = Configuration.AppInsightKey; telemetryClient = new TelemetryClient(configuration); } if (args.Contains("--reset")) { Console.WriteLine("Cleaning wait_time stats ..."); await ClearWaitTimeStats(); } telemetryClient?.TrackTrace("Monitor started"); Console.WriteLine("Monitor started"); DateTime RoundUp(DateTime dt, TimeSpan d) { return(new DateTime((dt.Ticks + d.Ticks - 1) / d.Ticks * d.Ticks, dt.Kind)); } var interval = TimeSpan.FromSeconds(30); // Report granulatity is 1 minute, must be reporting more often to ensure every minute has atleast one sample. var now = DateTime.UtcNow; var next = RoundUp(now, interval); var delay = next - now; await Task.Delay(delay); // Align clock while (true) { try { async Task Invoke() { var pageLatchMetrics = await GetPageLatchStats(); if (telemetryClient != null) { pageLatchMetrics.ToList().ForEach(m => telemetryClient.TrackMetric(m)); await foreach (var item in GetQueueLengthsMetric()) { telemetryClient.TrackMetric(item); } telemetryClient.Flush(); } } now = DateTime.UtcNow; // Keeps invocation spot on the interval next += interval; delay = next - now; await Task.WhenAll( Task.Delay(delay), Invoke() ); } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.White; Console.BackgroundColor = ConsoleColor.DarkRed; Console.WriteLine(ex); Console.ForegroundColor = ConsoleColor.Gray; Console.BackgroundColor = ConsoleColor.Black; } } }
public void DeterministicGuid_Version5() { var actual = DeterministicGuid.Create(DeterministicGuid.DnsNamespace, "www.example.com", DeterministicGuidVersion.Version5); Assert.Equal(Guid.Parse("2ed6657d-e927-568b-95e1-2665a8aea6a2"), actual); }
public void DeterministicGuid_Version3_Dns(string name, string expectedGuid) { var actual = DeterministicGuid.Create(DeterministicGuid.DnsNamespace, name, DeterministicGuidVersion.Version3); Assert.Equal(Guid.Parse(expectedGuid), actual); }
public static string FormatId(MessageType messageType) { var id = DeterministicGuid.Create(messageType.TypeName, "/", messageType.Version.Major); return(string.Format("Subscriptions/{0}", id)); }
public Guid NewGuid() { return(DeterministicGuid.Create(_orchestrationGuidNamespace, $"{ExecutionId}/{++_count}")); }