private static TActor CreateActor <TActor>( ActorService service, ActorId id) where TActor : Actor { TActor actor; IServiceEventSource eventSource = null; try { var actorContainer = GetActorContainer(service, id); eventSource = actorContainer.GetInstance <IServiceEventSource>(); eventSource.ServiceTypeRegistered(Process.GetCurrentProcess().Id, Naming.GetServiceName <TActor>()); actor = actorContainer.GetInstance <TActor>(); var stateManager = (LazyActorStateManager)actorContainer.GetInstance <IActorStateManager>(); stateManager.SetActorStateManager(actor.StateManager); } catch (Exception e) { eventSource?.ServiceHostInitializationFailed(e.ToString()); throw; } return(actor); }
/// <summary> /// ConfigurationProvider constructor. /// </summary> /// <param name="serviceName">Name of the service.</param> /// <param name="context">CodePackageActivationContext instance.</param> /// <param name="eventSource">IServiceEventSource instance for logging.</param> /// <param name="partition">Partition identifier.</param> /// <param name="replica">Replica or instance identifier.</param> public ConfigurationProvider(Uri serviceName, ICodePackageActivationContext context, IServiceEventSource eventSource, Guid partition, long replica) { Guard.ArgumentNotNull(serviceName, nameof(serviceName)); Guard.ArgumentNotNull(context, nameof(context)); _serviceNameUri = serviceName; _serviceName = _serviceNameUri.Segments[_serviceNameUri.Segments.Length - 1]; _eventSource = eventSource; _partitionId = partition; _replicaOrInstanceId = replica; // Subscribe to configuration change events if the context was passed. It will not be passed for unit tests. if (null != context) { context.ConfigurationPackageAddedEvent += CodePackageActivationContext_ConfigurationPackageAddedEvent; context.ConfigurationPackageModifiedEvent += CodePackageActivationContext_ConfigurationPackageModifiedEvent; context.ConfigurationPackageRemovedEvent += Context_ConfigurationPackageRemovedEvent; } // Configuration has already been loaded by the time we subscribe to the events above, initialize the configuration the first time. IList <string> names = context.GetConfigurationPackageNames(); ConfigurationPackage pkg = context.GetConfigurationPackageObject(c_ConfigurationPackageObjectName); // Create the add event parameters and call. PackageAddedEventArgs <ConfigurationPackage> evt = new PackageAddedEventArgs <ConfigurationPackage>(); evt.Package = pkg; CodePackageActivationContext_ConfigurationPackageAddedEvent(null, evt); }
public static void Add( this IServiceCollection @this, IServiceEventSource serviceEventSource) { if (@this == null) { throw new ArgumentNullException(nameof(@this)); } if (serviceEventSource == null) { throw new ArgumentNullException(nameof(serviceEventSource)); } var type = serviceEventSource.GetType(); foreach (var @interface in type .GetInterfaces() .Where(@interface => typeof(IServiceEventSourceInterface).IsAssignableFrom(@interface))) { @this.Add(new ServiceDescriptor(@interface, serviceEventSource)); } @this.Add(new ServiceDescriptor(type, serviceEventSource)); @this.Add(new ServiceDescriptor(typeof(IServiceEventSource), serviceEventSource)); }
public ServiceHostDelegateLogger( ServiceContext serviceContext, IServiceEventSource eventSource, string eventCategoryName, IConfigurableObjectLoggerOptions options) : base(serviceContext, eventSource, eventCategoryName, options) { }
public Owin(StatelessServiceContext serviceContext, IServiceEventSource serviceEventSource, Action <IAppBuilder> appBuilder) : base(serviceContext) { Requires.IsNotNull(serviceEventSource, nameof(serviceEventSource)); Requires.IsNotNull(appBuilder, nameof(appBuilder)); _serviceEventSource = serviceEventSource; _appBuilder = appBuilder; }
public ServiceHostGenericListenerLogger( IServiceHostGenericListenerInformation listenerInformation, ServiceContext serviceContext, IServiceEventSource eventSource, string eventCategoryName, IConfigurableObjectLoggerOptions options) : base(listenerInformation, serviceContext, eventSource, eventCategoryName, options) { }
/// <summary> /// OwinCommunicationListener constructor. /// </summary> /// <param name="appRoot">String containing the application root name of the service. Defaults to the service type name if not specified.</param> /// <param name="instance">Partition operation class instance.</param> /// <param name="context">ServiceContext instance containing information about the service instance.</param> /// <param name="evtSrc">IServiceEventSource to allow diagnostic logging from within this instance.</param> public StatefulOwinCommunicationListener(string appRoot, TOperations instance, ServiceContext context, IServiceEventSource evtSrc) { Guard.ArgumentNotNull(instance, nameof(instance)); Guard.ArgumentNotNull(context, nameof(context)); Guard.ArgumentNotNull(evtSrc, nameof(evtSrc)); _appRoot = string.IsNullOrWhiteSpace(appRoot) ? context.ServiceTypeName : appRoot.TrimEnd('/'); _partitionOperations = instance; _context = context; _eventSource = evtSrc; }
protected ServiceHostListenerLogger( IServiceHostListenerInformation listenerInformation, ServiceContext serviceContext, IServiceEventSource eventSource, string eventCategoryName, IConfigurableObjectLoggerOptions options) : base(serviceContext, eventSource, eventCategoryName, options) { this.listenerInformation = listenerInformation ?? throw new ArgumentNullException(nameof(listenerInformation)); }
protected BackupRestoreActorService(StatefulServiceContext context, ActorTypeInformation actorTypeInfo, IFileStore fileStore, IServiceEventSource serviceEventSource, Func <ActorService, ActorId, ActorBase> actorFactory = null, Func <ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null, IActorStateProvider stateProvider = null, ActorServiceSettings settings = null) : base(context, actorTypeInfo, actorFactory, stateManagerFactory, stateProvider, settings) { this._serviceEventSource = serviceEventSource; this._fileStore = fileStore; }
public OwinCommunicationListener(Action <IAppBuilder> startup, ServiceContext serviceContext, IServiceEventSource eventSource, string endpointName, string appRoot) { Requires.IsNotNull(startup, nameof(startup)); Requires.IsNotNull(serviceContext, nameof(serviceContext)); Requires.IsNotNull(endpointName, nameof(endpointName)); Requires.IsNotNull(eventSource, nameof(eventSource)); _startup = startup; _serviceContext = serviceContext; _endpointName = endpointName; _eventSource = eventSource; _appRoot = appRoot; }
public MockStatelessService( StatelessServiceContext serviceContext, IServiceEventSource serviceEventSource, IServicePartition servicePartition) { this.serviceContext = serviceContext ?? throw new ArgumentNullException(nameof(serviceContext)); this.serviceEventSource = serviceEventSource ?? throw new ArgumentNullException(nameof(serviceEventSource)); this.servicePartition = servicePartition ?? throw new ArgumentNullException(nameof(servicePartition)); }
public ServiceHostDelegateLoggerProvider( ServiceContext serviceContext, IServiceEventSource eventSource, IConfigurableObjectLoggerOptions loggerOptions) { this.serviceContext = serviceContext ?? throw new ArgumentNullException(nameof(serviceContext)); this.loggerOptions = loggerOptions ?? throw new ArgumentNullException(nameof(loggerOptions)); this.eventSource = eventSource ?? throw new ArgumentNullException(nameof(eventSource)); }
public virtual void Run <T>(string serviceTypeName, IServiceEventSource serviceEventSourceBase) { _eventSource = serviceEventSourceBase; //ILogger logger = null; try { //logger = LoggerFactoryCreator.GetLoggerFactory().Create($"Initialization.{typeof(T).Name}"); RunSpecific(serviceTypeName); } catch (Exception ex) { serviceEventSourceBase.ServiceHostInitializationFailed(ex.ToString()); //logger?.Error("Failed to initialize service", e); throw; } }
public MockStatefulService( StatefulServiceContext serviceContext, IServiceEventSource serviceEventSource, IServicePartition servicePartition, IReliableStateManager reliableStateManager) { this.serviceContext = serviceContext ?? throw new ArgumentNullException(nameof(serviceContext)); this.serviceEventSource = serviceEventSource ?? throw new ArgumentNullException(nameof(serviceEventSource)); this.servicePartition = servicePartition ?? throw new ArgumentNullException(nameof(servicePartition)); this.reliableStateManager = reliableStateManager; }
public ServiceHostRemotingListenerLoggerProvider( IServiceHostRemotingListenerInformation listenerInformation, ServiceContext serviceContext, IServiceEventSource eventSource, IConfigurableObjectLoggerOptions loggerOptions) { this.serviceContext = serviceContext ?? throw new ArgumentNullException(nameof(serviceContext)); this.listenerInformation = listenerInformation ?? throw new ArgumentNullException(nameof(listenerInformation)); this.loggerOptions = loggerOptions ?? throw new ArgumentNullException(nameof(loggerOptions)); this.eventSource = eventSource ?? throw new ArgumentNullException(nameof(eventSource)); }
/// <summary> /// QueueService constructor. /// </summary> /// <param name="context">StatefulServiceContext instance.</param> /// <param name="eventSource">IStatefulServiceEventSource instance for diagnostic logging.</param> public GenericInt64PartitionService(StatefulServiceContext context, IServiceEventSource eventSource) : base(context) { // Check passed parameters. Guard.ArgumentNotNull(context, nameof(context)); Guard.ArgumentNotNull(eventSource, nameof(eventSource)); _eventSource = eventSource; TokenSource = new CancellationTokenSource(); // Parse the service name into an application name. string appName = (Context.ServiceName.Segments.Length > 2) ? Context.ServiceName.Segments[1].Replace("/", "") : ""; Application = new Uri($"fabric:/{appName}"); ConfigurationProvider = new ConfigurationProvider <TConfiguration>(context.ServiceName, context.CodePackageActivationContext, eventSource, Context.PartitionId, Context.ReplicaOrInstanceId); _eventSource?.ServicePartitionConfigurationChanged(Context.ServiceTypeName, Context.PartitionId, Context.ReplicaOrInstanceId); }
protected ServiceHostLogger( ServiceContext serviceContext, IServiceEventSource eventSource, string eventCategoryName, IConfigurableObjectLoggerOptions options) { this.serviceContext = serviceContext ?? throw new ArgumentNullException(nameof(serviceContext)); this.eventSource = eventSource ?? throw new ArgumentNullException(nameof(eventSource)); this.eventCategoryName = eventCategoryName ?? throw new ArgumentNullException(nameof(eventCategoryName)); this.scope = new AsyncLocal <Scope>(); this.options = options ?? throw new ArgumentNullException(nameof(options)); }
private static TService CreateService <TService>(StatefulServiceContext context) where TService : StatefulService { TService service; IServiceEventSource eventSource = null; try { var container = GetContainer(context); eventSource = container.GetInstance <IServiceEventSource>(); eventSource.ServiceTypeRegistered(Process.GetCurrentProcess().Id, Naming.GetServiceName <TService>()); service = container.GetInstance <TService>(); } catch (Exception e) { eventSource?.ServiceHostInitializationFailed(e.ToString()); throw; } return(service); }
public KitchenActorService(StatefulServiceContext context, ActorTypeInformation actorTypeInfo, IFileStore fileStore, IServiceEventSource serviceEventSource, Func <ActorService, ActorId, ActorBase> actorFactory = null, Func <ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null, IActorStateProvider stateProvider = null, ActorServiceSettings settings = null) : base(context, actorTypeInfo, fileStore, serviceEventSource, actorFactory, stateManagerFactory, stateProvider, settings) { }
public static async Task <EmbedConfig> GetEmbedReportConfigData(string clientId, string groupId, string username, string password, string authorityUrl, string resourceUrl, string apiUrl, string reportUniqueId, string reportName, ServiceContext serviceContext, IServiceEventSource serviceEventSource) { ServiceEventSourceHelper serviceEventSourceHelper = new ServiceEventSourceHelper(serviceEventSource); var result = new EmbedConfig(); var roles = ""; try { var error = GetWebConfigErrors(clientId, groupId, username, password); if (error != null) { result.ErrorMessage = error; return(result); } // Create a user password cradentials. var credential = new UserPasswordCredential(username, password); // Authenticate using created credentials var authenticationContext = new AuthenticationContext(authorityUrl); var authenticationResult = await authenticationContext.AcquireTokenAsync(resourceUrl, clientId, credential); if (authenticationResult == null) { result.ErrorMessage = "Authentication Failed."; return(result); } var tokenCredentials = new TokenCredentials(authenticationResult.AccessToken, "Bearer"); // Create a Power BI Client object. It will be used to call Power BI APIs. using (var client = new PowerBIClient(new Uri(apiUrl), tokenCredentials)) { // Get a list of reports. var reports = await client.Reports.GetReportsInGroupAsync(groupId); Report report; if (string.IsNullOrEmpty(reportName)) { // Get the first report in the group. report = reports.Value.FirstOrDefault(); } else { report = reports.Value.FirstOrDefault(r => r.Name.Equals(reportName)); } if (report == null) { result.ErrorMessage = $"PowerBI Group has no report registered for Name[{reportName}]."; return(result); } var datasets = await client.Datasets.GetDatasetByIdInGroupAsync(groupId, report.DatasetId); result.IsEffectiveIdentityRequired = datasets.IsEffectiveIdentityRequired; result.IsEffectiveIdentityRolesRequired = datasets.IsEffectiveIdentityRolesRequired; GenerateTokenRequest generateTokenRequestParameters; // This is how you create embed token with effective identities if ((result.IsEffectiveIdentityRequired != null && result.IsEffectiveIdentityRequired == true) && (result.IsEffectiveIdentityRolesRequired != null && result.IsEffectiveIdentityRolesRequired == true) && !string.IsNullOrEmpty(username)) { var rls = new EffectiveIdentity(username, new List <string> { report.DatasetId }); if (!string.IsNullOrWhiteSpace(roles)) { var rolesList = new List <string>(); rolesList.AddRange(roles.Split(',')); rls.Roles = rolesList; } // Generate Embed Token with effective identities. generateTokenRequestParameters = new GenerateTokenRequest(accessLevel: "view", identities: new List <EffectiveIdentity> { rls }); } else { // Generate Embed Token for reports without effective identities. generateTokenRequestParameters = new GenerateTokenRequest(accessLevel: "view"); } var tokenResponse = await client.Reports.GenerateTokenInGroupAsync(groupId, report.Id, generateTokenRequestParameters); if (tokenResponse == null) { serviceEventSourceHelper.ServiceMessage(serviceContext, $"Embed Report - Error during user authentication for report - Result=[{tokenResponse.ToString()}]"); result.ErrorMessage = "Failed to authenticate user for report request"; return(result); } // Generate Embed Configuration. result.EmbedToken = tokenResponse; result.EmbedUrl = report.EmbedUrl; result.Id = report.Id; return(result); } } catch (HttpOperationException exc) { result.ErrorMessage = string.Format($"Status: {exc.Response.StatusCode} Response Content: [{exc.Response.Content}] RequestId: {exc.Response.Headers["RequestId"].FirstOrDefault()}"); } catch (Exception exc) { result.ErrorMessage = exc.ToString(); } return(result); }
public static async Task <bool> PublishReportDataFor(string reportUniqueId, string datasetName, List <DeviceMessage> deviceMessagelList, ServiceContext serviceContext, HttpClient httpClient, CancellationToken cancellationToken, IServiceEventSource serviceEventSource, int resampleSetsLimit = 0, int minMagnitudeAllowed = 1) { bool bRet = false; int maxSendingSet = 9999; ServiceEventSourceHelper serviceEventSourceHelper = new ServiceEventSourceHelper(serviceEventSource); DatasetConfiguration datasetConfiguration = DatasetRegistry.GetDatasetConfiguration(datasetName); int initialMessageCount = 0; serviceEventSourceHelper.ServiceMessage(serviceContext, $"PublishReportDataFor - About to publish data for Report id[{reportUniqueId}] Dataset Name[{datasetName}] Number of messages [{deviceMessagelList.Count}]"); ReportStreamDataset reportStreamDataset = new ReportStreamDataset(reportUniqueId, datasetConfiguration, deviceMessagelList); if (reportStreamDataset.Count > 0 && resampleSetsLimit > 0) { initialMessageCount = reportStreamDataset.Count; int maxNumberOfMessagesToSend = (resampleSetsLimit * maxSendingSet); ReportStreamDataset resampledReportStreamDataset = new ReportStreamDataset(reportUniqueId, datasetConfiguration); if (reportStreamDataset.Count > maxNumberOfMessagesToSend) { float selectInterval = reportStreamDataset.Count / maxNumberOfMessagesToSend; int selectedCount = 0; int index = 0; foreach (DeviceMessage message in reportStreamDataset.DeviceMessageList) { if (index >= (selectedCount * selectInterval)) { selectedCount++; resampledReportStreamDataset.AddMessage(message); } index++; if (selectedCount == maxNumberOfMessagesToSend) { break; } } reportStreamDataset = resampledReportStreamDataset; } } serviceEventSourceHelper.ServiceMessage(serviceContext, $"PublishReportDataFor - Report id[{reportUniqueId}] Final number of rows [{reportStreamDataset.Count}] generated from messages [{initialMessageCount}] requested for Dataset [{datasetName}]"); if (reportStreamDataset.Count > 0) { int messageCounter = 0; int messageSet = 1; bool firstSet = true; StringBuilder bodyContent = new StringBuilder(); bodyContent.Append("["); bool firstItem = true; foreach (DeviceMessage message in reportStreamDataset.DeviceMessageList) { if (firstItem) { firstItem = false; } else { bodyContent.Append(","); } bodyContent.Append(datasetConfiguration.GetMessageToPublish(message)); messageCounter++; if (messageCounter == maxSendingSet) { if (!firstSet) { await Task.Delay(global::Iot.Common.Names.IntervalBetweenReportStreamingCalls); } bodyContent.Append("]"); await RESTHandler.ExecuteHttpPOST(datasetConfiguration.PostUrl, bodyContent.ToString(), httpClient, cancellationToken, serviceEventSource); serviceEventSourceHelper.ServiceMessage(serviceContext, $"PublishReportDataFor - Sending set [{messageSet}] with number of rows [{messageCounter}] generated from messages [{reportStreamDataset.Count}] to dataset [{datasetName}]"); bodyContent.Clear(); bodyContent.Append("["); firstItem = true; messageCounter = 0; messageSet++; firstSet = false; } } if (reportStreamDataset.Count > 0) { if (!firstSet) { await Task.Delay(global::Iot.Common.Names.IntervalBetweenReportStreamingCalls); } bodyContent.Append("]"); await RESTHandler.ExecuteHttpPOST(datasetConfiguration.PostUrl, bodyContent, httpClient, cancellationToken, serviceEventSource); serviceEventSourceHelper.ServiceMessage(serviceContext, $"PublishReportDataFor - Sending set [{messageSet}] with number of rows [{messageCounter}] generated from messages [{reportStreamDataset.Count}] to dataset [{datasetName}]"); } bRet = true; } else { serviceEventSourceHelper.ServiceMessage(serviceContext, $"Embed Report - No data found to publish for Dataset [{datasetName}]"); } return(bRet); }
public MicroServiceProcessor(ServiceContext serviceContext, IServiceEventSource serviceEventSource = null) { _serviceEventSource = serviceEventSource; _serviceContext = serviceContext; }
public DinnerMenuService(StatefulServiceContext context, IDishStateManager dishStateManager, IReliableStateManagerReplica2 stateManager, IFileStore fileStore, IServiceEventSource serviceEventSource) : base(context, stateManager, fileStore, serviceEventSource) { _dishStateManager = dishStateManager; }
public static async Task <object> ExecuteFabricGETForEntity(Type targetObjectType, string targetServiceType, string servicePathAndQuery, string entityName, ServiceContext serviceContext, HttpClient httpClient, CancellationToken cancellationToken, IServiceEventSource serviceEventSource = null) { object objRet = null; ServiceEventSourceHelper serviceEventSourceHelper = new ServiceEventSourceHelper(serviceEventSource); ServiceUriBuilder uriBuilder = new ServiceUriBuilder(targetServiceType); Uri serviceUri = uriBuilder.Build(); long targetSiteServicePartitionKey = HashUtil.Hash(entityName); Uri getUrl = new HttpServiceUriBuilder() .SetServiceName(serviceUri) .SetPartitionKey(targetSiteServicePartitionKey) .SetServicePathAndQuery(servicePathAndQuery) .Build(); HttpResponseMessage response = await httpClient.GetAsync(getUrl, cancellationToken); if (response.StatusCode != System.Net.HttpStatusCode.OK) { serviceEventSourceHelper.ServiceMessage(serviceContext, $"On Execute Fabric GET - Service returned result[{response.StatusCode}] for entity[{entityName}] request[{servicePathAndQuery}]"); objRet = response; } else { JsonSerializer serializer = new JsonSerializer(); using (StreamReader streamReader = new StreamReader(await response.Content.ReadAsStreamAsync())) { using (JsonTextReader jsonReader = new JsonTextReader(streamReader)) { objRet = serializer.Deserialize(jsonReader, targetObjectType); } } } return(objRet); }
public static async Task <bool> ExecuteHttpPOST(String postUrl, object bodyObject, HttpClient httpClient, CancellationToken cancellationToken, IEnumerable <KeyValuePair <string, IEnumerable <string> > > additionalHeaders = null, IServiceEventSource serviceEventSource = null) { bool bRet = false; ServiceEventSourceHelper serviceEventSourceHelper = new ServiceEventSourceHelper(serviceEventSource); HttpContent postContent = null; if (bodyObject != null) { string jsonStr = ""; if (bodyObject is string) { jsonStr = (string)bodyObject; } else { jsonStr = JsonConvert.SerializeObject(bodyObject); } if (jsonStr.Length > 0) { MemoryStream mStrm = new MemoryStream(Encoding.UTF8.GetBytes(jsonStr)); postContent = new StreamContent(mStrm); } else { postContent = new StringContent(""); } postContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } else { postContent = new StringContent(""); postContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } if (additionalHeaders != null) { foreach (KeyValuePair <string, IEnumerable <string> > item in additionalHeaders) { if (item.Key.Equals("Authorization")) { string scheme = "Bearer"; string parameter = ""; int counter = 0; foreach (string value in item.Value) { if (counter == 0) { scheme = value; } if (counter == 1) { parameter = value; } counter++; } httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(scheme, parameter); } else { if (item.Value.Count() > 1) { httpClient.DefaultRequestHeaders.Add(item.Key, item.Value); } else { string value = item.Value.FirstOrDefault(); httpClient.DefaultRequestHeaders.Add(item.Key, value); } } } } HttpResponseMessage response = await httpClient.PostAsync(postUrl, postContent, cancellationToken); if (response.StatusCode == System.Net.HttpStatusCode.BadRequest) { // This service expects the receiving target site service to return HTTP 400 if the device message was malformed. // In this example, the message is simply logged. // Your application should handle all possible error status codes from the receiving service // and treat the message as a "poison" message. // Message processing should be allowed to continue after a poison message is detected. string responseContent = await response.Content.ReadAsStringAsync(); serviceEventSourceHelper.Message($"On Execute HTTP POST - Service Returned BAD REQUEST - Response Content[{responseContent}]"); } else { bRet = true; } return(bRet); }
public static DeviceMessage DeserializeEvents(string deviceId, string arrayEventStr, ServiceContext serviceContext, IServiceEventSource serviceEventSource) { DeviceMessage deviceMessageRet = null; try { JArray jarr = JArray.Parse(arrayEventStr); deviceMessageRet = DeserializeEvents(deviceId, jarr, serviceContext, serviceEventSource); } catch (Exception ex) { serviceEventSource.ServiceMessage(serviceContext, $"Event Registry - Could not parse device id[{deviceId}] message [{arrayEventStr}] Error Message [{ex.Message}]"); } return(deviceMessageRet); }
public static JArray SerializeEvents(string deviceId, DeviceMessage deviceMessage, ServiceContext serviceContext, IServiceEventSource serviceEventSource) { JArray jarrRet = new JArray(); foreach (DeviceEvent deviceEvent in deviceMessage.Events) { JObject jsonObj = SerializeEvent(deviceEvent); jarrRet.Add(jsonObj); } return(jarrRet); }
public static async Task <bool> ExecuteFabricPOSTForEntity(Type targetObjectType, string targetServiceType, string servicePathAndQuery, string entityName, object bodyObject, ServiceContext serviceContext, HttpClient httpClient, CancellationToken cancellationToken, IServiceEventSource serviceEventSource = null) { bool bRet = false; ServiceEventSourceHelper serviceEventSourceHelper = new ServiceEventSourceHelper(serviceEventSource); ServiceUriBuilder uriBuilder = new ServiceUriBuilder(targetServiceType); Uri serviceUri = uriBuilder.Build(); long targetSiteServicePartitionKey = HashUtil.Hash(entityName); Uri postUrl = new HttpServiceUriBuilder() .SetServiceName(serviceUri) .SetPartitionKey(targetSiteServicePartitionKey) .SetServicePathAndQuery(servicePathAndQuery) .Build(); string jsonStr = JsonConvert.SerializeObject(bodyObject); MemoryStream mStrm = new MemoryStream(Encoding.UTF8.GetBytes(jsonStr)); using (StreamContent postContent = new StreamContent(mStrm)) { postContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); HttpResponseMessage response = await httpClient.PostAsync(postUrl, postContent, cancellationToken); if (response.StatusCode == System.Net.HttpStatusCode.BadRequest) { // This service expects the receiving target site service to return HTTP 400 if the device message was malformed. // In this example, the message is simply logged. // Your application should handle all possible error status codes from the receiving service // and treat the message as a "poison" message. // Message processing should be allowed to continue after a poison message is detected. string responseContent = await response.Content.ReadAsStringAsync(); serviceEventSourceHelper.ServiceMessage(serviceContext, $"On Execute Fabric POST - Service returned BAD REQUEST for entity[{entityName}] request[{servicePathAndQuery}] result=[{responseContent} requestBody[{await postContent.ReadAsStringAsync()}]"); } else { bRet = true; } } return(bRet); }
public static DeviceMessage DeserializeEvents(string deviceId, JArray events, ServiceContext serviceContext, IServiceEventSource serviceEventSource) { DeviceMessage messageRet = null; bool firstEvent = true; foreach (JObject evt in events) { String eventType = GetEventTypeFromEvent(evt); if (eventType.Equals(Names.EVENT_TYPE_DEFAULT)) { serviceEventSource.ServiceMessage(serviceContext, $"Event Registry - Could not find event configuration for event type [{eventType}] - Will parse the event as Default Type"); } EventConfiguration eventConfiguration = EventRegistry.GetEventConfiguration(eventType); DeviceEvent deviceEvent = DeserializeEvent(eventConfiguration, evt); if (firstEvent) { messageRet = new DeviceMessage(eventConfiguration.MessageType, deviceId, deviceEvent); firstEvent = false; } else { messageRet.AddEvent(deviceEvent); } } return(messageRet); }
public static async Task <bool> ExecuteHttpPOST(String postUrl, object bodyObject, HttpClient httpClient, CancellationToken cancellationToken, IServiceEventSource serviceEventSource = null) { return(await ExecuteHttpPOST(postUrl, bodyObject, httpClient, cancellationToken, null, serviceEventSource)); }