private IEventHub GetEventHub()
{
if(_eventHub == null)
{
_eventHub = Kernel.Resolve<IEventHub>();
}
return _eventHub;
}
public TimerWindowPresenter(IPomodoroEngine pomodoroEngine, ICountdownClock countdownClock, IEventHub eventHub)
{
this.countdownClock = countdownClock;
idleState = new IdleState(pomodoroEngine);
pomodoroState = new PomodoroState(pomodoroEngine);
shortBreakState = new ShortBreakState(pomodoroEngine);
longBreakState = new LongBreakState(pomodoroEngine);
pomodoroCompletedState = new PomodoroCompletedState(pomodoroEngine);
breakFinishedState = new BreakFinishedState(pomodoroEngine);
pomodoroInterruptedState = new TimerInterruptedState("Pomodoro Interrupted", pomodoroEngine);
breakInterruptedState = new TimerInterruptedState("Break Interrupted", pomodoroEngine);
currentState = idleState;
eventHub.Subscribe <TimerStarted>(OnTimerStarted);
eventHub.Subscribe <TimeElapsed>(OnTimeElapsed);
eventHub.Subscribe <TimerStopped>(OnTimerStopped);
}
///GENMHASH:F99F3258B7041A2910BA994BB518EAA3:2CC5F403817B58A1E7310EB6F1AF1764
public EventHubAuthorizationRuleImpl WithExistingEventHub(IEventHub eventHub)
{
this.ancestor = new TwoAncestor(SelfId(eventHub.Id));
return(this);
}
public RoomJoiner(IEventHub eventHub, IFetchRoom fetcher, IPersistRooms persister)
{
_eventHub = eventHub;
_persister = persister;
_fetcher = fetcher;
}
public EventContextLogger(IEventHub eventHub)
{
_eventHub = eventHub;
}
public static IEventHub WireSql(this IEventHub hub)
{
hub.WireEvents(typeof(EventHubExtensions).Assembly);
return(hub);
}
public ConsoleCommandExecutor(IEnumerable<ICommandLocator> handlers, IEventHub eventHub, ICommandOutputFormatter formatter)
{
_handlers = handlers;
_eventHub = eventHub;
_formatter = formatter;
}
public MapEventController(IEventHub hub, IRepository repo)
{
this.hub = hub;
this.repo = repo;
}
public void SetEventHub(IEventHub newEventHub)
{
this.objEventHub = newEventHub;
}
//public EventHubPublisherController(IEventHub eventHub)
//{
// _eventHub = eventHub;
//}
public EventHubPublisherController()
{
_eventHub = new EventHub();
}
public WhatsUpViewModel(IEventHub eventHub)
{
this._eventHub = eventHub;
this._eventHub.Subscribe <MessageAddedEvent>(this, MessageAddedHandler);
this._eventHub.Exists <MessageAddedEvent>(this);
}
public void TestNoSubUnsubUsingMethods()
{
IEventHub hub = EventHub;
Assert.IsFalse(hub.Unsubscribe <EventHubTests, Box <int> >(this));
}
private void SubInsideThisMethod(IEventHub hub)
{
hub.Subscribe <EventHubTests, IEventHub>(this, hub => { });
hub.Subscribe <EventHubTests, Box <int> >(this, IncrementBox);
}
private void UnsubInsideThisMethod(IEventHub hub)
{
hub.Unsubscribe <EventHubTests, IEventHub>(this);
hub.Unsubscribe <EventHubTests, Box <int> >(this);
}
public GameStarter(IEventHub eventHub, IFetchRoom roomFetcher, IPersistRooms persister)
{
_eventHub = eventHub;
_roomFetcher = roomFetcher;
_persister = persister;
}
public EventHubWriterReader(IEventHub eventHub)
{
_eventHub = eventHub;
}
public ExpensesController(IMediator mediator, IEventHub eventHub)
{
_mediator = mediator;
_eventHub = eventHub;
}
public CqrsControllerProvider(IDynamicTypePool dynamicPool, IWebApiGenerator webApiGenerator, IEventHub eventHub)
{
_dynamicPool = dynamicPool;
_webApiGenerator = webApiGenerator;
_eventHub = eventHub;
}
public GameHost(IEventHub eventHub, IPersistGame persister)
{
_eventHub = eventHub;
_persister = persister;
_games = new List <Game>();
}
public RoomCreator(IEventHub eventHub, IPersistRooms persister)
{
_eventHub = eventHub;
_persister = persister;
}
public NotificationsPresenter(IPomodoroEngine pomodoroEngine, IUserPreferences userPreferences, IEventHub eventHub)
{
this.pomodoroEngine = pomodoroEngine;
this.userPreferences = userPreferences;
eventHub.Subscribe <TimerStopped>(OnTimerStopped);
eventHub.Subscribe <AppUpdated>(OnAppUpdated);
eventHub.Subscribe <FirstRun>(OnFirstRun);
}
/// <summary>
/// Specifies the event hub for which consumer group needs to be created.
/// </summary>
/// <param name="eventHub">Event hub.</param>
/// <return>Next stage of the consumer group definition.</return>
EventHubConsumerGroup.Definition.IWithCreate EventHubConsumerGroup.Definition.IWithEventHub.WithExistingEventHub(IEventHub eventHub)
{
return(this.WithExistingEventHub(eventHub) as EventHubConsumerGroup.Definition.IWithCreate);
}
public SoundNotificationPlayer(IUserPreferences userPreferences, IEventHub eventHub)
{
this.userPreferences = userPreferences;
eventHub.Subscribe <TimerStopped>(OnTimerStopped);
}
public static void RunSample(IAzure azure)
{
Region region = Region.USEast;
string rgName = SdkContext.RandomResourceName("rgeh", 15);
string namespaceName1 = SdkContext.RandomResourceName("ns", 15);
string namespaceName2 = SdkContext.RandomResourceName("ns", 15);
string storageAccountName = SdkContext.RandomResourceName("stg", 14);
string eventHubName1 = SdkContext.RandomResourceName("eh", 14);
string eventHubName2 = SdkContext.RandomResourceName("eh", 14);
try
{
//============================================================
// Create an event hub namespace
//
Utilities.Log("Creating a namespace");
IEventHubNamespace namespace1 = azure.EventHubNamespaces
.Define(namespaceName1)
.WithRegion(Region.USEast2)
.WithNewResourceGroup(rgName)
.Create();
Utilities.Print(namespace1);
Utilities.Log("Created a namespace");
//============================================================
// Create an event hub in the namespace with data capture enabled, with consumer group and auth rule
//
ICreatable <IStorageAccount> storageAccountCreatable = azure.StorageAccounts
.Define(storageAccountName)
.WithRegion(Region.USEast2)
.WithExistingResourceGroup(rgName)
.WithSku(StorageAccountSkuType.Standard_LRS);
Utilities.Log("Creating an event hub with data capture enabled with a consumer group and rule in it");
IEventHub eventHub1 = azure.EventHubs
.Define(eventHubName1)
.WithExistingNamespace(namespace1)
// Optional - configure data capture
.WithNewStorageAccountForCapturedData(storageAccountCreatable, "datacpt")
.WithDataCaptureEnabled()
// Optional - create one consumer group in event hub
.WithNewConsumerGroup("cg1", "sometadata")
// Optional - create an authorization rule for event hub
.WithNewListenRule("listenrule1")
.Create();
Utilities.Log("Created an event hub with data capture enabled with a consumer group and rule in it");
Utilities.Print(eventHub1);
//============================================================
// Retrieve consumer groups in the event hub
//
Utilities.Log("Retrieving consumer groups");
var consumerGroups = eventHub1.ListConsumerGroups();
Utilities.Log("Retrieved consumer groups");
foreach (IEventHubConsumerGroup group in consumerGroups)
{
Utilities.Print(group);
}
//============================================================
// Create another event hub in the namespace using event hub accessor in namespace accessor
//
Utilities.Log("Creating another event hub in the namespace");
IEventHub eventHub2 = azure.EventHubNamespaces
.EventHubs
.Define(eventHubName2)
.WithExistingNamespace(namespace1)
.Create();
Utilities.Log("Created second event hub");
Utilities.Print(eventHub2);
//============================================================
// Create a consumer group in the event hub using consumer group accessor in event hub accessor
//
Utilities.Log("Creating a consumer group in the second event hub");
IEventHubConsumerGroup consumerGroup2 = azure.EventHubNamespaces
.EventHubs
.ConsumerGroups
.Define("cg2")
.WithExistingEventHub(eventHub2)
// Optional
.WithUserMetadata("sometadata")
.Create();
Utilities.Log("Created a consumer group in the second event hub");
Utilities.Print(consumerGroup2);
//============================================================
// Retrieve consumer groups in the event hub
//
Utilities.Log("Retrieving consumer groups in the second event hub");
consumerGroups = eventHub2.ListConsumerGroups();
Utilities.Log("Retrieved consumer groups in the seoond event hub");
foreach (IEventHubConsumerGroup group in consumerGroups)
{
Utilities.Print(group);
}
//============================================================
// Create an event hub namespace with event hub
//
Utilities.Log("Creating an event hub namespace along with event hub");
IEventHubNamespace namespace2 = azure.EventHubNamespaces
.Define(namespaceName2)
.WithRegion(Region.USEast2)
.WithExistingResourceGroup(rgName)
.WithNewEventHub(eventHubName2)
.Create();
Utilities.Log("Created an event hub namespace along with event hub");
Utilities.Print(namespace2);
foreach (IEventHub eh in namespace2.ListEventHubs())
{
Utilities.Print(eh);
}
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception ex)
{
Utilities.Log(ex);
}
}
}
public void CanManageAuthorizationRules()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USEast;
var groupName = TestUtilities.GenerateName("rgns");
var namespaceName = TestUtilities.GenerateName("ns111");
var eventHubName = TestUtilities.GenerateName("eh");
var azure = TestHelper.CreateRollupClient();
try
{
var namespaceCreatable = azure.EventHubNamespaces
.Define(namespaceName)
.WithRegion(region)
.WithNewResourceGroup(groupName);
IEventHub eventHub = azure.EventHubs
.Define(eventHubName)
.WithNewNamespace(namespaceCreatable)
.WithNewManageRule("mngRule1")
.WithNewSendRule("sndRule1")
.Create();
Assert.NotNull(eventHub);
Assert.NotNull(eventHub.Inner);
var rules = eventHub.ListAuthorizationRules();
HashSet <string> set = new HashSet <string>();
foreach (IEventHubAuthorizationRule rule in rules)
{
set.Add(rule.Name);
}
Assert.Contains("mngRule1", set);
Assert.Contains("sndRule1", set);
rules = azure.EventHubs
.AuthorizationRules
.ListByEventHub(eventHub.NamespaceResourceGroupName, eventHub.NamespaceName, eventHub.Name);
set.Clear();
foreach (IEventHubAuthorizationRule rule in rules)
{
set.Add(rule.Name);
}
Assert.Contains("mngRule1", set);
Assert.Contains("sndRule1", set);
azure.EventHubs
.AuthorizationRules
.Define("sndRule2")
.WithExistingEventHubId(eventHub.Id)
.WithSendAccess()
.Create();
rules = eventHub.ListAuthorizationRules();
set.Clear();
foreach (IEventHubAuthorizationRule rule in rules)
{
set.Add(rule.Name);
}
Assert.Contains("mngRule1", set);
Assert.Contains("sndRule1", set);
Assert.Contains("sndRule2", set);
}
finally
{
try
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
catch
{ }
}
}
}
public TalkAgent(ISettingAgent settingAgent, IEventHub eventHub)
{
_settingAgent = settingAgent;
_eventHub = eventHub;
}
public void CanConfigureDataCapturing()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USEast;
var groupName = TestUtilities.GenerateName("rgns");
var stgName = TestUtilities.GenerateName("stg");
var namespaceName = TestUtilities.GenerateName("ns111");
var eventHubName1 = TestUtilities.GenerateName("eh");
var eventHubName2 = TestUtilities.GenerateName("eh");
var azure = TestHelper.CreateRollupClient();
try
{
var storageAccountCreatable = azure.StorageAccounts
.Define(stgName)
.WithRegion(region)
.WithNewResourceGroup(groupName)
.WithSku(StorageAccountSkuType.Standard_LRS);
var namespaceCreatable = azure.EventHubNamespaces
.Define(namespaceName)
.WithRegion(region)
.WithNewResourceGroup(groupName);
var containerName1 = "eventsctr1";
IEventHub eventHub1 = azure.EventHubs
.Define(eventHubName1)
.WithNewNamespace(namespaceCreatable)
.WithNewStorageAccountForCapturedData(storageAccountCreatable, containerName1)
.WithDataCaptureEnabled()
// Window config is optional if not set service will choose default for it2
//
.WithDataCaptureWindowSizeInSeconds(120)
.WithDataCaptureWindowSizeInMB(300)
.Create();
Assert.NotNull(eventHub1);
Assert.NotNull(eventHub1.Inner);
Assert.NotNull(eventHub1.Name);
Assert.Equal(eventHub1.Name, eventHubName1, ignoreCase: true);
Assert.NotNull(eventHub1.PartitionIds);
Assert.True(eventHub1.IsDataCaptureEnabled);
Assert.NotNull(eventHub1.CaptureDestination);
Assert.Contains("/storageAccounts/", eventHub1.CaptureDestination.StorageAccountResourceId);
Assert.Contains(stgName, eventHub1.CaptureDestination.StorageAccountResourceId);
Assert.Equal(eventHub1.CaptureDestination.BlobContainer, containerName1, ignoreCase: true);
// Create another event Hub in the same namespace with data capture uses the same storage account
//
var stgAccountId = eventHub1.CaptureDestination.StorageAccountResourceId;
var containerName2 = "eventsctr2";
IEventHub eventHub2 = azure.EventHubs
.Define(eventHubName2)
.WithNewNamespace(namespaceCreatable)
.WithExistingStorageAccountForCapturedData(stgAccountId, containerName2)
.WithDataCaptureEnabled()
.Create();
Assert.True(eventHub2.IsDataCaptureEnabled);
Assert.NotNull(eventHub2.CaptureDestination);
Assert.Contains("/storageAccounts/", eventHub2.CaptureDestination.StorageAccountResourceId);
Assert.Contains(stgName, eventHub2.CaptureDestination.StorageAccountResourceId);
Assert.Equal(eventHub2.CaptureDestination.BlobContainer, containerName2, ignoreCase: true);
eventHub2.Update()
.WithDataCaptureDisabled()
.Apply();
Assert.False(eventHub2.IsDataCaptureEnabled);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(groupName);
}
catch
{ }
}
}
}
public EventDispatcher(IEventHub eventHub, IValidator <Event> validator)
{
_eventHub = eventHub;
_validator = validator;
}
public void CanEnableDataCaptureOnUpdate()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USEast;
var groupName = TestUtilities.GenerateName("rgns");
var azure = TestHelper.CreateRollupClient();
try
{
var stgName = TestUtilities.GenerateName("stg");
var namespaceName = TestUtilities.GenerateName("ns111");
var eventHubName = TestUtilities.GenerateName("eh");
var namespaceCreatable = azure.EventHubNamespaces
.Define(namespaceName)
.WithRegion(region)
.WithNewResourceGroup(groupName);
IEventHub eventHub = azure.EventHubs
.Define(eventHubName)
.WithNewNamespace(namespaceCreatable)
.Create();
bool exceptionThrown = false;
try
{
eventHub.Update()
.WithDataCaptureEnabled()
.Apply();
}
catch
{
exceptionThrown = true;
}
Assert.True(exceptionThrown, "Expected IllegalStateException is not thrown");
eventHub = eventHub.Refresh();
var storageAccountCreatable = azure.StorageAccounts
.Define(stgName)
.WithRegion(region)
.WithNewResourceGroup(groupName)
.WithSku(StorageAccountSkuType.Standard_LRS);
eventHub.Update()
.WithDataCaptureEnabled()
.WithNewStorageAccountForCapturedData(storageAccountCreatable, "eventctr")
.Apply();
Assert.True(eventHub.IsDataCaptureEnabled);
Assert.NotNull(eventHub.CaptureDestination);
Assert.Contains("/storageAccounts/", eventHub.CaptureDestination.StorageAccountResourceId);
Assert.Contains(stgName, eventHub.CaptureDestination.StorageAccountResourceId);
Assert.Equal("eventctr", eventHub.CaptureDestination.BlobContainer, ignoreCase: true);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(groupName);
}
catch
{ }
}
}
}
public DynamicAssembly(IEventHub eventHub)
{
_eventHub = eventHub;
_sourceUnits = new SourceUnitCollection();
_references = new List <Assembly>();
}
public void CanManageConusmerGroups()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var region = Region.USEast;
var groupName = TestUtilities.GenerateName("rgns");
var namespaceName = TestUtilities.GenerateName("ns111");
var eventHubName = TestUtilities.GenerateName("eh");
var azure = TestHelper.CreateRollupClient();
try
{
var namespaceCreatable = azure.EventHubNamespaces
.Define(namespaceName)
.WithRegion(region)
.WithNewResourceGroup(groupName);
IEventHub eventHub = azure.EventHubs
.Define(eventHubName)
.WithNewNamespace(namespaceCreatable)
.WithNewConsumerGroup("grp1")
.WithNewConsumerGroup("grp2", "metadata111")
.Create();
Assert.NotNull(eventHub);
Assert.NotNull(eventHub.Inner);
var cGroups = eventHub.ListConsumerGroups();
HashSet <string> set = new HashSet <string>();
foreach (IEventHubConsumerGroup grp in cGroups)
{
set.Add(grp.Name);
}
Assert.Contains("grp1", set);
Assert.Contains("grp2", set);
cGroups = azure.EventHubs
.ConsumerGroups
.ListByEventHub(eventHub.NamespaceResourceGroupName,
eventHub.NamespaceName, eventHub.Name);
set.Clear();
foreach (IEventHubConsumerGroup rule in cGroups)
{
set.Add(rule.Name);
}
Assert.Contains("grp1", set);
Assert.Contains("grp2", set);
azure.EventHubs
.ConsumerGroups
.Define("grp3")
.WithExistingEventHubId(eventHub.Id)
.WithUserMetadata("metadata222")
.Create();
cGroups = eventHub.ListConsumerGroups();
set.Clear();
foreach (IEventHubConsumerGroup grp in cGroups)
{
set.Add(grp.Name);
}
Assert.Contains("grp1", set);
Assert.Contains("grp2", set);
Assert.Contains("grp3", set);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(groupName);
}
catch
{ }
}
}
}
public GitBusiness(IEventHub eventHub)
{
_eventHub = eventHub;
}
public CommandExecutor(IEnumerable<ICommandLocator> handlers, IEventHub eventHub)
{
_handlers = handlers;
_eventHub = eventHub;
}
