public void RegisterInfrastructureServiceFactory(IStatefulServiceFactory factory) { var activationContext = FabricRuntime.GetActivationContext(); var broker = new ServiceFactoryBroker(factory, activationContext); Utility.WrapNativeSyncInvokeInMTA(() => this.nativeAgent.RegisterInfrastructureServiceFactory(broker), "InfrastructureServiceAgent.RegisterInfrastructureServiceFactory"); }
private NativeRuntime.IFabricServiceGroupFactory CreateServiceGroupFactoryHelper(ServiceGroupFactory factory) { NativeRuntime.IFabricServiceGroupFactoryBuilder nativeBuilder = this.NativeRuntimeObject.CreateServiceGroupFactoryBuilder(); foreach (var namedFactory in factory.StatefulServiceFactories) { ServiceFactoryBroker broker = new ServiceFactoryBroker(namedFactory.Item2, this.codePackageActivationContext); using (var pin = new PinBlittable(namedFactory.Item1)) { nativeBuilder.AddStatefulServiceFactory(pin.AddrOfPinnedObject(), broker as NativeRuntime.IFabricStatefulServiceFactory); } } foreach (var namedFactory in factory.StatelessServiceFactories) { ServiceFactoryBroker broker = new ServiceFactoryBroker(namedFactory.Item2, this.codePackageActivationContext); using (var pin = new PinBlittable(namedFactory.Item1)) { nativeBuilder.AddStatelessServiceFactory(pin.AddrOfPinnedObject(), broker as NativeRuntime.IFabricStatelessServiceFactory); } } NativeRuntime.IFabricServiceGroupFactory serviceGroupFactory = nativeBuilder.ToServiceGroupFactory(); return(serviceGroupFactory); }
/// <summary> /// <para>Registers the specified <see cref="System.Fabric.IStatefulServiceFactory" /> for the specified service type with the specified /// <paramref name="timeout" /> and <paramref name="cancellationToken" />.</para> /// </summary> /// <param name="serviceTypeName"> /// <para>The type name of the service type (as a string). This should match the type of the service group type as specified in the manifests /// and/or the CreateService command.</para> /// </param> /// <param name="factory"> /// <para>The <see cref="System.Fabric.IStatefulServiceFactory" /> which can create the specified service type.</para> /// </param> /// <param name="timeout"> /// <para>The maximum amount of time Service Fabric will allow this operation to continue before returning a TimeoutException.</para> /// </param> /// <param name="cancellationToken"> /// <para>The <see cref="System.Threading.CancellationToken" /> that the operation is observing. It can be used to send a notification that /// the operation should be canceled. Note that cancellation is advisory and that the operation may still be completed even if it is canceled.</para> /// </param> /// <returns> /// <para>The representing the asynchronous operation.</para> /// </returns> public Task RegisterStatefulServiceFactoryAsync(string serviceTypeName, IStatefulServiceFactory factory, TimeSpan timeout, CancellationToken cancellationToken) { this.ThrowIfDisposed(); FabricRuntime.ValidateParametersForRegisterServiceFactory(serviceTypeName, factory); ServiceFactoryBroker broker = new ServiceFactoryBroker(factory, this.codePackageActivationContext); return(this.RegisterServiceFactoryAsyncHelper(true, serviceTypeName, broker, (uint)timeout.TotalMilliseconds, cancellationToken)); }
/// <summary> /// <para>Asynchronously associates the specified serviceTypeName with the actual managed Type that implements it, with the specified <paramref name="timeout" /> /// and <paramref name="cancellationToken" /></para> /// </summary> /// <param name="serviceTypeName"> /// <para>The type name of the service type (as a string). This should match the type of the service group type as specified in the manifests /// and/or the CreateService command.</para> /// </param> /// <param name="serviceTypeImplementation"> /// <para>The qualified service Type that implements the specified <paramref name="serviceTypeName" />.</para> /// </param> /// <param name="timeout"> /// <para>The maximum amount of time Service Fabric will allow this operation to continue before returning a TimeoutException.</para> /// </param> /// <param name="cancellationToken"> /// <para>The <see cref="System.Threading.CancellationToken" /> that the operation is observing. It can be used to send a notification that the /// operation should be canceled. Note that cancellation is advisory and that the operation may still be completed even if it is canceled.</para> /// </param> /// <returns> /// <para>The task representing the asynchronous operation.</para> /// </returns> public Task RegisterServiceTypeAsync(string serviceTypeName, Type serviceTypeImplementation, TimeSpan timeout, CancellationToken cancellationToken) { this.ThrowIfDisposed(); bool isStateful = FabricRuntime.ValidateParametersForRegisterServiceType(serviceTypeName, serviceTypeImplementation); ServiceFactoryBroker factory = new ServiceFactoryBroker(new DefaultServiceFactory(serviceTypeImplementation), this.codePackageActivationContext); return(this.RegisterServiceFactoryAsyncHelper(isStateful, serviceTypeName, factory, (uint)timeout.TotalMilliseconds, cancellationToken)); }
private TReturnValue CreateHelper <TFactory, TReturnValue>( IntPtr nativeServiceType, IntPtr nativeServiceName, uint initializationDataLength, IntPtr nativeInitializationData, Guid partitionId, Func <TFactory, ServiceInitializationParameters, TReturnValue> creationFunc, Action <TReturnValue, ServiceInitializationParameters> initializationFunc, ServiceInitializationParameters initializationParameters) where TReturnValue : class where TFactory : class { ServiceFactoryBroker.ValidatePublicApiArguments(nativeServiceType, nativeServiceName); string managedServiceType = NativeTypes.FromNativeString(nativeServiceType); string managedServiceName = NativeTypes.FromNativeString(nativeServiceName); byte[] initializationData = ServiceFactoryBroker.ParseInitializationData(initializationDataLength, nativeInitializationData); Uri serviceNameUri = null; if (managedServiceName.StartsWith("fabric:", StringComparison.Ordinal)) { serviceNameUri = new Uri(managedServiceName); AppTrace.TraceSource.WriteNoise( "ServiceFactoryBroker.CreateInstance", "Creating Instance for {0} Uri {1} partitionId {2}", managedServiceType, serviceNameUri.OriginalString, partitionId); } else { AppTrace.TraceSource.WriteNoise( "ServiceFactoryBroker.CreateInstance", "Creating Instance for {0} System Service {1} partitionId {2}", managedServiceType, managedServiceName, partitionId); } TFactory factory = this.serviceFactory as TFactory; if (factory == null) { AppTrace.TraceSource.WriteError("ServiceFactoryBroker.CreateInstanceHelper", "ServiceFactory type is incorrect for creation call {0}", this.serviceFactory.GetType().FullName); throw new InvalidOperationException(StringResources.Error_ServiceFactoryBroker_Invalid_ServiceFactoryType); } initializationParameters.InitializationData = initializationData; initializationParameters.ServiceTypeName = managedServiceType; initializationParameters.ServiceName = serviceNameUri; initializationParameters.PartitionId = partitionId; TReturnValue instance; try { instance = creationFunc(factory, initializationParameters); } catch (Exception e) { AppTrace.TraceSource.WriteExceptionAsWarning("ServiceFactoryBroker.CreateInstanceHelper", e, "the passed in servicefactory threw exception"); CreateReplicaOrInstanceApi.HandleException(e); throw; } if (instance == null) { AppTrace.TraceSource.WriteError("ServiceFactoryBroker.CreateInstance", "ServiceFactory returned null {0}", this.serviceFactory.GetType().FullName); throw new InvalidOperationException(StringResources.Error_ServiceFactoryBroker_Null_Return); } try { initializationFunc(instance, initializationParameters); } catch (Exception e) { AppTrace.TraceSource.WriteExceptionAsWarning("ServiceFactoryBroker.CreateInstanceHelper", e, "the service threw an exception in Initialize"); CreateReplicaOrInstanceApi.HandleException(e); throw; } return(instance as TReturnValue); }
private void InternalRegisterServiceFactory(bool isStateful, string serviceType, ServiceFactoryBroker serviceFactoryBroker) { //// Calls native code, requires UnmanagedCode permission using (var pin = new PinBlittable(serviceType)) { if (!isStateful) { this.NativeRuntimeObject.RegisterStatelessServiceFactory(pin.AddrOfPinnedObject(), serviceFactoryBroker); } else { this.NativeRuntimeObject.RegisterStatefulServiceFactory(pin.AddrOfPinnedObject(), serviceFactoryBroker); } } }
private void RegisterServiceFactoryHelper(bool isStateful, string serviceTypeName, object factory) { ServiceFactoryBroker broker = new ServiceFactoryBroker(factory, this.codePackageActivationContext); this.InternalRegisterServiceFactory(isStateful, serviceTypeName, broker); }
private void RegisterServiceTypeHelper(bool isStateful, string serviceTypeName, Type serviceTypeImplementation) { ServiceFactoryBroker factory = new ServiceFactoryBroker(new DefaultServiceFactory(serviceTypeImplementation), this.codePackageActivationContext); this.InternalRegisterServiceFactory(isStateful, serviceTypeName, factory); }