public async Task <string> GetStateAsync() { var group = await containerGroup .ConfigureAwait(false); return(group.State); }
public async Task <TAuthorizationToken> GetAsync <TAuthorizationToken>(DeploymentScope deploymentScope) where TAuthorizationToken : AuthorizationToken, new() { if (deploymentScope is null) { throw new ArgumentNullException(nameof(deploymentScope)); } var client = await tableClient.ConfigureAwait(false); var rowKey = AuthorizationEntity.GetEntityId(deploymentScope); var partitionKey = string.Join(",", typeof(TAuthorizationToken).AssemblyQualifiedName.Split(',').Take(2)); try { var response = await client .GetEntityAsync <TAuthorizationToken>(partitionKey, rowKey) .ConfigureAwait(false); return(response.Value); } catch (RequestFailedException ex) when(ex.Status == 404) { // doesn't exist return(null); } }
public async Task <IEnumerable <string> > GetKeysAsync() { var storage = await storageInstance .ConfigureAwait(false); var storageKeys = await storage .GetKeysAsync() .ConfigureAwait(false); return(storageKeys .Select(k => k.Value)); }
public async Task <string> AcquireTokenAsync(User user, TimeSpan?ttl = null) { var client = await tableClient.ConfigureAwait(false); var entity = new OneTimeTokenServiceEntity(Guid.Parse(user.Organization), Guid.Parse(user.Id), ttl); _ = await client .UpsertEntityAsync(entity) .ConfigureAwait(false); return(entity.Token); }
/// <inheritdoc /> public async Task<Installation> GetInstallationAsync(long installationId) { var gitHubUserClient = await _lazyGitHubUserClient.ConfigureAwait(false); var gitHubAppsUserClient = gitHubUserClient.GitHubApps; var gitHubAppsInstallationsUserClient = gitHubAppsUserClient.Installations; var installation = await gitHubAppsUserClient.GetInstallation(installationId).ConfigureAwait(false); var repositoriesResponse = await gitHubAppsInstallationsUserClient .GetAllRepositoriesForUser(installation.Id).ConfigureAwait(false); var repositoriesResponseRepositories = repositoriesResponse.Repositories; var userInstallation = BuildInstallation(installation, repositoriesResponseRepositories); return userInstallation; }
public override async IAsyncEnumerable <IAzureIdentity> GetIdentitiesAsync() { _ = await identityInstance .ConfigureAwait(false); yield return(this); }
/// <inheritdoc /> public async Task <Repository> GetRepositoryAsync(long repositoryId) { var gitHubUserClient = await _lazyGitHubUserClient.ConfigureAwait(false); var repositoriesClient = gitHubUserClient.Repository; var repository = await repositoriesClient.Get(repositoryId).ConfigureAwait(false); return(BuildRepository(repository)); }
public async Task SetAllSecretPermissionsAsync(Guid userObjectId) { try { var vault = await vaultInstance .ConfigureAwait(false); await vault.Update() .DefineAccessPolicy() .ForObjectId(userObjectId.ToString()) .AllowSecretAllPermissions() .Attach() .ApplyAsync() .ConfigureAwait(false); } finally { vaultInstance.Reset(); } }
/// <summary> /// Starts the network services. /// </summary> /// <returns> /// A task that represents the asynchronous operation. /// </returns> /// <remarks> /// Starts the various IPFS and PeerTalk network services. This should /// be called after any configuration changes. /// </remarks> /// <exception cref="Exception"> /// When the engine is already started. /// </exception> public async Task StartAsync() { if (stopTasks.Count > 0) { throw new Exception("IPFS engine is already started."); } var localPeer = await LocalPeer.ConfigureAwait(false); log.Debug("starting " + localPeer.Id); // Everybody needs the swarm. var swarm = await SwarmService.ConfigureAwait(false); stopTasks.Add(async() => { await swarm.StopAsync().ConfigureAwait(false); }); await swarm.StartAsync().ConfigureAwait(false); // Start the primary services. var tasks = new List <Func <Task> > { async() => { var bitswap = await BitswapService.ConfigureAwait(false); stopTasks.Add(async() => await bitswap.StopAsync().ConfigureAwait(false)); await bitswap.StartAsync().ConfigureAwait(false); }, async() => { var dht = await DhtService.ConfigureAwait(false); stopTasks.Add(async() => await dht.StopAsync().ConfigureAwait(false)); await dht.StartAsync().ConfigureAwait(false); }, async() => { var pubsub = await PubSubService.ConfigureAwait(false); stopTasks.Add(async() => await pubsub.StopAsync().ConfigureAwait(false)); await pubsub.StartAsync().ConfigureAwait(false); }, }; log.Debug("waiting for services to start"); await Task.WhenAll(tasks.Select(t => t())).ConfigureAwait(false); // Starting listening to the swarm. var json = await Config.GetAsync("Addresses.Swarm").ConfigureAwait(false); var numberListeners = 0; foreach (string a in json) { try { await swarm.StartListeningAsync(a).ConfigureAwait(false); ++numberListeners; } catch (Exception e) { log.Warn($"Listener failure for '{a}'", e); // eat the exception } } if (numberListeners == 0) { log.Error("No listeners were created."); } // Now that the listener addresses are established, the discovery // services can begin. MulticastService multicast = null; if (!Options.Discovery.DisableMdns) { multicast = new MulticastService(); #pragma warning disable CS1998 stopTasks.Add(async() => multicast.Dispose()); #pragma warning restore CS1998 } var autodialer = new AutoDialer(swarm) { MinConnections = Options.Swarm.MinConnections }; #pragma warning disable CS1998 stopTasks.Add(async() => autodialer.Dispose()); #pragma warning restore CS1998 tasks = new List <Func <Task> > { // Bootstrap discovery async() => { var bootstrap = new PeerTalk.Discovery.Bootstrap { Addresses = await this.Bootstrap.ListAsync() }; bootstrap.PeerDiscovered += OnPeerDiscovered; stopTasks.Add(async() => await bootstrap.StopAsync().ConfigureAwait(false)); await bootstrap.StartAsync().ConfigureAwait(false); }, // New multicast DNS discovery async() => { if (Options.Discovery.DisableMdns) { return; } var mdns = new PeerTalk.Discovery.MdnsNext { LocalPeer = localPeer, MulticastService = multicast }; if (Options.Swarm.PrivateNetworkKey != null) { mdns.ServiceName = $"_p2p-{Options.Swarm.PrivateNetworkKey.Fingerprint().ToHexString()}._udp"; } mdns.PeerDiscovered += OnPeerDiscovered; stopTasks.Add(async() => await mdns.StopAsync().ConfigureAwait(false)); await mdns.StartAsync().ConfigureAwait(false); }, // Old style JS multicast DNS discovery async() => { if (Options.Discovery.DisableMdns || Options.Swarm.PrivateNetworkKey != null) { return; } var mdns = new PeerTalk.Discovery.MdnsJs { LocalPeer = localPeer, MulticastService = multicast }; mdns.PeerDiscovered += OnPeerDiscovered; stopTasks.Add(async() => await mdns.StopAsync().ConfigureAwait(false)); await mdns.StartAsync().ConfigureAwait(false); }, // Old style GO multicast DNS discovery async() => { if (Options.Discovery.DisableMdns || Options.Swarm.PrivateNetworkKey != null) { return; } var mdns = new PeerTalk.Discovery.MdnsGo { LocalPeer = localPeer, MulticastService = multicast }; mdns.PeerDiscovered += OnPeerDiscovered; stopTasks.Add(async() => await mdns.StopAsync().ConfigureAwait(false)); await mdns.StartAsync().ConfigureAwait(false); }, async() => { if (Options.Discovery.DisableRandomWalk) { return; } var randomWalk = new RandomWalk { Dht = Dht }; stopTasks.Add(async() => await randomWalk.StopAsync().ConfigureAwait(false)); await randomWalk.StartAsync().ConfigureAwait(false); } }; log.Debug("waiting for discovery services to start"); await Task.WhenAll(tasks.Select(t => t())).ConfigureAwait(false); multicast?.Start(); log.Debug("started"); }
void Init() { // Init the core api inteface. Bitswap = new BitswapApi(this); Block = new BlockApi(this); BlockRepository = new BlockRepositoryApi(this); Bootstrap = new BootstrapApi(this); Config = new ConfigApi(this); Dag = new DagApi(this); Dht = new DhtApi(this); Dns = new DnsApi(this); FileSystem = new FileSystemApi(this); Generic = new GenericApi(this); Key = new KeyApi(this); Name = new NameApi(this); Object = new ObjectApi(this); Pin = new PinApi(this); PubSub = new PubSubApi(this); Stats = new StatsApi(this); Swarm = new SwarmApi(this); // Async properties LocalPeer = new AsyncLazy <Peer>(async() => { log.Debug("Building local peer"); var keyChain = await KeyChain().ConfigureAwait(false); log.Debug("Getting key info about self"); var self = await keyChain.FindKeyByNameAsync("self").ConfigureAwait(false); var localPeer = new Peer { Id = self.Id, PublicKey = await keyChain.GetPublicKeyAsync("self").ConfigureAwait(false), ProtocolVersion = "ipfs/0.1.0" }; var version = typeof(IpfsEngine).GetTypeInfo().Assembly.GetName().Version; localPeer.AgentVersion = $"net-ipfs/{version.Major}.{version.Minor}.{version.Revision}"; log.Debug("Built local peer"); return(localPeer); }); SwarmService = new AsyncLazy <Swarm>(async() => { log.Debug("Building swarm service"); if (Options.Swarm.PrivateNetworkKey == null) { var path = Path.Combine(Options.Repository.Folder, "swarm.key"); if (File.Exists(path)) { using (var x = File.OpenText(path)) { Options.Swarm.PrivateNetworkKey = new PreSharedKey(); Options.Swarm.PrivateNetworkKey.Import(x); } } } var peer = await LocalPeer.ConfigureAwait(false); var keyChain = await KeyChain().ConfigureAwait(false); var self = await keyChain.GetPrivateKeyAsync("self").ConfigureAwait(false); var swarm = new Swarm { LocalPeer = peer, LocalPeerKey = PeerTalk.Cryptography.Key.CreatePrivateKey(self), NetworkProtector = Options.Swarm.PrivateNetworkKey == null ? null : new Psk1Protector { Key = Options.Swarm.PrivateNetworkKey } }; if (Options.Swarm.PrivateNetworkKey != null) { log.Debug($"Private network {Options.Swarm.PrivateNetworkKey.Fingerprint().ToHexString()}"); } log.Debug("Built swarm service"); return(swarm); }); BitswapService = new AsyncLazy <BlockExchange.Bitswap>(async() => { log.Debug("Building bitswap service"); var bitswap = new BlockExchange.Bitswap { Swarm = await SwarmService.ConfigureAwait(false), BlockService = Block }; log.Debug("Built bitswap service"); return(bitswap); }); DhtService = new AsyncLazy <PeerTalk.Routing.Dht1>(async() => { log.Debug("Building DHT service"); var dht = new PeerTalk.Routing.Dht1 { Swarm = await SwarmService.ConfigureAwait(false) }; dht.Swarm.Router = dht; log.Debug("Built DHT service"); return(dht); }); PubSubService = new AsyncLazy <PeerTalk.PubSub.NotificationService>(async() => { log.Debug("Building PubSub service"); var pubsub = new PeerTalk.PubSub.NotificationService { LocalPeer = await LocalPeer.ConfigureAwait(false) }; pubsub.Routers.Add(new PeerTalk.PubSub.FloodRouter { Swarm = await SwarmService.ConfigureAwait(false) }); log.Debug("Built PubSub service"); return(pubsub); }); }