internal static RequestDelegate ShareMyData(RequestDelegate next) { return(async ctx => { var navigations = NavigationApiMiddleWare.GetNavigationsFromAssembly <Navigation>().ToList(); if (navigations.HasAny()) { try { var url = Microservice.Of("Hub").Url("local-setup"); navigations.Do(r => r.Define()); new WebClient().UploadString(url, Newtonsoft.Json.JsonConvert.SerializeObject(new { Service = GetService(), BoardSources = GetBoardSources(navigations), Features = GetFeatures(navigations), GlobalySearchable = GetControllerFromAssembly <Olive.GlobalSearch.SearchSource>().HasAny() })); Shared = true; } catch (Exception ex) { Log.For(typeof(DevelopmentShareInfo)).Error("With URL: " + Microservice.Of("Hub").Url("local-setup") + "\nCould not reach local hub.\n" + ex); } } await next(ctx); }); }
public void Constructor_WithEmptyFeatureInstances_ThrowsException() { Assert.Throws <ArgumentException>(() => { var sot = new Microservice(Enumerable.Empty <FeatureInstance>()); }); }
public void OpenAndStartServiceHostTestWithSB() { var host = getMicroserviceHostWithTableStorage(); Microservice service = new Microservice(); service.InputArgument = new Daenet.DurableTaskMicroservices.Tests.TestOrchestrationInput() { Counter = 2, Delay = 1000, }; service.OrchestrationQName = typeof(CounterOrchestration).AssemblyQualifiedName; service.ActivityQNames = new string[] { typeof(Task1).AssemblyQualifiedName, typeof(Task2).AssemblyQualifiedName, }; host.LoadService(service); host.OpenAsync().Wait(); // This is client side code. var instance = host.StartServiceAsync(service.OrchestrationQName, service.InputArgument).Result; Debug.WriteLine($"Microservice instance {instance.OrchestrationInstance.InstanceId} started"); host.WaitOnInstanceAsync(instance).Wait(); }
private void lstItemsMicroservice_SelectedIndexChanged(object sender, EventArgs e) { Microservice microservice = (Microservice)lstItemsMicroservice.SelectedItem; _selectedMicroserviceId = microservice != null ? microservice.Id : 0; lblDescricao.Text = microservice != null ? microservice.Description : ""; }
public void Initialise() { mService = new Microservice(); //mService. mService.Start(); }
private void waitOnInstance(ServiceHost host, Microservice service, MicroserviceInstance instance) { ManualResetEvent mEvent = new ManualResetEvent(false); new Thread(() => { while (true) { try { Thread.Sleep(1000); var cnt = host.GetNumOfRunningInstances(service); if (cnt == 0) { mEvent.Set(); Debug.WriteLine($"Microservice instance {instance.OrchestrationInstance.InstanceId} completed."); break; } } catch (Exception ex) { mEvent.Set(); Assert.Fail(ex.Message); } } }).Start(); mEvent.WaitOne(); }
/// <summary> /// Tries to decompose an event identifier <see cref="string"/> to its components. /// </summary> /// <param name="eventIdentifier">The event identifier <see cref="string"/>.</param> /// <param name="microservice">When this method returns, the <see cref="Microservice"/> that committed the event.</param> /// <param name="tenant">When this method returns, the <see cref="TenantId"/> that committed the event.</param> /// <param name="sequenceNumber">When this method returns, the <see cref="EventLogSequenceNumber"/> of the event that was committed.</param> /// <returns><c>true</c> if the deomposition was successful; otherwise, <c>false</c>.</returns> public static bool TryDecompose(string eventIdentifier, out Microservice microservice, out TenantId tenant, out EventLogSequenceNumber sequenceNumber) { var decoded = new Span <byte>(new byte[40]); if (Convert.TryFromBase64String(eventIdentifier, decoded, out var read) && read == 40) { var microserviceBytes = decoded.Slice(0, 16); var tenantBytes = decoded.Slice(16, 16); var sequenceNumberBytes = decoded.Slice(32, 8); if (!BitConverter.IsLittleEndian) { sequenceNumberBytes.Reverse(); } microservice = new Guid(microserviceBytes); tenant = new Guid(tenantBytes); sequenceNumber = BitConverter.ToUInt64(sequenceNumberBytes); return(true); } microservice = null; tenant = null; sequenceNumber = 0; return(false); }
public void OpenAndStartServiceHostTest() { var host = createMicroserviceHost(); Microservice service = new Microservice(); service.InputArgument = new TestOrchestrationInput() { Counter = 3, Delay = 1000, }; service.OrchestrationQName = typeof(CounterOrchestration).AssemblyQualifiedName; service.ActivityQNames = new string[] { typeof(Task1).AssemblyQualifiedName, typeof(Task2).AssemblyQualifiedName, }; host.LoadService(service); host.Open(); // This is client side code. var instance = host.StartService(service.OrchestrationQName, service.InputArgument); Debug.WriteLine($"Microservice instance {instance.OrchestrationInstance.InstanceId} started"); waitOnInstance(host, service, instance); }
private static void runSample1() { ServiceHost host = new ServiceHost(m_ServiceBusConnectionString, m_StorageConnectionString, nameof(runSample1)); Microservice microSvc = new Microservice(); #region How to create Config automatically? //microSvc.InputArgument = new CounterOrchestrationInput() { Counter = 1, Delay = 2 }; //xmlSerializeService(microSvc, "c:\\temp\\aaa.xml"); #endregion var instances = host.LoadServiceFromXml("counterorchestration.config.xml", new List <Type>() { typeof(CounterOrchestrationInput) }, out microSvc); host.Open(); var instance = host.StartService(microSvc.OrchestrationQName, microSvc.InputArgument); Debug.WriteLine($"Microservice instance {instance.OrchestrationInstance.InstanceId} started"); waitOnInstance(host, microSvc, instance); }
public MicroserviceTests() { _instances = new Dictionary <Uri, IMicroserviceInstance>(); _metricDictionary = new Dictionary <MetricType, IInstanceMetric>(); _servicesNames = new List <string>(); _sut = new Microservice(MicroserviceName, _servicesNames, _instances); }
/// <summary> /// Initializes a new instance of the <see cref="ExecutionContextManager"/> class. /// </summary> /// <param name="logger"><see cref="ILogger"/> for logging.</param> public ExecutionContextManager(ILogger logger) { _logger = logger; _microservice = Microservice.NotSet; _version = Version.NotSet; _environment = Environment.Undetermined; }
public override void ConfigureServices(IServiceCollection services) { services.AddCors(x => x.AddPolicy("AllowHubOrigin", f => f.WithOrigins(Microservice.Of("Hub").Url().TrimEnd("/"), HubDevUrl) .AllowAnyHeader().AllowAnyMethod().AllowCredentials())); base.ConfigureServices(services); }
private JObject WriteMicroservice(Microservice microservice) { return(new JObject( new JProperty("id", new JValue(microservice.Id.ToString())), new JProperty("name", new JValue(microservice.Id.ToString())), new JProperty("features", new JArray(microservice.Select(WriteFeature))) )); }
public void SerializeJsonConfigTest(string fileName) { Microservice service = getMicroService(); string jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(service); File.WriteAllText(GetPathForFile(fileName), jsonString); }
public void When_passed_name_to_constructor_then_instances_should_be_empty() { // Act _sut = new Microservice(MicroserviceName); // Assert Assert.NotNull(_sut.GetInstances()); Assert.Empty(_sut.GetInstances()); }
public void ServiceUrlWithoutPortTest() { var service = new Microservice() { DomainName = "http://localhost" }; Assert.AreEqual("http://localhost", service.ServiceUrl); }
public void GatewayBaseUrlTest() { var service = new Microservice() { Prefix = "Authentication" }; Assert.IsTrue(service.GatewayBaseUrl.EndsWith("Authentication", StringComparison.Ordinal)); }
/// <inheritdoc/> public void SetConstants( Microservice microservice, Version version, Environment environment) { _microservice = microservice; _version = version; _environment = environment; }
/// <summary> /// Initializes a new instance of the <see cref="SubscriptionId"/> class. /// </summary> /// <param name="consumerTenant">The consumer <see cref="TenantId" />.</param> /// <param name="producerMicroservice">The producer <see cref="Microservice" />.</param> /// <param name="producerTenant">The producer <see cref="TenantId" />.</param> /// <param name="scope">The <see cref="Events.Store.ScopeId" />.</param> /// <param name="stream">The public <see cref="Events.Store.Streams.StreamId" /> to subscribe to.</param> /// <param name="partition">The <see cref="Events.Store.Streams.PartitionId" /> in the stream to subscribe to.</param> public SubscriptionId(TenantId consumerTenant, Microservice producerMicroservice, TenantId producerTenant, ScopeId scope, StreamId stream, PartitionId partition) { ConsumerTenantId = consumerTenant; ProducerMicroserviceId = producerMicroservice; ProducerTenantId = producerTenant; ScopeId = scope; StreamId = stream; PartitionId = partition; }
public override void ConfigureServices(IServiceCollection services) { Configuration.MergeEnvironmentVariables(); services.AddCors(x => x.AddPolicy("AllowHubOrigin", f => f.WithOrigins(Microservice.Of("Hub").Url().TrimEnd("/"), HubDevUrl) .SetIsOriginAllowed(x => true) .AllowAnyHeader().AllowAnyMethod().AllowCredentials())); base.ConfigureServices(services); }
static void Main(string[] args) { Serilog.Log.Logger = LoggerConfiguration.ConfigureLogger(); AppDomain.CurrentDomain.ProcessExit += ProcessExit; Microservice.StartAsync <Startup>(cancellationTokenSource.Token).Wait(); Serilog.Log.Logger.Information("Process Exited"); }
protected virtual void Dispose(bool disposing) { if (disposing) { Container?.Dispose(); Microservice?.Dispose(); FirstChanceExceptionListener?.Dispose(); UnhandledExceptionListener?.Dispose(); } }
public void Delete(int microserviceId) { CustomerMicroserviceService customerMicroserviceService = new CustomerMicroserviceService(); customerMicroserviceService.DeleteMicroservicesByMicroserviceId(microserviceId); Microservice microservice = GetById(microserviceId); _microserviceRepository.Delete(microservice); }
public static async Task StartServiceAsync(this ServiceHost host, string orchestrationQualifiedName, OrchestrationInput inputArgs, string activityId) { var tp = Type.GetType(orchestrationQualifiedName); if (tp == null) { throw new ArgumentException(String.Format("Cannot lookup type '{0} ", orchestrationQualifiedName)); } Microservice config = ServiceHost.GetServiceConfiguration(String.Empty, tp); var svcCfg = config.ServiceConfiguration as OrchestrationConfig; if (svcCfg == null) { throw new ArgumentException(String.Format("Specified orchestration configuration is not of type 'OrchestrationConfig'. Failed by starting of '{1}' - Specified (invalid) configuration type: '{2}'.", orchestrationQualifiedName, config)); } if (!String.IsNullOrEmpty(svcCfg.LogTraceSourceName)) { foreach (var item in config.ActivityConfiguration) { TaskConfig cfg = item.Value as TaskConfig; // // We can have configuration, which is not of type of TaskConfig. if (cfg != null) { if (String.IsNullOrEmpty(cfg.LogTraceSourceName)) { cfg.LogTraceSourceName = svcCfg.LogTraceSourceName; } } } } // // Generate new Guid if not set if (String.IsNullOrEmpty(activityId)) { activityId = Guid.NewGuid().ToString(); } inputArgs.Context = new Dictionary <string, object>(); var logCtx = new LoggingContext(); logCtx.LoggingScopes = new Dictionary <string, string>(); logCtx.LoggingScopes.Add("ActivityId", activityId); inputArgs.Context.Add("Orchestration", config.Type.FullName); inputArgs.Context.Add("ParentLoggingContext", logCtx); await host.StartServiceAsync(orchestrationQualifiedName, inputArgs); }
public void MicroserviceValidationTest() { var service = new Microservice() { Endpoints = null }; var result = service.Validate(); Assert.IsFalse(result); }
public void MicroserviceWithoutEndpointsTest() { var service = new Microservice() { Endpoints = new List <Endpoint>() }; var result = service.Validate(); Assert.IsFalse(result); }
public override void ConfigureServices(IServiceCollection services) { var permittedUrls = Config.Get("PermittedDomains").Split(",").Union(Microservice.Of("Hub").Url()).Select(d => d.TrimEnd("/")).Union(HubDevUrl).ToArray(); Configuration.MergeEnvironmentVariables(); services.AddCors(x => x.AddPolicy("AllowHubOrigin", f => f.WithOrigins(permittedUrls) .SetIsOriginAllowed(x => true) .AllowAnyHeader().AllowAnyMethod().AllowCredentials())); base.ConfigureServices(services); }
public ActionResult <IList <Microservice> > Add(Microservice service) { var result = this.serviceManager.Register(service); if (result) { return(Ok(service)); } else { return(BadRequest()); } }
public void ToString_Returns_NonEmptyString() { var aProperties = new[] { new Property(new PropertyIdentifier("p1"), "p1") }; var bProperties = new[] { new Property(new PropertyIdentifier("p2"), "p2") }; var featureInstances = new[] { new FeatureInstance(new Feature(new FeatureIdentifier("a"), "a", aProperties), aProperties.Select(p => p.Id)), new FeatureInstance(new Feature(new FeatureIdentifier("b"), "b", bProperties), bProperties.Select(p => p.Id)) }; var microservice = new Microservice(featureInstances); Assert.False(string.IsNullOrEmpty(microservice.ToString())); }
private static void serializeService(Microservice svc) { using (XmlWriter writer = XmlWriter.Create("abc.xml", new XmlWriterSettings() { Indent = true })) { DataContractSerializerSettings sett = new DataContractSerializerSettings(); DataContractSerializer ser = new DataContractSerializer(typeof(Microservice), loadKnownTypes()); ser.WriteObject(writer, (Microservice)svc); } }