public UserActionsController(ConsoleApplicationWrapper <MinecraftMessageParser> wrapper, UserRepository userRepository, UserManager <ApplicationUser> userManager, WhiteListService whiteListService, IOptions <ApplicationSettings> applicationSettings) { _wrapper = wrapper; _userRepository = userRepository; _userManager = userManager; _whiteListService = whiteListService; _applicationSettings = applicationSettings.Value; }
public WhiteListConfiguration GetWindowsAzureHostedServiceWhiteListConfiguration() { // The "StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList" property is // never null because it's a "Configuration Element Collection". So the best way to test if the White // List has been explicitly configured is if the "PollingIntervalInMinutes" is set (i.e. not "0"). if (StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList.PollingIntervalInMinutes > 0) { WhiteListConfiguration whiteListConfiguration = new WhiteListConfiguration(); whiteListConfiguration.IncludeDeploymentCreateServices = StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList.IncludeDeploymentCreateServices; whiteListConfiguration.IncludeDeploymentDeleteServices = StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList.IncludeDeploymentDeleteServices; whiteListConfiguration.IncludeHorizontalScaleServices = StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList.IncludeHorizontalScaleServices; whiteListConfiguration.PollingIntervalInMinutes = StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList.PollingIntervalInMinutes; foreach (ServiceConfigurationElement serviceConfigurationElement in StealFocusForecastConfiguration.Instance.WindowsAzure.HostedService.WhiteList) { WhiteListService whiteListService = new WhiteListService { Name = serviceConfigurationElement.Name }; foreach (RoleConfigurationElement roleConfigurationElement in serviceConfigurationElement.Roles) { WhiteListRole whiteListRole = new WhiteListRole { Name = roleConfigurationElement.Name }; if (!string.IsNullOrEmpty(roleConfigurationElement.MaxInstanceSize)) { InstanceSize instanceSize; bool parsed = System.Enum.TryParse(roleConfigurationElement.MaxInstanceSize, true, out instanceSize); if (!parsed) { string exceptionMessage = string.Format(CultureInfo.CurrentCulture, "The configured instance size of '{0}' could not be parsed as a valid Azure instance size. Valid values are '{1}', '{2}', '{3}', '{4}' or '{5}'.", roleConfigurationElement.MaxInstanceSize, InstanceSize.ExtraSmall, InstanceSize.Small, InstanceSize.Medium, InstanceSize.Large, InstanceSize.ExtraLarge); throw new ForecastException(exceptionMessage); } whiteListRole.MaxInstanceSize = instanceSize; } if (roleConfigurationElement.MaxInstanceCount > 0) { whiteListRole.MaxInstanceCount = roleConfigurationElement.MaxInstanceCount; } whiteListService.Roles.Add(whiteListRole); } whiteListConfiguration.Services.Add(whiteListService); } return(whiteListConfiguration); } return(null); }
public override void DoWork() { if (this.lastTimeWeDidWork.AddMinutes(this.pollingIntervalInMinutes) < DateTime.Now) { string doingWorkLogMessage = string.Format(CultureInfo.CurrentCulture, "{0} '{1}' is doing work.", this.GetType().Name, this.Id); Logger.Debug(doingWorkLogMessage); lock (SyncRoot) { foreach (ISubscription subscription in this.subscriptions) { string[] hostedServiceNames = new string[0]; try { hostedServiceNames = subscription.ListHostedServices(); } catch (Exception e) { string errorMessage = string.Format(CultureInfo.CurrentCulture, "{0} '{1}' experienced an error getting the hosted services for Subscription ID '{2}'. The operation will be retried after the next polling interval.", this.GetType().Name, this.Id, subscription.SubscriptionId); Logger.Error(errorMessage, e); } foreach (string hostedServiceName in hostedServiceNames) { bool allowed = this.allowedServices.Any(allowedService => allowedService.Name == hostedServiceName); if (allowed) { WhiteListService whiteListService = this.allowedServices.Single(allowedService => allowedService.Name == hostedServiceName); this.CheckDeploymentAgainstItsWhiteListEntry(subscription, hostedServiceName, whiteListService, DeploymentSlot.Staging); this.CheckDeploymentAgainstItsWhiteListEntry(subscription, hostedServiceName, whiteListService, DeploymentSlot.Production); } else { this.DeleteDeployedService(subscription, hostedServiceName, DeploymentSlot.Staging); this.DeleteDeployedService(subscription, hostedServiceName, DeploymentSlot.Production); } } } } this.lastTimeWeDidWork = DateTime.Now; } else { string notDoingWorkLogMessage = string.Format(CultureInfo.CurrentCulture, "{0} '{1}' is skipping doing work as we did work within the current polling window.", this.GetType().Name, this.Id); Logger.Debug(notDoingWorkLogMessage); } }
public void UnitTestDoWork_With_No_Explicit_Roles_Configured_For_White_List_Service() { MockRepository mockRepository = new MockRepository(); WhiteListService whiteListService = new WhiteListService { Name = "wls1" }; WhiteListService[] whiteListServices = new[] { whiteListService }; // Arrange ISubscription mockSubscription = mockRepository.StrictMock <ISubscription>(); mockSubscription .Expect(s => s.ListHostedServices()) .Repeat.Once() .Return(new[] { "wls1" }); mockSubscription .Expect(s => s.SubscriptionId) .Repeat.Any() .Return(SubscriptionId); mockSubscription .Expect(s => s.CertificateThumbprint) .Repeat.Any() .Return(CertificateThumbprint); ISubscription[] subscriptions = new[] { mockSubscription }; IDeployment mockDeployment = mockRepository.StrictMock <IDeployment>(); IOperation mockOperation = mockRepository.StrictMock <IOperation>(); // Act // There are no roles configured for the white list service, therefore there should be no checks made against // the service, we just accept however it is deployed for instance count or instance size. mockRepository.ReplayAll(); WhiteListForecastWorker whiteListForecastWorker = new WhiteListForecastWorker(subscriptions, mockDeployment, mockOperation, whiteListServices, 1); whiteListForecastWorker.DoWork(); whiteListForecastWorker.DoWork(); // Call twice to test the polling interval (nothing should be invoked the second time). // Assert mockRepository.VerifyAll(); }
private void OnPlayerConnectedHandler(Client client) { if (Settings.WhitelistEnabled) { if (!WhiteListService.IsClientWhitelisted(client.socialClubName)) { API.kickPlayer(client, "You are not whitelisted on this server"); return; } } Account account = AccountService.LoadAccount(client.socialClubName); if (account != null) { // User has an account if (account.Locked == 1) { API.kickPlayer(client, "Your Account is Locked!"); return; } client.setData("preaccount", account); } client.dimension = -10 - API.getAllPlayers().Count; }
private HorizontalScale[] FindHorizontalScaleChangesComparedToWhitelist(ISubscription subscription, string hostedServiceName, WhiteListService whiteListService, string deploymentSlot) { List <HorizontalScale> horizontalScales = new List <HorizontalScale>(); foreach (WhiteListRole whiteListRole in whiteListService.Roles) { if (whiteListRole.MaxInstanceCount.HasValue) { int instanceCount = this.deployment.GetInstanceCount(subscription.SubscriptionId, subscription.CertificateThumbprint, hostedServiceName, deploymentSlot, whiteListRole.Name); if (instanceCount > whiteListRole.MaxInstanceCount) { HorizontalScale horizontalScale = new HorizontalScale { InstanceCount = whiteListRole.MaxInstanceCount.Value, RoleName = whiteListRole.Name }; horizontalScales.Add(horizontalScale); } } } return(horizontalScales.ToArray()); }
private bool FindIfDeployedInstanceSizesExceedWhiteListConfiguration(ISubscription subscription, string hostedServiceName, WhiteListService whiteListService, string deploymentSlot) { if (whiteListService.Roles.Count == 0) { // No explicit roles configured, so just allow whatever is there. return(false); } foreach (WhiteListRole whiteListRole in whiteListService.Roles) { if (whiteListRole.MaxInstanceSize.HasValue) { string actualInstanceSizeValue = this.deployment.GetInstanceSize(subscription.SubscriptionId, subscription.CertificateThumbprint, hostedServiceName, deploymentSlot, whiteListRole.Name); InstanceSize actualInstanceSize = (InstanceSize)Enum.Parse(typeof(InstanceSize), actualInstanceSizeValue); if (actualInstanceSize > whiteListRole.MaxInstanceSize.Value) { return(true); } } } return(false); }
private void CheckDeploymentAgainstItsWhiteListEntry(ISubscription subscription, string hostedServiceName, WhiteListService whiteListService, string deploymentSlot) { bool deployedInstanceSizesExceedWhiteListConfiguration = this.FindIfDeployedInstanceSizesExceedWhiteListConfiguration(subscription, hostedServiceName, whiteListService, deploymentSlot); if (deployedInstanceSizesExceedWhiteListConfiguration) { this.DeleteDeployedService(subscription, hostedServiceName, deploymentSlot); return; } HorizontalScale[] horizontalScales = this.FindHorizontalScaleChangesComparedToWhitelist(subscription, hostedServiceName, whiteListService, deploymentSlot); if (horizontalScales.Length > 0) { this.HorizontallyScaleDeployedServiceRole(subscription, hostedServiceName, deploymentSlot, horizontalScales); } }
public void UnitTestDoWork_With_One_Role_Having_Instance_Count_Too_High_And_Second_Role_Having_Instance_Size_Too_Large() { MockRepository mockRepository = new MockRepository(); WhiteListService whiteListService = new WhiteListService { Name = "wls1" }; WhiteListRole whiteListRole = new WhiteListRole { Name = "wlr1", MaxInstanceSize = InstanceSize.ExtraSmall, MaxInstanceCount = 1 }; whiteListService.Roles.Add(whiteListRole); WhiteListService[] whiteListServices = new[] { whiteListService }; // Arrange ISubscription mockSubscription = mockRepository.StrictMock <ISubscription>(); mockSubscription .Expect(s => s.ListHostedServices()) .Repeat.Once() .Return(new[] { "bls1", "wls1" }); mockSubscription .Expect(s => s.SubscriptionId) .Repeat.Any() .Return(SubscriptionId); mockSubscription .Expect(s => s.CertificateThumbprint) .Repeat.Any() .Return(CertificateThumbprint); ISubscription[] subscriptions = new[] { mockSubscription }; IDeployment mockDeployment = mockRepository.StrictMock <IDeployment>(); IOperation mockOperation = mockRepository.StrictMock <IOperation>(); // Delete the black listed service from Staging and Production SetupDeleteRequestWithStatusCheck(mockDeployment, mockOperation, "bls1", DeploymentSlot.Staging, "deleteRequest1"); SetupDeleteRequestWithStatusCheck(mockDeployment, mockOperation, "bls1", DeploymentSlot.Production, "deleteRequest2"); // Get the instance size of White List Role 1 from Staging, all okay. mockDeployment .Expect(d => d.GetInstanceSize(SubscriptionId, CertificateThumbprint, "wls1", DeploymentSlot.Staging, "wlr1")) .Repeat.Once() .Return(InstanceSize.ExtraSmall.ToString()); // Get the instance count of White List Role 1 from Staging, horizontally scale as a result. mockDeployment .Expect(d => d.GetInstanceCount(SubscriptionId, CertificateThumbprint, "wls1", DeploymentSlot.Staging, "wlr1")) .Repeat.Once() .Return(2); SetupHorizontallyScaleWithStatusCheck(mockDeployment, mockOperation, "wls1", DeploymentSlot.Staging, new[] { new HorizontalScale { RoleName = "wlr1", InstanceCount = 1 } }, "scaleRequest1"); // Get the instance size of the White List Role 1 from Production, delete as a result. mockDeployment .Expect(d => d.GetInstanceSize(SubscriptionId, CertificateThumbprint, "wls1", DeploymentSlot.Production, "wlr1")) .Repeat.Once() .Return(InstanceSize.ExtraLarge.ToString()); SetupDeleteRequestWithStatusCheck(mockDeployment, mockOperation, "wls1", DeploymentSlot.Production, "deleteRequest3"); // Act mockRepository.ReplayAll(); WhiteListForecastWorker whiteListForecastWorker = new WhiteListForecastWorker(subscriptions, mockDeployment, mockOperation, whiteListServices, 1); whiteListForecastWorker.DoWork(); whiteListForecastWorker.DoWork(); // Call twice to test the polling interval (nothing should be invoked the second time). // Assert mockRepository.VerifyAll(); }
internal static WhiteListForecastWorker GetWhiteListForecastWorker() { IConfigurationSource configurationSource = GetConfigurationSource(); WhiteListConfiguration whiteListConfiguration = configurationSource.GetWindowsAzureHostedServiceWhiteListConfiguration(); if (whiteListConfiguration != null) { SubscriptionConfiguration[] subscriptionConfigurations = configurationSource.GetAllWindowsAzureSubscriptionConfigurations(); ISubscription[] subscriptions = new ISubscription[subscriptionConfigurations.Length]; for (int i = 0; i < subscriptionConfigurations.Length; i++) { subscriptions[i] = subscriptionConfigurations[i].Convert(); } if (whiteListConfiguration.IncludeDeploymentCreateServices) { foreach (DeploymentCreateConfiguration deploymentCreateConfiguration in configurationSource.GetWindowsAzureDeploymentCreateConfigurations()) { bool alreadyIncluded = false; foreach (WhiteListService configuredWhiteListService in whiteListConfiguration.Services) { if (configuredWhiteListService.Name == deploymentCreateConfiguration.ServiceName) { alreadyIncluded = true; } } if (!alreadyIncluded) { WhiteListService whiteListService = new WhiteListService { Name = deploymentCreateConfiguration.ServiceName }; whiteListConfiguration.Services.Add(whiteListService); } } } if (whiteListConfiguration.IncludeDeploymentDeleteServices) { foreach (DeploymentDeleteConfiguration deploymentDeleteConfiguration in configurationSource.GetWindowsAzureDeploymentDeleteConfigurations()) { bool alreadyIncluded = false; foreach (WhiteListService configuredWhiteListService in whiteListConfiguration.Services) { if (configuredWhiteListService.Name == deploymentDeleteConfiguration.ServiceName) { alreadyIncluded = true; } } if (!alreadyIncluded) { WhiteListService whiteListService = new WhiteListService { Name = deploymentDeleteConfiguration.ServiceName }; whiteListConfiguration.Services.Add(whiteListService); } } } if (whiteListConfiguration.IncludeHorizontalScaleServices) { foreach (ScheduledHorizontalScaleConfiguration windowsAzureScheduledHorizontalScaleConfiguration in configurationSource.GetWindowsAzureScheduledHorizontalScaleConfigurations()) { bool alreadyIncluded = false; foreach (WhiteListService configuredWhiteListService in whiteListConfiguration.Services) { if (configuredWhiteListService.Name == windowsAzureScheduledHorizontalScaleConfiguration.ServiceName) { alreadyIncluded = true; } } if (!alreadyIncluded) { WhiteListService whiteListService = new WhiteListService { Name = windowsAzureScheduledHorizontalScaleConfiguration.ServiceName }; whiteListConfiguration.Services.Add(whiteListService); } } } WhiteListForecastWorker whiteListForecastWorker = new WhiteListForecastWorker( subscriptions, new Deployment(), new Operation(), whiteListConfiguration.Services.ToArray(), whiteListConfiguration.PollingIntervalInMinutes); return(whiteListForecastWorker); } return(null); }