public static async Task<SharePointClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } ResourceDiscoveryResult dcr = null; try { dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); } catch (AuthenticationFailedException) { // If the user go back in the login page an Authentication exception is launched. return null; } _lastLoggedInUser = dcr.UserId; return new SharePointClient(ServiceEndpointUri, async () => { return (await _discoveryContext.AuthenticationContext .AcquireTokenSilentAsync(ServiceResourceId, _discoveryContext.AppIdentity.ClientId, new Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifier(dcr.UserId, Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifierType.UniqueId))).AccessToken; }); }
public static async Task <SharePointClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } ResourceDiscoveryResult dcr = null; try { dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); } catch (AuthenticationFailedException) { // If the user go back in the login page an Authentication exception is launched. return(null); } _lastLoggedInUser = dcr.UserId; return(new SharePointClient(ServiceEndpointUri, async() => { return (await _discoveryContext.AuthenticationContext .AcquireTokenSilentAsync(ServiceResourceId, _discoveryContext.AppIdentity.ClientId, new Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifier(dcr.UserId, Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifierType.UniqueId))).AccessToken; })); }
public static async Task <PullRequest> FindGithubPullRequestAsync(DiscoveryContext context, string repoOwner, string repoName, string creator, string title) { // Optimization: if the creator is the current user, we can rely on the cached list of pull requests if (creator.EqualsIgnoreCase(context.GithubClient.Connection.Credentials.Login)) { return(context.PullRequestsCreatedByCurrentUser .Where(p => { var success = Misc.DeriveGitHubRepositoryInfo(new Uri(p.Url), out string owner, out string name); return owner.EqualsIgnoreCase(repoOwner) && name.EqualsIgnoreCase(repoName); }) .FirstOrDefault(i => i.Title.EqualsIgnoreCase(title))); } else { var request = new PullRequestRequest() { State = ItemStateFilter.Open, SortProperty = PullRequestSort.Created, SortDirection = SortDirection.Descending }; var pullRequests = await context.GithubClient.PullRequest.GetAllForRepository(repoOwner, repoName, request).ConfigureAwait(false); var pullRequest = pullRequests.FirstOrDefault(pr => pr.Title.EqualsIgnoreCase(title) && pr.User.Login.EqualsIgnoreCase(creator)); return(pullRequest); } }
public static async Task <GraphServiceClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(GraphResourceId); _lastLoggedInUser = dcr.UserId; var clientCredential = new ClientCredential(_discoveryContext.AppIdentity.ClientId, _discoveryContext.AppIdentity.ClientSecret); var authResult = await _discoveryContext .AuthenticationContext .AcquireTokenByRefreshTokenAsync(new SessionCache().Read("RefreshToken"), clientCredential, GraphResourceId); var graphToken = authResult.AccessToken; var authenticationProvider = new DelegateAuthenticationProvider( (requestMessage) => { requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", graphToken); return(Task.FromResult(0)); }); return(new GraphServiceClient(authenticationProvider)); }
private async Task <SharePointClient> EnsureClientCreated() { DiscoveryContext disco = GetFromCache("DiscoveryContext") as DiscoveryContext; if (disco == null) { disco = await DiscoveryContext.CreateAsync(); SaveInCache("DiscoveryContext", disco); } var dcr = await disco.DiscoverCapabilityAsync("MyFiles"); var ServiceResourceId = dcr.ServiceResourceId; var ServiceEndpointUri = dcr.ServiceEndpointUri; SaveInCache("LastLoggedInUser", dcr.UserId); return(new SharePointClient(ServiceEndpointUri, async() => { return (await disco.AuthenticationContext.AcquireTokenByRefreshTokenAsync( new SessionCache().Read("RefreshToken"), new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential( disco.AppIdentity.ClientId, disco.AppIdentity.ClientSecret), ServiceResourceId)).AccessToken; })); }
public async Task ExecuteAsync(DiscoveryContext context, TextWriter log) { ExcelPackage.LicenseContext = LicenseContext.NonCommercial; using (var excel = new ExcelPackage(new FileInfo(context.ExcelReportPath))) { var deprecatedAddins = context.Addins.Where(addin => addin.IsDeprecated).ToArray(); var auditedAddins = context.Addins.Where(addin => !addin.IsDeprecated && string.IsNullOrEmpty(addin.AnalysisResult.Notes)).ToArray(); var exceptionAddins = context.Addins.Where(addin => !addin.IsDeprecated && !string.IsNullOrEmpty(addin.AnalysisResult.Notes)).ToArray(); var namedStyle = excel.Workbook.Styles.CreateNamedStyle("HyperLink"); namedStyle.Style.Font.UnderLine = true; namedStyle.Style.Font.Color.SetColor(Color.Blue); // One worksheet per version of Cake foreach (var cakeVersion in Constants.CAKE_VERSIONS.OrderByDescending(cakeVersion => cakeVersion.Version)) { GenerateExcelWorksheet(auditedAddins, cakeVersion, AddinType.Addin | AddinType.Module, $"Cake {cakeVersion.Version}", excel); } // One worksheet for recipes GenerateExcelWorksheet(auditedAddins, null, AddinType.Recipe, "Recipes", excel); // Exceptions report GenerateExcelWorksheetWithNotes(exceptionAddins, "Exceptions", excel); // Deprecated report GenerateExcelWorksheetWithNotes(deprecatedAddins, "Deprecated", excel); // Save the Excel file excel.Save(); } await Task.Delay(1).ConfigureAwait(false); }
private async Task DeleteMergedBranches(DiscoveryContext context, IEnumerable <Branch> branches, TextWriter log) { // Delete branches when their corresponding PR has been merged foreach (var branch in branches) { var pullRequestsRequest = new PullRequestRequest() { State = ItemStateFilter.Closed, SortProperty = PullRequestSort.Updated, SortDirection = SortDirection.Descending, Head = $"{context.Options.GithubUsername}:{branch.Name}" }; var pullRequests = await context.GithubClient.Repository.PullRequest .GetAllForRepository(Constants.CAKE_REPO_OWNER, Constants.CAKE_WEBSITE_REPO_NAME, pullRequestsRequest) .ConfigureAwait(false); var pr = pullRequests.SingleOrDefault(pr => pr.Head.Sha == branch.Commit.Sha); if (pr != null && pr.Merged) { await log.WriteLineAsync($"Deleting branch {context.Options.GithubUsername}/{Constants.CAKE_WEBSITE_REPO_NAME}/{branch.Name}").ConfigureAwait(false); await context.GithubClient.Git.Reference .Delete(context.Options.GithubUsername, Constants.CAKE_WEBSITE_REPO_NAME, $"heads/{branch.Name}") .ConfigureAwait(false); } } }
private async Task DeleteBranches(DiscoveryContext context, TextWriter log) { var sensitiveBranches = new[] { "develop", "master", "main", "publish/develop", "publish/master", "publish/main" }; var branches = await context.GithubClient.Repository.Branch .GetAll(context.Options.GithubUsername, Constants.CAKE_WEBSITE_REPO_NAME) .ConfigureAwait(false); var safeBranches = branches .Where(branch => !sensitiveBranches.Contains(branch.Name)) .ToArray(); var dryRunBranches = safeBranches .Where(branch => branch.Name.StartsWith("dryrun", StringComparison.OrdinalIgnoreCase)) .ToArray(); var otherBranches = safeBranches .Except(dryRunBranches) .ToArray(); await DeleteDryRunBranches(context, dryRunBranches, log).ConfigureAwait(false); await DeleteMergedBranches(context, otherBranches, log).ConfigureAwait(false); }
private async Task <ExchangeClient> EnsureClientCreated() { DiscoveryContext disco = GetFromCache("DiscoveryContext") as DiscoveryContext; if (disco == null) { disco = await DiscoveryContext.CreateAsync(); SaveInCache("DiscoveryContext", disco); } string ServiceResourceId = "https://outlook.office365.com"; Uri ServiceEndpointUri = new Uri("https://outlook.office365.com/ews/odata"); var dcr = await disco.DiscoverResourceAsync(ServiceResourceId); SaveInCache("LastLoggedInUser", dcr.UserId); return(new ExchangeClient(ServiceEndpointUri, async() => { return (await disco.AuthenticationContext.AcquireTokenByRefreshTokenAsync( new SessionCache().Read("RefreshToken"), new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential( disco.AppIdentity.ClientId, disco.AppIdentity.ClientSecret), ServiceResourceId)).AccessToken; })); }
public AddinDiscoverer(Options options) { // Setup the Github client var proxy = string.IsNullOrEmpty(options.ProxyUrl) ? null : new WebProxy(options.ProxyUrl); var credentials = !string.IsNullOrEmpty(options.GithubToken) ? new Credentials(options.GithubToken) : new Credentials(options.GithubUsername, options.GithuPassword); var connection = new Connection(new ProductHeaderValue(Constants.PRODUCT_NAME), new HttpClientAdapter(() => HttpMessageHandlerFactory.CreateDefault(proxy))) { Credentials = credentials, }; // This environment variable is used by NuGet.Configuration.ProxyCache to configure a proxy Environment.SetEnvironmentVariable("http_proxy", options.ProxyUrl); // Setup nuget var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(NuGet.Protocol.Core.Types.Repository.Provider.GetCoreV3()); // Add v3 API support var packageSource = new PackageSource("https://api.nuget.org/v3/index.json"); // Setup the context that will be passed to each step _context = new DiscoveryContext() { Addins = Array.Empty <AddinMetadata>(), GithubClient = new GitHubClient(connection), GithubHttpClient = new HttpClientAdapter(() => HttpMessageHandlerFactory.CreateDefault(proxy)), HttpClient = new HttpClient(new HttpClientHandler() { Proxy = proxy, UseProxy = proxy != null }), NugetRepository = new SourceRepository(packageSource, providers), Options = options, TempFolder = Path.Combine(options.TemporaryFolder, Constants.PRODUCT_NAME), Version = typeof(AddinDiscoverer).GetTypeInfo().Assembly.GetName().Version.ToString(3) }; }
public async Task <ActionResult> Index(string authType) { if (authType == "O365") { try { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); _lastLoggedInUser = dcr.UserId; string accessToken = (await _discoveryContext.AuthenticationContext.AcquireTokenByRefreshTokenAsync(new SessionCache().Read("RefreshToken"), new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential(_discoveryContext.AppIdentity.ClientId, _discoveryContext.AppIdentity.ClientSecret), ServiceResourceId)).AccessToken; OAuthController.SaveAccessTokenInCache(ServiceResourceId, accessToken, DateTime.Now.AddMinutes(10).ToString()); return(new RedirectResult("/Home/App")); } catch (RedirectRequiredException ex) { return(Redirect(ex.RedirectUri.ToString())); } } else { string redirectUri = this.Request.Url.GetLeftPart(UriPartial.Authority).ToString() + "/Home/App"; string authorizationUrl = OAuthController.GetAuthorizationUrl(ServiceResourceId, new Uri(redirectUri)); return(new RedirectResult(authorizationUrl)); } }
private IEnumerable <DiscoveredModel> GetModels(DiscoveryContext context) { IEnumerable <System.Type> cronusJobs = context.FindService <ICronusJob <object> >(); foreach (var job in cronusJobs) { yield return(new DiscoveredModel(job, job, ServiceLifetime.Transient)); } yield return(new DiscoveredModel(typeof(TypeContainer <ICronusJob <object> >), new TypeContainer <ICronusJob <object> >(cronusJobs))); yield return(new DiscoveredModel(typeof(InMemoryCronusJobRunner), typeof(InMemoryCronusJobRunner), ServiceLifetime.Transient)); yield return(new DiscoveredModel(typeof(ICronusJobRunner), typeof(InMemoryCronusJobRunner), ServiceLifetime.Transient)); yield return(new DiscoveredModel(typeof(IJobNameBuilder), typeof(DefaultJobNameBuilder), ServiceLifetime.Scoped)); yield return(new DiscoveredModel(typeof(DefaultJobNameBuilder), typeof(DefaultJobNameBuilder), ServiceLifetime.Scoped)); yield return(new DiscoveredModel(typeof(RebuildIndex_EventToAggregateRootId_JobFactory), typeof(RebuildIndex_EventToAggregateRootId_JobFactory), ServiceLifetime.Transient)); yield return(new DiscoveredModel(typeof(Projection_JobFactory), typeof(Projection_JobFactory), ServiceLifetime.Transient)); yield return(new DiscoveredModel(typeof(RebuildIndex_MessageCounter_JobFactory), typeof(RebuildIndex_MessageCounter_JobFactory), ServiceLifetime.Transient)); yield return(new DiscoveredModel(typeof(ReplayPublicEvents_JobFactory), typeof(ReplayPublicEvents_JobFactory), ServiceLifetime.Transient)); }
public static ModelScheme <T> Create <T>(Specification <T> specification, ICapacityInfo capacityInfo) { ThrowHelper.NullArgument(specification, nameof(specification)); var scopeBuilderContext = new ScopeBuilderContext(); var rootSpecificationScopeId = scopeBuilderContext.GetOrRegisterSpecificationScope(specification); var discoveryContext = new DiscoveryContext(scopeBuilderContext, rootSpecificationScopeId); var rootSpecificationScope = (SpecificationScope <T>)scopeBuilderContext.Scopes[rootSpecificationScopeId]; rootSpecificationScope.Discover(discoveryContext); if (capacityInfo is ICapacityInfoHelpersConsumer capacityInfoHelpersConsumer) { capacityInfoHelpersConsumer.InjectHelpers(CapacityInfoHelpers); } if (capacityInfo is IFeedableCapacityInfo feedableCapacityInfo && feedableCapacityInfo.ShouldFeed) { feedableCapacityInfo.Feed(discoveryContext); } return(new ModelScheme <T>( scopeBuilderContext.Scopes, rootSpecificationScopeId, scopeBuilderContext.Errors, discoveryContext.Errors.ToDictionary(p => p.Key, p => (IReadOnlyList <int>)p.Value), discoveryContext.Paths.ToDictionary(p => p.Key, p => (IReadOnlyDictionary <string, string>)p.Value), capacityInfo, discoveryContext.ReferenceLoopRoots.Count > 0)); }
/// <summary> /// Checks that an Exchange client is available to the client. /// </summary> /// <returns>The Exchange Online client.</returns> public static async Task<ExchangeClient> EnsureCalendarClientCreatedAsync() { try { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(ExchangeServiceResourceId); _loggedInUser = dcr.UserId; return new ExchangeClient(ExchangeServiceEndpointUri, async () => { return (await _discoveryContext.AuthenticationContext.AcquireTokenSilentAsync(ExchangeServiceResourceId, _discoveryContext.AppIdentity.ClientId, new Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifier(dcr.UserId, Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifierType.UniqueId))).AccessToken; }); } catch (AuthenticationFailedException ex) { string errorText = String.Format( "{0}, code {1}. EnsureCalendarClientCreatedAsync - failed", ex.ErrorDescription, ex.ErrorCode); LoggingViewModel.Instance.Information = errorText; } return null; }
public async Task<ActionResult> Index(string authType) { if (authType == "O365") { try { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); _lastLoggedInUser = dcr.UserId; string accessToken = (await _discoveryContext.AuthenticationContext.AcquireTokenByRefreshTokenAsync(new SessionCache().Read("RefreshToken"), new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential(_discoveryContext.AppIdentity.ClientId, _discoveryContext.AppIdentity.ClientSecret), ServiceResourceId)).AccessToken; OAuthController.SaveAccessTokenInCache(ServiceResourceId, accessToken, DateTime.Now.AddMinutes(10).ToString()); return new RedirectResult("/Home/App"); } catch (RedirectRequiredException ex) { return Redirect(ex.RedirectUri.ToString()); } } else { string redirectUri = this.Request.Url.GetLeftPart(UriPartial.Authority).ToString() + "/Home/App"; string authorizationUrl = OAuthController.GetAuthorizationUrl(ServiceResourceId, new Uri(redirectUri)); return new RedirectResult(authorizationUrl); } }
public static async Task <Issue> FindGithubIssueAsync(DiscoveryContext context, string repoOwner, string repoName, string creator, string title) { // Optimization: if the creator is the current user, we can rely on the cached list of issues if (creator.EqualsIgnoreCase(context.GithubClient.Connection.Credentials.Login)) { return(context.IssuesCreatedByCurrentUser .Where(i => { var success = Misc.DeriveGitHubRepositoryInfo(new Uri(i.Url), out string owner, out string name); return owner.EqualsIgnoreCase(repoOwner) && name.EqualsIgnoreCase(repoName); }) .FirstOrDefault(i => i.Title.EqualsIgnoreCase(title))); } else { var request = new RepositoryIssueRequest() { Creator = creator, State = ItemStateFilter.Open, SortProperty = IssueSort.Created, SortDirection = SortDirection.Descending }; var issues = await context.GithubClient.Issue.GetAllForRepository(repoOwner, repoName, request).ConfigureAwait(false); var issue = issues.FirstOrDefault(i => i.Title.EqualsIgnoreCase(title)); return(issue); } }
public async Task ExecuteAsync(DiscoveryContext context, TextWriter log) { var recommendedCakeVersion = Constants.CAKE_VERSIONS .OrderByDescending(cakeVersion => cakeVersion.Version) .First(); context.Addins = await context.Addins .ForEachAsync( async addin => { if (addin.Type != AddinType.Recipe && !addin.IsDeprecated && !string.IsNullOrEmpty(addin.RepositoryName) && !string.IsNullOrEmpty(addin.RepositoryOwner)) { if (addin.AuditIssue != null && addin.AuditIssue.UpdatedAt.HasValue && DateTimeOffset.UtcNow.Subtract(addin.AuditIssue.UpdatedAt.Value).TotalDays > 90) { await AddCommentAsync(context.Options.DryRun, context, addin).ConfigureAwait(false); } else if (addin.AuditIssue == null) { var issue = await CreateIssueAsync(context.Options.DryRun, context, addin, recommendedCakeVersion).ConfigureAwait(false); if (issue != null) { addin.AuditIssue = issue; context.IssuesCreatedByCurrentUser.Add(issue); } } } return(addin); }, Constants.MAX_GITHUB_CONCURENCY) .ConfigureAwait(false); }
public async Task ExecuteAsync(DiscoveryContext context, TextWriter log) { var recommendedCakeVersion = Constants.CAKE_VERSIONS .OrderByDescending(cakeVersion => cakeVersion.Version) .First(); context.Addins = await context.Addins .OrderBy(a => a.Name) .ForEachAsync( async addin => { if (addin.Type != AddinType.Recipe && addin.AuditIssue != null && addin.AuditPullRequest == null && !string.IsNullOrEmpty(addin.RepositoryName) && !string.IsNullOrEmpty(addin.RepositoryOwner)) { var commits = new List <(string CommitMessage, IEnumerable <string> FilesToDelete, IEnumerable <(EncodingType Encoding, string Path, string Content)> FilesToUpsert)>(); await FixNuspec(context, addin, recommendedCakeVersion, commits).ConfigureAwait(false); await FixCsproj(context, addin, recommendedCakeVersion, commits).ConfigureAwait(false); if (commits.Any()) { // Make sure we have enough API calls left before proceeding var apiInfo = context.GithubClient.GetLastApiInfo(); var requestsLeft = apiInfo?.RateLimit?.Remaining ?? 0; if (requestsLeft > Constants.MIN_GITHUB_REQUESTS_THRESHOLD) { // Fork the addin repo if it hasn't been forked already and make sure it's up to date var fork = await context.GithubClient.CreateOrRefreshFork(addin.RepositoryOwner, addin.RepositoryName).ConfigureAwait(false); // This delay is important to avoid triggering GitHub's abuse protection await Misc.RandomGithubDelayAsync().ConfigureAwait(false); // Commit changes to a new branch and submit PR var newBranchName = $"addin_discoverer_{DateTime.UtcNow:yyyy_MM_dd_HH_mm_ss}"; var pullRequest = await Misc.CommitToNewBranchAndSubmitPullRequestAsync(context, fork, addin.AuditIssue?.Number, newBranchName, Constants.PULL_REQUEST_TITLE, commits).ConfigureAwait(false); if (pullRequest != null) { addin.AuditPullRequest = pullRequest; context.PullRequestsCreatedByCurrentUser.Add(pullRequest); } // This delay is important to avoid triggering GitHub's abuse protection await Misc.RandomGithubDelayAsync().ConfigureAwait(false); } else { Console.WriteLine($" Only {requestsLeft} GitHub API requests left. Therefore skipping PR for {addin.Name} despite the fact that we have {commits.Count} commits."); } } } return(addin); }, Constants.MAX_GITHUB_CONCURENCY) .ConfigureAwait(false); }
private async Task <SharePointClient> EnsureClientCreated() { DiscoveryContext disco = GetFromCache("DiscoveryContext") as DiscoveryContext; if (disco == null) { disco = await DiscoveryContext.CreateAsync(); SaveInCache("DiscoveryContext", disco); } var dcr = await disco.DiscoverCapabilityAsync(MyFilesCapability); var ServiceResourceId = dcr.ServiceResourceId; var ServiceEndpointUri = dcr.ServiceEndpointUri; SaveInCache("LastLoggedInUser", dcr.UserId); return(new SharePointClient(ServiceEndpointUri, async() => { Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential creds = new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential( disco.AppIdentity.ClientId, disco.AppIdentity.ClientSecret); return (await disco.AuthenticationContext.AcquireTokenSilentAsync( ServiceResourceId, creds, new UserIdentifier(dcr.UserId, UserIdentifierType.UniqueId))).AccessToken; })); }
public string GetDescription(DiscoveryContext context) { if (string.IsNullOrEmpty(context.Options.AddinName)) { return("Download packages from NuGet"); } return($"Download package for {context.Options.AddinName}"); }
private async Task <JObject> DownloadResourceFromGitHub(DiscoveryContext context, string resourceName) { var resourcePath = $"Source/Cake.AddinDiscoverer/{resourceName}"; var contents = await context.GithubClient.Repository.Content.GetAllContents(Constants.CAKE_CONTRIB_REPO_OWNER, Constants.ADDIN_DISCOVERER_REPO_NAME, resourcePath).ConfigureAwait(false); var jObject = JObject.Parse(contents[0].Content); return(jObject); }
public Task ExecuteAsync(DiscoveryContext context, TextWriter log, CancellationToken cancellationToken) { context.Addins = context.Addins .Where(addin => addin.Name.Equals(context.Options.AddinName, StringComparison.OrdinalIgnoreCase) || !context.ExcludedAddins.Any(excludedAddinName => addin.Name.IsMatch(excludedAddinName))) .OrderBy(addin => addin.Name) .ToArray(); return(Task.CompletedTask); }
public async Task ExecuteAsync(DiscoveryContext context) { context.Addins = context.Addins .Where(addin => !context.ExcludedAddins.Any(excludedAddinName => addin.Name.IsMatch(excludedAddinName))) .OrderBy(addin => addin.Name) .ToArray(); await Task.Delay(1).ConfigureAwait(false); }
private async Task <IssueComment> AddCommentAsync(bool debugging, DiscoveryContext context, AddinMetadata addin) { var comment = new StringBuilder(); comment.AppendLine($"We performed a follow up automated audit of your Cake addin and found that some (or all) issues previously identified have not been resolved.{Environment.NewLine}"); comment.AppendLine($"We strongly encourage you to make the modifications previously highlighted.{Environment.NewLine}"); if (addin.AnalysisResult.Icon == IconAnalysisResult.RawgitUrl) { comment.AppendLine($"In particular would would like to highlight the fact that you use the rawgit CDN to serve your addin's icon. On October 8 2018 the maintainer of rawgit made the [announcement](https://rawgit.com/) that rawgit would shutdown in October 2019. Therefore it's **urgent** that you change your addin's icon URL to the new recommended URL: `{Constants.NEW_CAKE_CONTRIB_ICON_URL}`.{Environment.NewLine}"); } if (addin.AnalysisResult.Icon != IconAnalysisResult.EmbeddedCakeContrib && addin.AnalysisResult.Icon != IconAnalysisResult.EmbeddedFancyCakeContrib) { comment.AppendLine($"Please also note that the recommendation changed following .netcore3.0's release: you should now embedded the icon in your Nuget package. Read more about embedded icons in the [.nuspec reference](https://docs.microsoft.com/en-us/nuget/reference/nuspec#icon).{Environment.NewLine}"); } comment.AppendLine($"{Environment.NewLine}This comment was created by a tool: Cake.AddinDiscoverer version {context.Version}{Environment.NewLine}"); IssueComment issueComment = null; try { if (debugging) { await File.WriteAllTextAsync(Path.Combine(context.TempFolder, $"Comment_{addin.Name}.txt"), comment.ToString()).ConfigureAwait(false); } else { issueComment = await context.GithubClient.Issue.Comment.Create(addin.RepositoryOwner, addin.RepositoryName, addin.AuditIssue.Number, comment.ToString()).ConfigureAwait(false); } } catch (ApiException e) when(e.ApiError.Message.EqualsIgnoreCase("Issues are disabled for this repo")) { // There's a NuGet package with a project URL that points to a fork which doesn't allow issue. // Therefore it's safe to ignore this error. } catch (ApiException e) when(e.StatusCode == System.Net.HttpStatusCode.NotFound) { // I know of at least one case where the URL in the NuGet metadata points to a repo that has been deleted. // Therefore it's safe to ignore this error. } #pragma warning disable CS0168 // Variable is declared but never used catch (Exception e) #pragma warning restore CS0168 // Variable is declared but never used { Debugger.Break(); throw; } finally { // This delay is important to avoid triggering GitHub's abuse protection await Misc.RandomGithubDelayAsync().ConfigureAwait(false); } return(issueComment); }
public AddinDiscoverer(Options options) { // Setup the Github client var proxy = string.IsNullOrEmpty(options.ProxyUrl) ? null : new WebProxy(options.ProxyUrl); var credentials = !string.IsNullOrEmpty(options.GithubToken) ? new Credentials(options.GithubToken) : new Credentials(options.GithubUsername, options.GithuPassword); var connection = new Connection(new ProductHeaderValue(Constants.PRODUCT_NAME), new HttpClientAdapter(() => HttpMessageHandlerFactory.CreateDefault(proxy))) { Credentials = credentials, }; // Setup nuget var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(NuGet.Protocol.Core.Types.Repository.Provider.GetCoreV3()); // Add v3 API support var packageSource = new PackageSource("https://api.nuget.org/v3/index.json"); // Setup the context that will be passed to each step _context = new DiscoveryContext() { Addins = Array.Empty <AddinMetadata>(), GithubClient = new GitHubClient(connection), GithubHttpClient = new HttpClientAdapter(() => HttpMessageHandlerFactory.CreateDefault(proxy)), HttpClient = new HttpClient(new HttpClientHandler() { Proxy = proxy, UseProxy = proxy != null }), NugetRepository = new SourceRepository(packageSource, providers), Options = options, TempFolder = Path.Combine(options.TemporaryFolder, Constants.PRODUCT_NAME), Version = typeof(AddinDiscoverer).GetTypeInfo().Assembly.GetName().Version.ToString(3) }; // Using '.CodeBase' because it returns where the assembly is located when not executing (in other words, the 'permanent' path of the assembly). // '.Location' would seem more intuitive but in the case of shadow copied assemblies, it would return a path in a temp directory. var currentPath = new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath; var currentFolder = Path.GetDirectoryName(currentPath); var exclusionFilePath = Path.Combine(currentFolder, "exclusionlist.json"); var inclusionFilePath = Path.Combine(currentFolder, "inclusionlist.json"); using (var sr = new StreamReader(exclusionFilePath)) { var json = sr.ReadToEnd(); var jObject = JObject.Parse(json); _context.ExcludedAddins = jObject.Property("packages")?.Value.ToObject <string[]>() ?? Array.Empty <string>(); _context.ExcludedTags = jObject.Property("labels")?.Value.ToObject <string[]>() ?? Array.Empty <string>(); } using (var sr = new StreamReader(inclusionFilePath)) { var json = sr.ReadToEnd(); var jObject = JObject.Parse(json); _context.IncludedAddins = jObject.Property("packages")?.Value.ToObject <string[]>() ?? Array.Empty <string>(); } }
private async Task <RecipeFile[]> GetRecipeFilesAsync(DiscoveryContext context, CakeVersion currentCakeVersion, CakeVersion nextCakeVersion, CakeVersion latestCakeVersion) { var directoryContent = await context.GithubClient.Repository.Content.GetAllContents(Constants.CAKE_CONTRIB_REPO_OWNER, Constants.CAKE_RECIPE_REPO_NAME, "Cake.Recipe/Content").ConfigureAwait(false); var cakeFiles = directoryContent.Where(c => c.Type == new StringEnum <ContentType>(ContentType.File) && c.Name.EndsWith(".cake", StringComparison.OrdinalIgnoreCase)); var recipeFiles = await cakeFiles .ForEachAsync( async cakeFile => { var contents = await context.GithubClient.Repository.Content.GetAllContents(Constants.CAKE_CONTRIB_REPO_OWNER, Constants.CAKE_RECIPE_REPO_NAME, cakeFile.Path).ConfigureAwait(false); var recipeFile = new RecipeFile() { Name = cakeFile.Name, Path = cakeFile.Path, Content = contents[0].Content }; foreach (var addinReference in recipeFile.AddinReferences) { addinReference.LatestVersionForCurrentCake = context.Addins.SingleOrDefault(addin => { return(addin.Name.Equals(addinReference.Name, StringComparison.OrdinalIgnoreCase) && !addin.IsPrerelease && (currentCakeVersion == null || (addin.AnalysisResult.CakeCoreVersion.IsUpToDate(currentCakeVersion.Version) && addin.AnalysisResult.CakeCommonVersion.IsUpToDate(currentCakeVersion.Version))) && (nextCakeVersion == null || !(addin.AnalysisResult.CakeCoreVersion.IsUpToDate(nextCakeVersion.Version) && addin.AnalysisResult.CakeCommonVersion.IsUpToDate(nextCakeVersion.Version)))); })?.NuGetPackageVersion; addinReference.LatestVersionForLatestCake = context.Addins.SingleOrDefault(addin => { return(addin.Name.Equals(addinReference.Name, StringComparison.OrdinalIgnoreCase) && !addin.IsPrerelease && (latestCakeVersion != null && (addin.AnalysisResult.CakeCoreVersion.IsUpToDate(latestCakeVersion.Version) && addin.AnalysisResult.CakeCommonVersion.IsUpToDate(latestCakeVersion.Version)))); })?.NuGetPackageVersion; } var nugetPackageMetadataClient = context.NugetRepository.GetResource <PackageMetadataResource>(); await recipeFile.ToolReferences.ForEachAsync( async toolReference => { var searchMetadata = await nugetPackageMetadataClient.GetMetadataAsync(toolReference.Name, false, false, new SourceCacheContext(), NullLogger.Instance, CancellationToken.None).ConfigureAwait(false); var mostRecentPackageMetadata = searchMetadata.OrderByDescending(p => p.Published).FirstOrDefault(); if (mostRecentPackageMetadata != null) { toolReference.LatestVersion = mostRecentPackageMetadata.Identity.Version.ToNormalizedString(); } }, Constants.MAX_NUGET_CONCURENCY) .ConfigureAwait(false); return(recipeFile); }, Constants.MAX_GITHUB_CONCURENCY) .ConfigureAwait(false); return(recipeFiles); }
public static async Task<CapabilityDiscoveryResult> DiscoverMail() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverCapabilityAsync("Mail"); return dcr; }
private IEnumerable <Type> GetAllTypesImplementingOpenGenericType(DiscoveryContext context, Type openGenericType) { var resolverTypes = context.Assemblies .SelectMany(asm => asm.GetLoadableTypes()) .Where(type => type.IsAbstract == false && type.IsInterface == false && type.GetInterfaces() .Where(candidate => candidate.IsGenericType) .Any(candidate => openGenericType.IsAssignableFrom(candidate.GetGenericTypeDefinition()))); return(resolverTypes); }
public void Should_Initialize_WithDefaultValues() { var actions = Substitute.For <IDiscoveryContextActions>(); var context = new DiscoveryContext(actions, 0); context.Errors.Should().BeEmpty(); context.Paths.Should().BeEmpty(); context.ReferenceLoopRoots.Should().BeEmpty(); }
public async Task ExecuteAsync(DiscoveryContext context, TextWriter log, CancellationToken cancellationToken) { var exclusionListAsJObject = await GetResourceFile(context, "exclusionlist.json").ConfigureAwait(false); var inclusionListAsJObject = await GetResourceFile(context, "inclusionlist.json").ConfigureAwait(false); context.ExcludedAddins = exclusionListAsJObject.Property("packages")?.Value.ToObject <string[]>() ?? Array.Empty <string>(); context.ExcludedTags = exclusionListAsJObject.Property("labels")?.Value.ToObject <string[]>() ?? Array.Empty <string>(); context.IncludedAddins = inclusionListAsJObject.Property("packages")?.Value.ToObject <string[]>() ?? Array.Empty <string>(); }
private Task <JObject> GetResourceFile(DiscoveryContext context, string resourceName) { if (context.Options.UseLocalResources) { return(Task.FromResult <JObject>(GetLocalResource(resourceName))); } else { return(DownloadResourceFromGitHub(context, resourceName)); } }
public string GetDescription(DiscoveryContext context) { if (string.IsNullOrEmpty(context.Options.AddinName)) { return("Search NuGet for all packages matching 'Cake.*'"); } else { return($"Search NuGet for {context.Options.AddinName}"); } }
public static Uri SignOut(string postLogoutRedirect) { if (_discoveryContext == null) { _discoveryContext = new DiscoveryContext(); } _discoveryContext.ClearCache(); return _discoveryContext.GetLogoutUri<SessionCache>(postLogoutRedirect); }
public static Uri SignOut(string postLogoutRedirect) { if (_discoveryContext == null) { _discoveryContext = new DiscoveryContext(); } _discoveryContext.ClearCache(); return(_discoveryContext.GetLogoutUri <SessionCache>(postLogoutRedirect)); }
public async Task<ActionResult> O365API() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); _lastLoggedInUser = dcr.UserId; string accessToken = (await _discoveryContext.AuthenticationContext.AcquireTokenByRefreshTokenAsync(new SessionCache().Read("RefreshToken"), new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential(_discoveryContext.AppIdentity.ClientId, _discoveryContext.AppIdentity.ClientSecret), ServiceResourceId)).AccessToken; OAuthController.SaveAccessTokenInCache(ServiceResourceId, accessToken, DateTime.Now.AddMinutes(10).ToString()); return new RedirectResult("/Home/App"); }
public static Uri SignOut(string postLogoutRedirect) { DiscoveryContext _discoveryContext = System.Web.HttpContext.Current.Session["DiscoveryContext"] as DiscoveryContext; if (_discoveryContext == null) { _discoveryContext = new DiscoveryContext(); System.Web.HttpContext.Current.Session["DiscoveryContext"] = _discoveryContext; } _discoveryContext.ClearCache(); return _discoveryContext.GetLogoutUri<SessionCache>(postLogoutRedirect); }
public static async Task SignOut() { if (string.IsNullOrEmpty(_lastLoggedInUser)) { return; } if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } await _discoveryContext.LogoutAsync(_lastLoggedInUser); }
public static async Task<ExchangeClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); _lastLoggedInUser = dcr.UserId; return new ExchangeClient(ServiceEndpointUri, async () => { return (await _discoveryContext.AuthenticationContext.AcquireTokenByRefreshTokenAsync(new SessionCache().Read("RefreshToken"), new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential(_discoveryContext.AppIdentity.ClientId, _discoveryContext.AppIdentity.ClientSecret), ServiceResourceId)).AccessToken; }); }
public static async Task<AadGraphClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(ServiceResourceId); _lastLoggedInUser = dcr.UserId; return new AadGraphClient(new Uri(ServiceEndpointUri, dcr.TenantId), async () => { return (await _discoveryContext.AuthenticationContext.AcquireTokenSilentAsync(ServiceResourceId, _discoveryContext.AppIdentity.ClientId, new Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifier(dcr.UserId, Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifierType.UniqueId))).AccessToken; }); }
public static async Task<SharePointClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverCapabilityAsync(MyFilesCapability); var ServiceResourceId = dcr.ServiceResourceId; var ServiceEndpointUri = dcr.ServiceEndpointUri; _lastLoggedInUser = dcr.UserId; // Create the MyFiles client proxy: return new SharePointClient(ServiceEndpointUri, async () => { return (await _discoveryContext.AuthenticationContext.AcquireTokenSilentAsync(ServiceResourceId, _discoveryContext.AppIdentity.ClientId, new Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifier(dcr.UserId, Microsoft.IdentityModel.Clients.ActiveDirectory.UserIdentifierType.UniqueId))).AccessToken; }); }
public static async Task<GraphServiceClient> EnsureClientCreated() { if (_discoveryContext == null) { _discoveryContext = await DiscoveryContext.CreateAsync(); } var dcr = await _discoveryContext.DiscoverResourceAsync(GraphResourceId); _lastLoggedInUser = dcr.UserId; var clientCredential = new ClientCredential(_discoveryContext.AppIdentity.ClientId, _discoveryContext.AppIdentity.ClientSecret); var authResult = await _discoveryContext .AuthenticationContext .AcquireTokenByRefreshTokenAsync(new SessionCache().Read("RefreshToken"), clientCredential, GraphResourceId); var graphToken = authResult.AccessToken; var authenticationProvider = new DelegateAuthenticationProvider( (requestMessage) => { requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", graphToken); return Task.FromResult(0); }); return new GraphServiceClient(authenticationProvider); }