public AzureSubscriptionCleaner(IAuthenticated authenticated, string subscriptionId, string exceptedRGsRegex, ILogger logger, IConfigurationRoot config) { this.Authenticated = authenticated; this.SubscriptionId = subscriptionId; this.ExceptedRGsRegex = exceptedRGsRegex; this.Logger = logger; this.Config = config; this.DefaultExpiry = 2; this.DefaultExtension = 4; this.UsageLookback = 1; if (Config["DefaultExpiry"] != null) { this.DefaultExpiry = Int32.Parse(Config["DefaultExpiry"]); } if (Config["DefaultExtension"] != null) { this.DefaultExtension = Int32.Parse(Config["DefaultExtension"]); } if (Config["UsageLookback"] != null) { this.UsageLookback = Int32.Parse(Config["UsageLookback"]); } }
ITwitchChatClientBuilder ITwitchChatClientBuilder.WithOAuthToken(string oAuthToken) { _authenticated = new AuthenticationBuilder() .FromOAuthToken(oAuthToken) .Build(); return(this); }
public void Deploy( IAuthenticated azure, DeploymentOptions options, IEnumerable <AzureResource> resources) { foreach (AzureResource resource in resources) { Task.Factory.StartNew(async() => { try { Started?.Invoke(this, new DeploymentEventArgs(resource)); await CreateResourceAsync(azure, options, resource.Type); Finished?.Invoke(this, new DeploymentEventArgs(resource)); } catch (Exception ex) { Debug.WriteLine($"Error creating resource of type {resource.Type}: {ex}"); Failed?.Invoke(this, new DeploymentErrorEventArgs(resource, ex)); } }); } }
private Azure(RestClient restClient, string subscriptionId, string tenantId, IAuthenticated authenticated) { resourceManager = ResourceManager.Fluent.ResourceManager.Authenticate(restClient).WithSubscription(subscriptionId); storageManager = StorageManager.Authenticate(restClient, subscriptionId); computeManager = ComputeManager.Authenticate(restClient, subscriptionId); networkManager = NetworkManager.Authenticate(restClient, subscriptionId); batchManager = BatchManager.Authenticate(restClient, subscriptionId); keyVaultManager = KeyVaultManager.Authenticate(restClient, subscriptionId, tenantId); trafficManager = TrafficManager.Fluent.TrafficManager.Authenticate(restClient, subscriptionId); dnsZoneManager = DnsZoneManager.Authenticate(restClient, subscriptionId); sqlManager = SqlManager.Authenticate(restClient, subscriptionId); redisManager = RedisManager.Authenticate(restClient, subscriptionId); cdnManager = CdnManager.Authenticate(restClient, subscriptionId); appServiceManager = AppServiceManager.Authenticate(restClient, subscriptionId, tenantId); searchManager = SearchManager.Authenticate(restClient, subscriptionId); serviceBusManager = ServiceBusManager.Authenticate(restClient, subscriptionId); containerInstanceManager = ContainerInstanceManager.Authenticate(restClient, subscriptionId); registryManager = RegistryManager.Authenticate(restClient, subscriptionId); containerServiceManager = ContainerServiceManager.Authenticate(restClient, subscriptionId); cosmosDBManager = CosmosDBManager.Authenticate(restClient, subscriptionId); authorizationManager = AuthorizationManager.Authenticate(restClient, subscriptionId); msiManager = MsiManager.Authenticate(restClient, subscriptionId); batchAIManager = BatchAIManager.Authenticate(restClient, subscriptionId); monitorManager = MonitorManager.Authenticate(restClient, subscriptionId); eventHubManager = EventHubManager.Authenticate(restClient, subscriptionId); SubscriptionId = subscriptionId; this.authenticated = authenticated; }
public static TwitchAPIClient Create(IAuthenticated authenticated) { var loggerFactory = new LoggerFactory(); var httpClient = new HttpClient(); return(new TwitchAPIClient(authenticated, httpClient, loggerFactory.CreateLogger <TwitchAPIClient>())); }
public BaseDeployment(IAuthenticated azure, DeploymentOptions options) { Azure = azure; Options = options; analyticsService = DependencyService.Resolve <AnalyticsService>(); watch = new Stopwatch(); }
public IGDBClient(IAuthenticated authenticated, IHttpClientFactory httpClientFactory, IMemoryCache memoryCache, TwitchAPIClient twitchAPIClient, ILogger <IGDBClient> logger) { _httpClient = httpClientFactory.CreateClient(); _httpClient.BaseAddress = new Uri("https://api.igdb.com/"); _authenticated = authenticated; _cache = memoryCache; _logger = logger; }
public StorageAccountDeployment( string accountName, IAuthenticated azure, DeploymentOptions options) : base(azure, options) { AccountName = accountName; }
public SqlAzureDeployment( string serverName, IAuthenticated azure, DeploymentOptions options) : base(azure, options) { ServerName = serverName; }
public CosmosDbAccountDeployment( string docDbName, IAuthenticated azure, DeploymentOptions options) : base(azure, options) { DocDbName = docDbName; }
public KeyVaultDeployment( string vaultName, IAuthenticated azure, DeploymentOptions options) : base(azure, options) { VaultName = vaultName; }
public WebAppDeployment( string appName, IAuthenticated azure, DeploymentOptions options) : base(azure, options) { AppName = appName; }
public AzureSubscription(IAuthenticated authenticated, ISubscription subscription) : base(subscription.DisplayName, "azure/subscription") { _azure = authenticated.WithSubscription(subscription.SubscriptionId); CommandGroups.Add(new HierarchicalResourceCommandGroup( new HierarchicalResourceCommand("refresh", Symbol.Refresh, RefreshAsync))); RefreshAsync().Forget(); }
internal TwitchChatClient(IAuthenticated authenticated, Uri endpoint, ILogger <TwitchChatClient> logger) { _authenticated = authenticated; _endpoint = endpoint; _logger = logger; _webSocket = new ClientWebSocket(); _inBuffer = new byte[8703]; // IRCv3 8191B Tags + 512B message _outBuffer = new byte[1024]; }
async Task HandleTransportAsync(IAsyncTransport transport, IHandler handler, object context) { IPrincipal principal = null; if (this.saslSettings != null) { ListenerSaslProfile profile = new ListenerSaslProfile(this); transport = await profile.NegotiateAsync(transport).ConfigureAwait(false); principal = profile.GetPrincipal(); } var connection = new ListenerConnection(this, this.address, handler, transport); if (principal == null) { // SASL principal preferred. If not present, check transport. IAuthenticated authenticated = transport as IAuthenticated; if (authenticated != null) { principal = authenticated.Principal; } } connection.Principal = principal; bool shouldClose = false; lock (this.connections) { if (!this.closed) { connection.Closed += this.OnConnectionClosed; this.connections.Add(connection); } else { shouldClose = true; } } if (shouldClose) { await connection.CloseAsync().ConfigureAwait(false); } else { if (handler != null && handler.CanHandle(EventId.ConnectionAccept)) { handler.Handle(Event.Create(EventId.ConnectionAccept, connection, context: context)); } AsyncPump pump = new AsyncPump(this.BufferManager, transport); pump.Start(connection); } }
public async Task <IReadOnlyCollection <KeyValuePair <string, ISubscription> > > ListAllSubscriptionsAsync() { IAuthenticated globalClient = GetAuthenticated(); IPagedCollection <ITenant> tenants = await globalClient.Tenants.ListAsync().ConfigureAwait(false); var all = new List <KeyValuePair <string, ISubscription> >(); await Task.WhenAll(tenants.Select(t => ListSubscriptionsAsync(t.TenantId, all))).ConfigureAwait(false); return(all.AsReadOnly()); }
public static async Task ListSubscriptionAsync(this IAuthenticated azure) { Console.WriteLine("List Subscriptions... "); var subs = await azure.Subscriptions.ListAsync(); foreach (var sub in subs) { Console.WriteLine(sub.SubscriptionId); } }
private async Task ListSubscriptionsAsync(string tenantId, IList <KeyValuePair <string, ISubscription> > subscriptions) { IAuthenticated tenantClient = GetAuthenticated(tenantId); IPagedCollection <ISubscription> subs = await tenantClient.Subscriptions.ListAsync().ConfigureAwait(false); foreach (ISubscription sub in subs) { subscriptions.Add(new KeyValuePair <string, ISubscription>(tenantId, sub)); } }
public IPrincipal GetPrincipal() { IAuthenticated authenticated = this.innerProfile as IAuthenticated; if (authenticated != null) { return(authenticated.Principal); } return(null); }
public static List <KeyVaultProperties> runProgram(string[] args, bool testing) { AccessPoliciesToYaml ap = new AccessPoliciesToYaml(testing); UpdatePoliciesFromYaml up = new UpdatePoliciesFromYaml(testing); Console.ForegroundColor = ConsoleColor.DarkGreen; Console.WriteLine("Refer to 'Log.log' for more details should an error be thrown.\n"); Console.ResetColor(); Console.WriteLine("Reading input files..."); up.verifyFileExtensions(args); JsonInput vaultList = ap.readJsonFile(args[0]); Console.WriteLine("Finished!"); Console.WriteLine("Grabbing secrets..."); Dictionary <string, string> secrets = ap.getSecrets(); Console.WriteLine("Finished!"); Console.WriteLine("Creating KeyVaultManagementClient, GraphServiceClient, and AzureClient..."); KeyVaultManagementClient kvmClient = ap.createKVMClient(secrets); GraphServiceClient graphClient = ap.createGraphClient(secrets); IAuthenticated azureClient = ap.createAzureClient(secrets); Console.WriteLine("Finished!");; Console.WriteLine("Checking access and retrieving key vaults..."); ap.checkAccess(vaultList, azureClient); List <KeyVaultProperties> vaultsRetrieved = ap.getVaults(vaultList, kvmClient, graphClient); Console.WriteLine("Finished!"); Console.WriteLine("Reading yaml file..."); List <KeyVaultProperties> yamlVaults = up.deserializeYaml(args[1]); Console.WriteLine("Finished!"); Console.WriteLine("Updating key vaults..."); List <KeyVaultProperties> deletedPolicies = up.updateVaults(yamlVaults, vaultsRetrieved, kvmClient, secrets, graphClient); Console.WriteLine("Finished!"); Console.WriteLine("Generating DeletedPolicies yaml..."); up.convertToYaml(deletedPolicies, args[2]); Console.WriteLine("Finished!"); if (testing) { return(up.Changed); } return(null); }
async Task HandleTransportAsync(IAsyncTransport transport) { IPrincipal principal = null; if (this.saslSettings != null) { ListenerSaslProfile profile = new ListenerSaslProfile(this); transport = await profile.NegotiateAsync(transport); principal = profile.GetPrincipal(); } IHandler handler = this.HandlerFactory?.Invoke(this); var connection = new ListenerConnection(this, this.address, handler, transport); if (principal == null) { // SASL principal preferred. If not present, check transport. IAuthenticated authenticated = transport as IAuthenticated; if (authenticated != null) { principal = authenticated.Principal; } } connection.Principal = principal; bool shouldClose = false; lock (this.connections) { if (!this.closed) { connection.Closed += this.OnConnectionClosed; this.connections.Add(connection); } else { shouldClose = true; } } if (shouldClose) { await connection.CloseAsync(); } else { AsyncPump pump = new AsyncPump(this.BufferManager, transport); pump.Start(connection); } }
private void AuthenticateClient() { // clint credentials flow with secret var clientId = _configuration.GetValue <string>("AzureManagementFluent:ClientId"); var clientSecret = _configuration.GetValue <string>("AzureManagementFluent:ClientSecret"); var tenantId = _configuration.GetValue <string>("AzureManagementFluent:TenantId"); AzureCredentialsFactory azureCredentialsFactory = new AzureCredentialsFactory(); var credentials = azureCredentialsFactory .FromServicePrincipal(clientId, clientSecret, tenantId, AzureEnvironment.AzureGlobalCloud); // authenticate to Azure AD _authenticatedClient = Microsoft.Azure.Management.Fluent.Azure.Configure() .Authenticate(credentials); }
private Task CreateResourceAsync( IAuthenticated azure, DeploymentOptions options, AzureResourceType resourceType) { string resourceName = GetRandomResourceName(resourceType); BaseDeployment deployment = null; switch (resourceType) { case AzureResourceType.AppService: case AzureResourceType.WebApp: deployment = new WebAppDeployment(resourceName, azure, options); break; case AzureResourceType.Storage: deployment = new StorageAccountDeployment(resourceName, azure, options); break; case AzureResourceType.CosmosDB: deployment = new CosmosDbAccountDeployment(resourceName, azure, options); break; case AzureResourceType.Functions: deployment = new AzureFunctionDeployment(resourceName, azure, options); break; case AzureResourceType.SqlDatabase: deployment = new SqlAzureDeployment(resourceName, azure, options); break; case AzureResourceType.KeyVault: deployment = new KeyVaultDeployment(resourceName, azure, options); break; default: Debug.WriteLine($"Service of type {resourceType} not supported!"); break; } return(deployment != null ? deployment.CreateAsync() : Task.CompletedTask); }
public IAuthenticated GetAuthenticated(string tenantId = "common") { if (!_tenantIdToAuthenticated.TryGetValue(tenantId, out IAuthenticated auth)) { var armCredentials = new CleverServiceClientCredentials( "https://management.azure.com/", _clientId, tenantId, _tokenCache); armCredentials.UserTokenInteraction = UserTokenInteraction; if (!_userInfoReceiverSet) { armCredentials.UserInfoReceiver = this; _userInfoReceiverSet = true; } var azureCreds = new AzureCredentials(armCredentials, null, tenantId, AzureEnvironment.AzureGlobalCloud); IAuthenticated authenticated = Azure.Authenticate(azureCreds); _tenantIdToAuthenticated[tenantId] = authenticated; return(authenticated); } return(auth); }
/// <summary> /// This method reads in a Json config file and converts it into a serialized list of KeyVaults that are displayed in a Yaml file. /// </summary> public static void Main(string[] args) { AccessPoliciesToYaml ap = new AccessPoliciesToYaml(false); Console.ForegroundColor = ConsoleColor.DarkGreen; Console.WriteLine("Refer to 'Log.log' for more details should an error be thrown.\n"); Console.ResetColor(); Console.WriteLine("Reading input file..."); ap.verifyFileExtensions(args); JsonInput vaultList = ap.readJsonFile(args[0]); Console.WriteLine("Finished!"); Console.WriteLine("Grabbing secrets..."); Dictionary <string, string> secrets = ap.getSecrets(); Console.WriteLine("Finished!"); Console.WriteLine("Creating KeyVaultManagementClient, GraphServiceClient, and AzureClient..."); KeyVaultManagementClient kvmClient = ap.createKVMClient(secrets); GraphServiceClient graphClient = ap.createGraphClient(secrets); IAuthenticated azureClient = ap.createAzureClient(secrets); Console.WriteLine("Finished!");; Console.WriteLine("Checking access and retrieving key vaults..."); ap.checkAccess(vaultList, azureClient); List <KeyVaultProperties> vaultsRetrieved = ap.getVaults(vaultList, kvmClient, graphClient); Console.WriteLine("Finished!"); Console.WriteLine("Generating YAML output..."); ap.convertToYaml(vaultsRetrieved, args[1]); Console.WriteLine("Finished!"); }
public ActionResult Login(LoginAccountViewModel account) { IAuthenticated authenticated = null; if (ModelState.IsValid) { RestClient client = RemoteConfig.Client; RestRequest request = RemoteConfig.AUTHENTICATE.Request; request.AddParameter("email", account.Email); request.AddParameter("password", account.Password); IRestResponse response = client.Execute(request); try { JObject jObject = JObject.Parse(response.Content); if (response.StatusCode == System.Net.HttpStatusCode.OK) { String token = (String)jObject["token"]; request = RemoteConfig.USER.Request; request.AddHeader("Authorization", $"JWT {token}"); response = client.Execute(request); try { jObject = JObject.Parse(response.Content); if (response.StatusCode == System.Net.HttpStatusCode.OK) { JToken jToken = jObject["user"]; authenticated = new AuthUser(new User { Id = (String)jToken["_id"], FirstName = (String)jToken["firstName"], LastName = (String)jToken["lastName"], Email = (String)jToken["email"], // TODO createdAt, convert string to date }, token); } } catch { Debug.WriteLine("exception"); } } else { ModelState.AddModelError("password", (String)jObject["message"]); } } catch { ModelState.AddModelError("password", "Unable issue the server for authentication"); } } if (authenticated != null) { Session[Reference.KEY_USER_SESSION] = authenticated as IAuthenticated; return(RedirectToAction("Index", "Default")); } return(View()); }
public AccountController(IAuthenticated authenticated) : base(authenticated) { }
public DeletionOrchestrator(IAuthenticated auth, ILoggerFactory loggerFactory, IOptions <DeletionOptions> options) : base(auth, loggerFactory) { _options = options.Value; }
public BaseController(IAuthenticated authenticated) { Authenticated = authenticated; }
ITwitchChatClientBuilder ITwitchChatClientBuilder.WithAuthenticatedUser(IAuthenticated authenticated) { _authenticated = authenticated; return(this); }