// Event Stream
// ------------------------------------------------------------
public static async Task EventStreamDemo(ITopicFactory factory)
{
var topic3 = factory.OpenTopic <Person>("event-stream-demo");
await topic3.AppendAsync(new Person()
{
FullName = "Mad Dog"
});
var consumer3 = await topic3.CreateConsumerAsync("consumer3");
Console.WriteLine($"Starting consumer at {consumer3.CurrentOffset}");
var stream = consumer3.ToStreamEventObserable();
// Partionable stream using message group meta data???
//var input = stream.ToPartitionedStreamable(p => p.Payload.FullName, e=>e.EndTime);
var input = stream.ToStreamable();
var output = input.Max(p => p.Age);
var task = stream.StartObserving();
Console.WriteLine("Output =");
output.ToStreamEventObservable().ForEachAsync(e => Console.WriteLine(e)).Wait();
}
public ExecutionService(IRouteRepository routeRepository, IRequestRepository requestRepository, ITopicFactory topicFactory, IResponsePipeline responsePipeline, ITraceContext traceContext)
{
_routeRepository = routeRepository;
_requestRepository = requestRepository;
_topicFactory = topicFactory;
_responsePipeline = responsePipeline;
_traceContext = traceContext;
}
public TopicDispatcher(ITopicFactory <T> topicFactory)
{
if (topicFactory == null)
{
throw new ArgumentNullException(nameof(topicFactory));
}
_client = topicFactory.Create();
}
public BusConfigurationBuilder(IQueueFactory queueFactory, ITopicFactory topicFactory, ISubscriptionFactory subscriptionFactory)
{
_queueFactory = queueFactory;
_topicFactory = topicFactory;
_subscriptionFactory = subscriptionFactory;
_queuesRequiringCreation = new List <IQueueInstance>();
_eventsRequiringCreation = new List <Type>();
_eventSubscriptions = new List <EventSubscription>();
}
public Connection(ConnectionState state, ITopicFactory topicFactory)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
if (topicFactory == null)
{
throw new ArgumentNullException(nameof(topicFactory));
}
_state = state;
_topicFactory = topicFactory;
}
public static async Task <Topics> ForAsync(ITopicFactory topicFactory, ICollection <Type> eventTypes)
{
var handlerTasks = eventTypes
.Select(topicFactory.From)
.ToList();
await Task.WhenAll(handlerTasks);
var taskResults = handlerTasks
.Select(task => task.Result)
.ToList();
return(new Topics(taskResults));
}
/// <summary>Constructor</summary>
/// <param name="agentId">The string name that uniquely identifies this agent in SIF Zones.
/// This string is used as the <c>SourceId</c> in all SIF message
/// headers created by the agent.
/// </param>
public Agent(string agentId)
{
if (agentId == null || agentId.Trim().Length == 0)
{
AdkUtils._throw
(new ArgumentException("Agent ID cannot be null or a blank string"), Log);
}
fSourceId = agentId;
ObjectFactory factory = ObjectFactory.GetInstance();
fZoneFactory = (IZoneFactory)factory.CreateInstance(ObjectFactory.ADKFactoryType.ZONE, this);
fTopicFactory = (ITopicFactory)factory.CreateInstance(ObjectFactory.ADKFactoryType.TOPIC, this);
fTransportManager = new TransportManagerImpl();
}
public ResponsePipeline(ITopicFactory topicFactory)
{
// Since we're in a constructor, we can't use the await keyword, so we'll wait the old fashioned synchonous way.
// The clientTask.Wait() is a blocking call. This call doesn't actually create the subscription, we do that on
// pre-application initialization, since it's faster to do it once for the whole app up-front, instead of lazily
// somwhere buried in a constructor, plus doing it lazily causes a dead-lock.
var requestSubscriptionName = string.Format(Settings.ServiceBusResponseSubscriptionNameFormat, Environment.MachineName);
var clientTask = topicFactory.CreateSubscriptionClientAsync(Settings.ServiceBusResponseTopicName, requestSubscriptionName);
clientTask.Wait();
// Do a quick check to ensure that the task didn't throw an exception and wasn't cancelled.
if (clientTask.IsFaulted || clientTask.IsCanceled)
{
throw new ServiceBusException($"Failed to create and subscribe to the response topic for subscription '{requestSubscriptionName}'.", clientTask.Exception);
}
// Store the result in a local field as we don't want it to be garbage collected.
_responseSubscription = clientTask.Result;
// We only get one shot at processing the message, because the SubscriptionClient is set to ReceiveAndDelete.
// This means that we don't have to call Complete() or Abandon() on messages, and also means we only need
// one call to service bus to handle a message. We are publishing the message into an observable sequence
// which will ensure only one thread handles the message at a time (even if there are multiple subscribers
// to the observable sequence), but we'll set the MaxConcurrentCalls to something greater than 1, because the
// observable sequence will hold the messages in memory while they are waiting to be processed. The
// combination of these qualities means we can essentially prefetch messages while we are processing a
// message. This does create multiple threads for each message, but the observable sequence will synchronize
// them all back to the same thread. It's a small price to pay for prefetching ability.
var options = new OnMessageOptions
{
AutoComplete = true,
MaxConcurrentCalls = 5 // Drain 5 at a time into memory, so we can do a bit of prefetching.
};
// Using the OnMessage delegate will handle the internal polling (or sockets, depending on mode) for us.
// When we receive a message, we'll push it through the observable sequence. The OnNext() call will block
// until all subscriptions have received the message, but we don't have any heavy processing happening, so
// it's not a big deal and we are using ReceiveAndDelete anyways, so it doesn't matter how long the OnNext()
// call takes.
_responseSubscription.OnMessage(bm =>
{
_responseMessages.OnNext(bm);
}, options);
}
public Server(ITopicFactory topicFactory, ITopicsConfigurationStorage topicsConfigurationStorage)
{
this.topicFactory = topicFactory;
this.topicsConfigurationStorage = topicsConfigurationStorage;
topics = new Dictionary <string, ITopicManagement>();
}
/// <summary>
/// 實例化
/// </summary>
/// <param name="topicFactory"></param>
public TopicHelper(ITopicFactory topicFactory)
{
Guard.ArgumentNotNull(topicFactory, "topicFactory");
TopicFactory = topicFactory;
}
public TestEventHandler(IEventRepository eventRepository, ITopicFactory topicFactory)
: base(eventRepository, topicFactory)
{
}
protected PublishingEventHandler(IEventRepository repository, ITopicFactory topicFactory)
{
_repository = repository;
_topicFactory = topicFactory;
}
/// <summary>Constructor</summary>
/// <param name="agentId">The string name that uniquely identifies this agent in SIF Zones.
/// This string is used as the <c>SourceId</c> in all SIF message
/// headers created by the agent.
/// </param>
public Agent( string agentId )
{
if ( agentId == null || agentId.Trim().Length == 0 )
{
AdkUtils._throw
( new ArgumentException( "Agent ID cannot be null or a blank string" ), Log );
}
fSourceId = agentId;
ObjectFactory factory = ObjectFactory.GetInstance();
fZoneFactory = (IZoneFactory) factory.CreateInstance( ObjectFactory.ADKFactoryType.ZONE, this );
fTopicFactory = (ITopicFactory) factory.CreateInstance( ObjectFactory.ADKFactoryType.TOPIC, this );
fTransportManager = new TransportManagerImpl();
}
