public static async Task <ConnectionStringDictionary> GetConnectionStringsAsync( WebSiteManagementClient webAppClient, TargetSite targetSite) { var conStringDict = await webAppClient.WebApps.ListConnectionStringsAsync(targetSite); return(conStringDict); }
public static async Task <PublishingProfile> GetPublishingProfile(TargetSite targetSite, ServicePrincipalAccount account) { string mgmtEndpoint = account.ResourceManagementEndpointBaseUri; var token = new TokenCredentials(await Auth.GetAuthTokenAsync(account)); var azureCredentials = new AzureCredentials( token, token, account.TenantId, new AzureKnownEnvironment(account.AzureEnvironment).AsAzureSDKEnvironment()) .WithDefaultSubscription(account.SubscriptionNumber); var restClient = RestClient .Configure() .WithBaseUri(mgmtEndpoint) .WithEnvironment(new AzureKnownEnvironment(account.AzureEnvironment).AsAzureSDKEnvironment()) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(azureCredentials) .Build(); var webAppClient = new WebSiteManagementClient(restClient) { SubscriptionId = account.SubscriptionNumber }; var options = new CsmPublishingProfileOptions { Format = PublishingProfileFormat.WebDeploy }; await webAppClient.WebApps.GetWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site); using var publishProfileStream = targetSite.HasSlot ? await webAppClient.WebApps.ListPublishingProfileXmlWithSecretsSlotAsync(targetSite.ResourceGroupName, targetSite.Site, options, targetSite.Slot) : await webAppClient.WebApps.ListPublishingProfileXmlWithSecretsAsync(targetSite.ResourceGroupName, targetSite.Site, options); using var streamReader = new StreamReader(publishProfileStream); var document = XDocument.Parse(await streamReader.ReadToEndAsync()); var profile = (from el in document.Descendants("publishProfile") where string.Compare(el.Attribute("publishMethod")?.Value, "MSDeploy", StringComparison.OrdinalIgnoreCase) == 0 select new PublishingProfile { PublishUrl = $"https://{el.Attribute("publishUrl")?.Value}", Username = el.Attribute("userName")?.Value, Password = el.Attribute("userPWD")?.Value, Site = el.Attribute("msdeploySite")?.Value }).FirstOrDefault(); if (profile == null) { throw new Exception("Failed to retrieve publishing profile."); } return(profile); }
protected override string InternalHandler(HttpContext context, TargetSite target, string targetRootDir, string requestedPath, ViewModel vm) { string sitemapPath; if (target.HasCustomLayout) { sitemapPath = Path.Combine(targetRootDir, Constants.LayoutFolderName, Constants.SitemapFileName); } else { sitemapPath = Path.Combine(Session.GetInstance().WebRoot, Constants.LayoutFolderName, Constants.SitemapFileName); } if (!File.Exists(sitemapPath)) { throw new InvalidOperationException(String.Format("Sitemap template file for '{0}' is missing. It should be at '{1}'", target.Name, sitemapPath)); } vm.Sitemap = this.BuildSitemap(targetRootDir); SparkRenderer renderer = new SparkRenderer(); string sitemapOutput = renderer.Render(sitemapPath, vm); vm.MarkdownHtml = sitemapOutput; string output = renderer.Render(target.TemplateFile, vm); return output; }
private void Initialize(IApplicationConfiguration config) { if (config != null) { _config = config; _targetSite = _config.TargetWebsite; var result = PerformaAPIRequest(new RequestBase(_config)); } }
public static async Task <string> GetBasicAuthCreds(ServicePrincipalAccount principalAccount, TargetSite targetSite) { var publishingProfile = await PublishingProfile.GetPublishingProfile(targetSite, principalAccount); string credential = Convert.ToBase64String( Encoding.ASCII.GetBytes($"{publishingProfile.Username}:{publishingProfile.Password}")); return(credential); }
protected override string InternalHandler(HttpContext context, TargetSite target, string targetRootDir, string requestedPath, ViewModel vm) { string mdFilePath = String.Format("{0}.md", Path.Combine(targetRootDir, requestedPath)); vm.MarkdownHtml = MarkdownHelper.ProcessMarkdown(MarkdownHelper.GetMarkdown(mdFilePath)); SparkRenderer renderer = new SparkRenderer(); string output = renderer.Render(target.TemplateFile, vm); return output; }
public static async Task <SiteConfigResource> GetConfigurationAsync(this IWebAppsOperations operations, TargetSite targetSite, CancellationToken cancellationToken = default) { if (targetSite.HasSlot) { return((await operations.GetConfigurationSlotWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, targetSite.Slot, cancellationToken: cancellationToken)).Body); } return((await operations.GetConfigurationWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, cancellationToken: cancellationToken)).Body); }
public HubLogConnection(TargetSite site) { connection = new HubConnectionBuilder() .WithUrl(site.Url.TrimEnd('/', '\\') + "/MelvilleSpecialLoggingHubWellKnownUrl", o => o.AccessTokenProvider = GetAccessToken) .WithAutomaticReconnect() .Build(); disposeToStopReadingEvents = connection.On("SendEvent", (Action <string>)HandleLogEvent); if (site.Secret.Length > 0) { token = CapWebTokenFactory.CreateCapWebClient(site.Name, site.Secret); } connection.StartAsync(); }
async Task AssertDeploySuccessAsync(TargetSite targetSite) { var imageName = newVariables.Get(SpecialVariables.Action.Package.PackageId); var registryUrl = newVariables.Get(SpecialVariables.Action.Package.Registry); var imageVersion = newVariables.Get(SpecialVariables.Action.Package.PackageVersion) ?? "latest"; var config = await webMgmtClient.WebApps.GetConfigurationAsync(targetSite); Assert.AreEqual($@"DOCKER|{imageName}:{imageVersion}", config.LinuxFxVersion); var appSettings = await webMgmtClient.WebApps.ListApplicationSettingsAsync(targetSite); Assert.AreEqual("https://" + registryUrl, appSettings.Properties["DOCKER_REGISTRY_SERVER_URL"]); }
public static int GetSiteId(this TargetSite site) { switch (site) { case TargetSite.Cryptopia_Production: return(EnvironmentConstants.ProductionSiteId); case TargetSite.Cryptopia_Development: return(EnvironmentConstants.DevelopmentSiteId); default: return(-1); } }
private async Task PublishAppSettings(WebSiteManagementClient webAppClient, TargetSite targetSite, AppSetting[] appSettings, string authToken) { var settingsDict = new StringDictionary { Properties = new Dictionary <string, string>() }; var existingSlotSettings = new List <string>(); // for each app setting found on the web app (existing app setting) update it value and add if is a slot setting, add foreach (var(name, value, SlotSetting) in (await AppSettingsManagement.GetAppSettingsAsync(webAppClient, authToken, targetSite)).ToList()) { settingsDict.Properties[name] = value; if (SlotSetting) { existingSlotSettings.Add(name); } } // for each app setting defined by the user foreach (var setting in appSettings) { // add/update the settings value settingsDict.Properties[setting.Name] = setting.Value; // if the user indicates a settings should no longer be a slot setting if (existingSlotSettings.Contains(setting.Name) && !setting.SlotSetting) { Log.Verbose($"Removing {setting.Name} from the list of slot settings"); existingSlotSettings.Remove(setting.Name); } } await AppSettingsManagement.PutAppSettingsAsync(webAppClient, settingsDict, targetSite); var slotSettings = appSettings .Where(setting => setting.SlotSetting) .Select(setting => setting.Name).ToArray(); if (!slotSettings.Any()) { return; } await AppSettingsManagement.PutSlotSettingsListAsync(webAppClient, targetSite, slotSettings.Union(existingSlotSettings), authToken); }
public static async Task RestartAsync(this IWebAppsOperations operations, TargetSite targetSite, bool?softRestart = null, bool?synchronous = null, CancellationToken cancellationToken = default) { if (targetSite.HasSlot) { await operations.RestartSlotWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, targetSite.Slot, softRestart, synchronous, cancellationToken : cancellationToken); } else { await operations.RestartWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, softRestart, synchronous, cancellationToken : cancellationToken); } }
public void CopyFrom(Skill skill) { id = skill.id; displayName = skill.displayName; cooldown = skill.cooldown; manaCost = skill.manaCost; isPassive = skill.isPassive; icon = skill.icon; description = skill.description; targetType = skill.targetType; targetCount = skill.targetCount; targetSite = skill.targetSite; possiblePositions = skill.possiblePositions; possibleTargets = skill.possibleTargets; SkillEffects = skill.SkillEffects; RemainingCooldown = skill.RemainingCooldown; }
private async Task <IDeploymentSlot> FindOrCreateSlot(IWebApp client, TargetSite site) { Log.Verbose($"Checking if slot {site.Slot} exists"); var slot = await client.DeploymentSlots.GetByNameAsync(site.Slot); if (slot != null) { Log.Verbose($"Found existing slot {site.Slot}"); return(slot); } Log.Verbose($"Slot {site.Slot} not found"); Log.Info($"Creating slot {site.Slot}"); return(await client.DeploymentSlots .Define(site.Slot) .WithConfigurationFromParent() .CreateAsync()); }
public static async Task <StringDictionary> UpdateApplicationSettingsAsync(this IWebAppsOperations operations, TargetSite targetSite, StringDictionary appSettings, CancellationToken cancellationToken = default) { if (targetSite.HasSlot) { using var operationResponse = await operations.UpdateApplicationSettingsSlotWithHttpMessagesAsync( targetSite.ResourceGroupName, targetSite.Site, appSettings, targetSite.Slot, cancellationToken : cancellationToken); return(operationResponse.Body); } else { using var operationResponse = await operations .UpdateApplicationSettingsWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, appSettings, cancellationToken : cancellationToken).ConfigureAwait(false); return(operationResponse.Body); } }
public static async Task UpdateConnectionStringsAsync(this IWebAppsOperations operations, TargetSite targetSite, ConnectionStringDictionary connectionStringDictionary, CancellationToken cancellationToken = default) { if (targetSite.HasSlot) { await operations.UpdateConnectionStringsSlotWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, connectionStringDictionary, targetSite.Slot, cancellationToken : cancellationToken); } else { await operations.UpdateConnectionStringsWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, connectionStringDictionary, cancellationToken : cancellationToken); } }
public override string ToString() { string res = Source + "MutualExclusionException : " + meeMessage + " at " + TargetSite.ToString(); return(res); }
protected internal CbApi(string key, int timeout, TargetSite site) { _Settings.TargetSite = site; _Settings.DevKey = key; _Settings.TimeoutMS = timeout; }
public static async Task PutAppSettingsAsync(WebSiteManagementClient webAppClient, StringDictionary appSettings, TargetSite targetSite) { await webAppClient.WebApps.UpdateApplicationSettingsAsync(targetSite, appSettings); }
public static async Task PutSlotSettingsListAsync(WebSiteManagementClient webAppClient, TargetSite targetSite, IEnumerable <string> slotConfigNames, string authToken) { var client = webAppClient.HttpClient; client.DefaultRequestHeaders.Clear(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authToken); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var targetUrl = $"https://management.azure.com/subscriptions/{webAppClient.SubscriptionId}/resourceGroups/{targetSite.ResourceGroupName}/providers/Microsoft.Web/sites/{targetSite.Site}/config/slotconfignames?api-version=2018-11-01"; var slotSettingsJson = new appSettingNamesRoot { properties = new properties { appSettingNames = slotConfigNames }, name = targetSite.Site }; var postBody = JsonConvert.SerializeObject(slotSettingsJson); //var body = new StringContent(postBody); var body = new StringContent(postBody, Encoding.UTF8, "application/json"); var response = await client.PutAsync(targetUrl, body); if (!response.IsSuccessStatusCode) { throw new HttpRequestException(response.ReasonPhrase); } }
public static async Task <IEnumerable <string> > GetSlotSettingsListAsync(WebSiteManagementClient webAppClient, string authToken, TargetSite targetSite) { var client = webAppClient.HttpClient; client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authToken); var targetUrl = $"{client.BaseAddress}/subscriptions/{webAppClient.SubscriptionId}/resourceGroups/{targetSite.ResourceGroupName}/providers/Microsoft.Web/sites/{targetSite.Site}/config/slotconfignames?api-version=2018-11-01"; var results = await client.GetStringAsync(targetUrl); var output = JsonConvert.DeserializeObject <appSettingNamesRoot>(results).properties.appSettingNames ?? new List <string>(); return(output); }
public static async Task <IEnumerable <AppSetting> > GetAppSettingsAsync(WebSiteManagementClient webAppClient, string authToken, TargetSite targetSite) { var webAppSettings = await webAppClient.WebApps.ListApplicationSettingsAsync(targetSite); var slotSettings = (await GetSlotSettingsListAsync(webAppClient, authToken, targetSite)).ToArray(); return(webAppSettings.Properties.Select( setting => new AppSetting { Name = setting.Key, Value = setting.Value, SlotSetting = slotSettings.Any(x => x == setting.Key) }).ToList()); }
private async Task PublishConnectionStrings(WebSiteManagementClient webAppClient, TargetSite targetSite, ConnectionStringSetting[] newConStrings) { var conStrings = await AppSettingsManagement.GetConnectionStringsAsync(webAppClient, targetSite); foreach (var connectionStringSetting in newConStrings) { conStrings.Properties[connectionStringSetting.Name] = new ConnStringValueTypePair(connectionStringSetting.Value, connectionStringSetting.Type); } await webAppClient.WebApps.UpdateConnectionStringsAsync(targetSite, conStrings); }
protected abstract string InternalHandler(HttpContext context, TargetSite target, string targetRootDir, string requestedPath, ViewModel vm);
public static async Task UpdateConfigurationAsync(this IWebAppsOperations operations, TargetSite targetSite, SiteConfigResource config, CancellationToken cancellationToken = default) { if (targetSite.HasSlot) { await operations.UpdateConfigurationSlotWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, config, targetSite.Slot, cancellationToken : cancellationToken); } else { await operations.UpdateConfigurationWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.ScmSiteAndSlot, config, cancellationToken : cancellationToken); } }
public static ICBApi GetInstance(string developerKey, int timeoutMS, TargetSite site) { return(new CbApi(developerKey, timeoutMS, site)); }
public static async Task <ConnectionStringDictionary> ListConnectionStringsAsync(this IWebAppsOperations operations, TargetSite targetSite, CancellationToken cancellationToken = default) { ConnectionStringDictionary body; if (targetSite.HasSlot) { var response = await operations.ListConnectionStringsSlotWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, targetSite.Slot, cancellationToken : cancellationToken).ConfigureAwait(false); body = response.Body; } else { var response = await operations.ListConnectionStringsWithHttpMessagesAsync(targetSite.ResourceGroupName, targetSite.Site, cancellationToken : cancellationToken).ConfigureAwait(false); body = response.Body; } return(body); }
} //dont like this, otherwise immutable object made mutable. //infact its responsible for a bug. //decorator? public object InvokedOn(object target) { return(TargetSite.Invoke(target, Arguments.ToArray())); }