actions/runner
1
0
Fork 0
mirror of https://github.com/actions/runner.git synced 2026-01-04 00:49:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

GitHub Actions Runner

Browse Source
This commit is contained in:
Tingluo Huang
2019-10-10 00:52:42 -04:00
commit c8afc84840
1255 changed files with 198670 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

318
src/Sdk/DTWebApi/WebApi/VariableGroupUtility.cs Normal file
View File

@@ -0,0 +1,318 @@
using System;
using System.Collections.Generic;
using System.Linq;
using GitHub.Services.WebApi;
namespace GitHub.DistributedTask.WebApi
{
/// <summary>
/// Utility class to perform operations on Variable groups.
/// </summary>
public static class VariableGroupUtility
{
public static VariableValue Clone(this VariableValue value)
{
if (keyVaultVariableType == value.GetType())
{
return new AzureKeyVaultVariableValue((AzureKeyVaultVariableValue)value);
}
return new VariableValue(value);
}
public static void PopulateVariablesAndProviderData(this VariableGroup group, String variablesJson, String providerDataJson)
{
switch (group.Type)
{
case VariableGroupType.Vsts:
if (variablesJson != null)
{
group.Variables = JsonUtility.FromString<IDictionary<String, VariableValue>>(variablesJson);
}
if (providerDataJson != null)
{
group.ProviderData = JsonUtility.FromString<VariableGroupProviderData>(providerDataJson);
}
break;
case VariableGroupType.AzureKeyVault:
if (variablesJson != null)
{
var azureKeyVaultVariableValues = JsonUtility.FromString<IDictionary<String, AzureKeyVaultVariableValue>>(variablesJson);
if (azureKeyVaultVariableValues != null)
{
foreach (var azureKeyVaultVariableValue in azureKeyVaultVariableValues)
{
group.Variables[azureKeyVaultVariableValue.Key] = azureKeyVaultVariableValue.Value;
}
}
}
if (providerDataJson != null)
{
group.ProviderData = JsonUtility.FromString<AzureKeyVaultVariableGroupProviderData>(providerDataJson);
}
break;
}
}
public static void PopulateVariablesAndProviderData(this VariableGroupParameters variableGroupParameters, String variablesJson, String providerDataJson)
{
switch (variableGroupParameters.Type)
{
case VariableGroupType.Vsts:
if (variablesJson != null)
{
variableGroupParameters.Variables = JsonUtility.FromString<IDictionary<String, VariableValue>>(variablesJson);
}
if (providerDataJson != null)
{
variableGroupParameters.ProviderData = JsonUtility.FromString<VariableGroupProviderData>(providerDataJson);
}
break;
case VariableGroupType.AzureKeyVault:
if (variablesJson != null)
{
var azureKeyVaultVariableValues = JsonUtility.FromString<IDictionary<String, AzureKeyVaultVariableValue>>(variablesJson);
if (azureKeyVaultVariableValues != null)
{
foreach (var azureKeyVaultVariableValue in azureKeyVaultVariableValues)
{
variableGroupParameters.Variables[azureKeyVaultVariableValue.Key] = azureKeyVaultVariableValue.Value;
}
}
}
if (providerDataJson != null)
{
variableGroupParameters.ProviderData = JsonUtility.FromString<AzureKeyVaultVariableGroupProviderData>(providerDataJson);
}
break;
}
}
/// <summary>
/// Get list of cloned variable groups
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static IList<VariableGroup> CloneVariableGroups(IList<VariableGroup> source)
{
var clonedVariableGroups = new List<VariableGroup>();
if (source == null)
{
return clonedVariableGroups;
}
foreach (var group in source)
{
if (group != null)
{
clonedVariableGroups.Add(group.Clone());
}
}
return clonedVariableGroups;
}
/// <summary>
/// Replace secret values in group variables with null
/// </summary>
/// <param name="variableGroups">Variable groups to be cleared for secret variables</param>
/// <returns>List of cleared variable groups</returns>
public static IList<VariableGroup> ClearSecrets(IList<VariableGroup> variableGroups)
{
var groups = new List<VariableGroup>();
if (variableGroups == null)
{
return groups;
}
foreach (var group in variableGroups)
{
if (group != null)
{
var clearedGroup = group.Clone();
// Replacing secret variable's value with null
foreach (var variable in clearedGroup.Variables)
{
if (variable.Value != null && variable.Value.IsSecret)
{
variable.Value.Value = null;
}
}
groups.Add(clearedGroup);
}
}
return groups;
}
/// <summary>
/// Replace all secrets in variables with null
/// </summary>
/// <param name="variables">Variable set</param>
/// <returns>Dictionary of variables</returns>
public static IDictionary<String, VariableValue> ClearSecrets(IDictionary<String, VariableValue> variables)
{
var dictionary = new Dictionary<String, VariableValue>(StringComparer.OrdinalIgnoreCase);
if (variables == null)
{
return dictionary;
}
foreach (var kvp in variables)
{
if (kvp.Value != null)
{
var clonedValue = kvp.Value.Clone();
if (kvp.Value.IsSecret)
{
clonedValue.Value = null;
}
dictionary[kvp.Key] = clonedValue;
}
}
return dictionary;
}
/// <summary>
/// Check if any variable group has variable with secret value
/// </summary>
/// <param name="variableGroups">Variable groups to check if contains any secret variable with value.</param>
/// <returns>Result</returns>
public static bool HasSecretWithValue(IList<VariableGroup> variableGroups)
{
if (variableGroups == null || variableGroups.Count == 0)
{
return false;
}
foreach (var group in variableGroups)
{
if (group != null && HasSecretWithValue(group.Variables))
{
return true;
}
}
return false;
}
/// <summary>
/// Check if Variables has any secret value
/// </summary>
/// <param name="variables">Variable set to check for any secret value</param>
/// <returns></returns>
public static bool HasSecretWithValue(IDictionary<String, VariableValue> variables)
{
if (variables == null || variables.Count == 0)
{
return false;
}
return variables.Any(s => s.Value != null &&
s.Value.IsSecret &&
!String.IsNullOrEmpty(s.Value.Value));
}
/// <summary>
/// Check if any secret variable exists in variable group
/// </summary>
/// <param name="variableGroups">Variable groups to check if contains any secret variable</param>
/// <returns>Result</returns>
public static bool HasSecret(IList<VariableGroup> variableGroups)
{
if (variableGroups == null || variableGroups.Count == 0)
{
return false;
}
foreach (var group in variableGroups)
{
if (group != null && HasSecret(group.Variables))
{
return true;
}
}
return false;
}
/// <summary>
/// Check if variable set contains any secret variable
/// </summary>
/// <param name="variables">Variable set to be checked for secret variable</param>
/// <returns></returns>
public static bool HasSecret(IDictionary<String, VariableValue> variables)
{
if (variables != null)
{
return variables.Any(v => v.Value != null && v.Value.IsSecret);
}
return false;
}
/// <summary>
/// Copies secrets from source variable groups to target variable groups
/// </summary>
/// <param name="sourceGroups">Source variable groups</param>
/// <param name="targetGroups">Target variable groups</param>
/// <returns></returns>
public static void FillSecrets(
IList<VariableGroup> sourceGroups,
IList<VariableGroup> targetGroups)
{
if (sourceGroups == null || sourceGroups.Count == 0)
{
return;
}
if (targetGroups == null)
{
throw new ArgumentNullException("targetGroups");
}
foreach (var sourceGroup in sourceGroups)
{
var targetGroup = targetGroups.FirstOrDefault(group => group.Id == sourceGroup.Id);
if (targetGroup != null)
{
if (sourceGroup.Variables == null || sourceGroup.Variables.Count == 0)
{
// nothing to fill
continue;
}
if (targetGroup.Variables == null)
{
throw new ArgumentNullException(nameof(targetGroup.Variables));
}
foreach (var variable in sourceGroup.Variables.Where(x => x.Value.IsSecret))
{
targetGroup.Variables[variable.Key] = variable.Value.Clone();
}
}
}
}
private static Type keyVaultVariableType = typeof(AzureKeyVaultVariableValue);
}
}