public static void Main(string[] args)
{
try
{
// Sets window size and cursor color
Console.SetWindowSize(130, 30);
Console.ForegroundColor = ConsoleColor.White;
// Reads configuration settings
ReadConfiguration();
// Sets actor service URIs
workerActorServiceUri = ActorNameFormat.GetFabricServiceUri(typeof(IWorkerActor), ApplicationName);
queueActorServiceUri = ActorNameFormat.GetFabricServiceUri(typeof(IQueueActor), ApplicationName);
processorActorServiceUri = ActorNameFormat.GetFabricServiceUri(typeof(IProcessorActor), ApplicationName);
int i;
while ((i = SelectOption()) != TestList.Count + 1)
{
try
{
PrintTestParameters(TestList[i - 1].Name);
TestList[i - 1].Action();
}
catch (Exception ex)
{
PrintException(ex);
}
}
}
catch (Exception ex)
{
PrintException(ex);
}
}
void IStateProviderReplica.Initialize(StatefulServiceInitializationParameters initializationParameters)
{
this.initiParams = initializationParameters;
this.traceId = ActorTrace.GetTraceIdForReplica(this.initiParams.PartitionId, this.initiParams.ReplicaId);
var statefulServiceContext = new StatefulServiceContext(
FabricRuntime.GetNodeContext(),
this.initiParams.CodePackageActivationContext,
this.initiParams.ServiceTypeName,
this.initiParams.ServiceName,
this.initiParams.InitializationData,
this.initiParams.PartitionId,
this.initiParams.ReplicaId);
var stateManagerConfig = this.userDefinedStateManagerConfig;
if (stateManagerConfig == null)
{
var actorImplType = this.actorTypeInformation.ImplementationType;
stateManagerConfig = new ReliableStateManagerConfiguration(
ActorNameFormat.GetConfigPackageName(actorImplType),
ActorNameFormat.GetFabricServiceReplicatorSecurityConfigSectionName(actorImplType),
ActorNameFormat.GetFabricServiceReplicatorConfigSectionName(actorImplType));
}
this.stateManager = new ReliableStateManager(statefulServiceContext, stateManagerConfig);
ReleaseAssert.AssertIfNull(this.onDataLossAsyncFunc, "onDataLossAsync event handler cannot be null.");
this.stateManager.OnDataLossAsync = this.onDataLossAsyncFunc;
this.stateManager.Initialize(this.initiParams);
}
internal static IActorStateProvider GetActorStateProviderOverride()
{
IActorStateProvider stateProvider = null;
try
{
var configurationPackageName = ActorNameFormat.GetConfigPackageName();
var stateProviderOverrideSectionName = ActorNameFormat.GetActorStateProviderOverrideSectionName();
var attributeTypeKey = ActorNameFormat.GetActorStateProviderOverrideKeyName();
// Load the ActorStateProviderAttribute Type from the Configuration settings
var context = FabricRuntime.GetActivationContext();
var config = context.GetConfigurationPackageObject(configurationPackageName);
if ((config.Settings.Sections != null) &&
(config.Settings.Sections.Contains(stateProviderOverrideSectionName)))
{
var section = config.Settings.Sections[stateProviderOverrideSectionName];
var stateProviderType = section.Parameters[attributeTypeKey].Value;
stateProvider = Activator.CreateInstance(Type.GetType(stateProviderType)) as IActorStateProvider;
}
}
catch (Exception)
{
// ignore
}
return(stateProvider);
}
/// <summary>
/// This is used by Kvs and Volatile actor state provider.
/// </summary>
/// <param name="codePackage"></param>
/// <param name="actorImplType"></param>
/// <returns></returns>
internal static ReplicatorSettings GetActorReplicatorSettings(CodePackageActivationContext codePackage, Type actorImplType)
{
var settings = ReplicatorSettings.LoadFrom(
codePackage,
ActorNameFormat.GetConfigPackageName(actorImplType),
ActorNameFormat.GetFabricServiceReplicatorConfigSectionName(actorImplType));
settings.SecurityCredentials = SecurityCredentials.LoadFrom(
codePackage,
ActorNameFormat.GetConfigPackageName(actorImplType),
ActorNameFormat.GetFabricServiceReplicatorSecurityConfigSectionName(actorImplType));
var nodeContext = FabricRuntime.GetNodeContext();
var endpoint = codePackage.GetEndpoint(ActorNameFormat.GetFabricServiceReplicatorEndpointName(actorImplType));
settings.ReplicatorAddress = string.Format(
CultureInfo.InvariantCulture,
"{0}:{1}",
nodeContext.IPAddressOrFQDN,
endpoint.Port);
if (!settings.MaxPrimaryReplicationQueueSize.HasValue)
{
settings.MaxPrimaryReplicationQueueSize = DefaultMaxPrimaryReplicationQueueSize;
}
if (!settings.MaxSecondaryReplicationQueueSize.HasValue)
{
settings.MaxSecondaryReplicationQueueSize = DefaultMaxSecondaryReplicationQueueSize;
}
return(settings);
}
internal static FabricTransportRemotingListenerSettings GetActorListenerSettings(ActorService actorService)
{
FabricTransportRemotingListenerSettings listenerSettings;
if (!FabricTransportRemotingListenerSettings.TryLoadFrom(ActorNameFormat.GetFabricServiceTransportSettingsSectionName(actorService.ActorTypeInformation.ImplementationType), out listenerSettings, (string)null))
{
listenerSettings = GetDefaultFabricTransportListenerSettings("TransportSettings");
}
return(listenerSettings);
}
/// <summary>
/// Constructs a WCF based actor remoting listener.
/// </summary>
/// <param name="listenerBinding">WCF binding to use for the listener. If the listener binding is not specified or null,
/// a default listener binding is created using <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.WcfUtility.CreateTcpListenerBinding"/> method which creates
/// a <see cref="System.ServiceModel.NetTcpBinding"/> with no security.
/// </param>
/// <param name="actorService">The actor service.</param>
public WcfActorServiceRemotingListener(
ActorService actorService,
Binding listenerBinding = null)
: base(
GetContext(actorService),
new ActorServiceRemotingDispatcher(actorService),
listenerBinding,
ActorNameFormat.GetFabricServiceEndpointName(actorService.ActorTypeInformation.ImplementationType))
{
}
public WebFront(StatelessServiceContext context)
: base(context)
{
this.LoadLiveCounterSettings();
this.counter = new LivenessCounter <string>(expirationIntervalInSeconds, fuzzIntervalInSeconds);
nodeName = context.NodeContext.NodeName;
serviceUri = ActorNameFormat.GetFabricServiceUri(typeof(IContainerAggregatorActor));
proxy = ActorServiceProxy.Create <IContainerAggregator>(serviceUri, 0);
reportTimer = new Timer(this.Report, null, TimeSpan.FromSeconds(reportIntervalInSeconds), TimeSpan.FromSeconds(reportIntervalInSeconds));
}
public void GetFabricService_PassServiceName_ReturnServiceName()
{
// Arrange
string serviceName = "serviceName";
// Act
var result = ActorNameFormat.GetFabricServiceName(typeof(object), serviceName);
// Assert
result.Should().Be(serviceName);
}
public void GetFabricService_NoServiceNameProvided_ReturnServiceName()
{
// Arrange
string serviceName = "ObjectActorService";
// Act
var result = ActorNameFormat.GetFabricServiceName(typeof(object));
// Assert
result.Should().Be(serviceName);
}
/// <summary>
/// Creates a proxy to the actor object that implements an actor interface.
/// </summary>
/// <typeparam name="TActorInterface">
/// The actor interface implemented by the remote actor object.
/// The returned proxy object will implement this interface.
/// </typeparam>
/// <param name="actorId">Actor Id of the proxy actor object. Methods called on this proxy will result in requests
/// being sent to the actor with this id.</param>
/// <param name="applicationName">
/// Name of the Service Fabric application that contains the actor service hosting the actor objects.
/// This parameter can be null if the client is running as part of that same Service Fabric application. For more information, see Remarks.
/// </param>
/// <param name="serviceName">
/// Name of the Service Fabric service as configured by <see cref="Microsoft.ServiceFabric.Actors.Runtime.ActorServiceAttribute"/> on the actor implementation.
/// By default, the name of the service is derived from the name of the actor interface. However <see cref="Microsoft.ServiceFabric.Actors.Runtime.ActorServiceAttribute"/>
/// is required when an actor implements more than one actor interfaces or an actor interface derives from another actor interface as the determination of the
/// serviceName cannot be made automatically.
/// </param>
/// <param name="listenerName">
/// By default an actor service has only one listener for clients to connect to and communicate with.
/// However it is possible to configure an actor service with more than one listeners, the listenerName parameter specifies the name of the listener to connect to.
/// </param>
/// <returns>An actor proxy object that implements <see cref="IActorProxy"/> and TActorInterface.</returns>
public TActorInterface CreateActorProxy <TActorInterface>(ActorId actorId, string applicationName = null,
string serviceName = null, string listenerName = null) where TActorInterface : IActor
{
if (string.IsNullOrEmpty(applicationName))
{
applicationName = ActorNameFormat.GetCurrentFabricApplicationName();
}
var actorInterfaceType = typeof(TActorInterface);
var serviceUri = ActorNameFormat.GetFabricServiceUri(actorInterfaceType, applicationName, serviceName);
return(this.CreateActorProxy <TActorInterface>(serviceUri, actorId, listenerName));
}
/// <summary>
/// Constructs a WCF based actor remoting listener.
/// </summary>
/// <param name="listenerBinding">WCF binding to use for the listener. If the listener binding is not specified or null,
/// a default listener binding is created using <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.WcfUtility.CreateTcpListenerBinding"/> method which creates
/// a <see cref="System.ServiceModel.NetTcpBinding"/> with no security.
/// </param>
/// <param name="actorService">The actor service.</param>
public WcfActorServiceRemotingListener(
ActorService actorService,
Binding listenerBinding = null)
: base(
GetContext(actorService),
new ActorServiceRemotingDispatcher(actorService, new DataContractRemotingMessageFactory()),
new ActorRemotingSerializationManager(new BasicDataContractSerializationProvider(),
new BasicDataContractActorHeaderSerializer()),
listenerBinding,
ActorNameFormat.GetFabricServiceEndpointName(actorService.ActorTypeInformation.ImplementationType))
{
}
internal static FabricTransportRemotingListenerSettings GetActorListenerSettings(ActorService actorService)
{
var sectionName = ActorNameFormat.GetFabricServiceTransportSettingsSectionName(
actorService.ActorTypeInformation.ImplementationType);
FabricTransportRemotingListenerSettings listenerSettings;
var isSucceded = FabricTransportRemotingListenerSettings.TryLoadFrom(sectionName, out listenerSettings);
if (!isSucceded)
{
listenerSettings = FabricTransportRemotingListenerSettings.GetDefault();
}
return(listenerSettings);
}
public Task Subscribe(TSubscription subscription)
{
return(WithLock(async() =>
{
var topicId = subscription.GetTopicId();
if (!_proxies.ContainsKey(topicId))
{
var uri = ActorNameFormat.GetFabricServiceUri(typeof(ITopicActor));
var actor = _actorProxyFactory.CreateActorProxy <ITopicActor>(uri, new ActorId(topicId));
await actor.SubscribeAsync(this);
_proxies.Add(topicId, actor);
}
}));
}
public async Task Publish(TMessage message, TSubscription subscription)
{
var uri = ActorNameFormat.GetFabricServiceUri(typeof(ITopicActor));
var topicId = subscription.GetTopicId();
var actor = _actorProxyFactory.CreateActorProxy <ITopicActor>(uri, new ActorId(topicId));
var serialisedMessage = JsonConvert.SerializeObject(message);
var serialisedSubscription = JsonConvert.SerializeObject(subscription);
await actor.PublishMessage(new TopicActorMessage
{
Subscription = serialisedSubscription,
Message = serialisedMessage
});
}
private static FabricTransportRemotingListenerSettings SetEndPointResourceName(
FabricTransportRemotingListenerSettings listenerSettings, ActorService actorService)
{
if (listenerSettings == null)
{
listenerSettings = GetActorListenerSettings(actorService);
}
if (listenerSettings.EndpointResourceName.Equals(FabricTransportRemotingListenerSettings.DefaultEndpointResourceName))
{
listenerSettings.EndpointResourceName = ActorNameFormat.GetFabricServiceEndpointName(
actorService.ActorTypeInformation.ImplementationType);
}
return(listenerSettings);
}
/// <summary>
/// Registers an actor service with Service Fabric runtime. This allows the runtime to create instances of the replicas for the actor service.
/// </summary>
/// <typeparam name="TActor">Type implementing actor.</typeparam>
/// <param name="actorServiceFactory">Delegate that create new actor service.</param>
/// <param name="timeout">A timeout period after which the registration operation will be canceled.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A task that represents the asynchronous operation to register actor service with Service Fabric runtime.</returns>
public static async Task RegisterActorAsync <TActor>(
Func <StatefulServiceContext, ActorTypeInformation, ActorService> actorServiceFactory,
TimeSpan timeout = default(TimeSpan),
CancellationToken cancellationToken = default(CancellationToken))
where TActor : ActorBase
{
actorServiceFactory.ThrowIfNull("actorServiceFactory");
var actorType = typeof(TActor);
var actorServiceType = actorServiceFactory.GetMethodInfo().ReturnType;
var actorTypeInformation = ActorTypeInformation.Get(actorType);
var serviceTypeName = ActorNameFormat.GetFabricServiceTypeName(actorTypeInformation.ImplementationType);
try
{
var customActorServiceFactory = new ActorServiceFactory(
actorTypeInformation,
new ActorMethodFriendlyNameBuilder(actorTypeInformation),
actorServiceFactory,
new ActorMethodDispatcherMap(actorTypeInformation));
await ServiceRuntime.RegisterServiceAsync(
serviceTypeName,
context => customActorServiceFactory.CreateActorService(context),
timeout,
cancellationToken);
ActorFrameworkEventSource.Writer.ActorTypeRegistered(
actorType.ToString(),
actorServiceType.ToString(),
NodeName);
}
catch (Exception e)
{
ActorFrameworkEventSource.Writer.ActorTypeRegistrationFailed(
e.ToString(),
actorType.ToString(),
actorServiceType.ToString(),
NodeName);
throw;
}
}
