private static async Task <int> ExecuteCommand(TrustCommand action,
CommandOption algorithm,
bool allowUntrustedRootOption,
CommandOption owners,
CommandOption verbosity,
CommandOption configFile,
Func <ILogger> getLogger,
Action <LogLevel> setLogLevel,
string name = null,
string sourceUrl = null,
string packagePath = null,
string fingerprint = null)
{
ILogger logger = getLogger();
try
{
ISettings settings = XPlatUtility.ProcessConfigFile(configFile.Value());
var trustedSignersArgs = new TrustedSignersArgs()
{
Action = MapTrustEnumAction(action),
PackagePath = packagePath,
Name = name,
ServiceIndex = sourceUrl,
CertificateFingerprint = fingerprint,
FingerprintAlgorithm = algorithm?.Value(),
AllowUntrustedRoot = allowUntrustedRootOption,
Author = action == TrustCommand.Author,
Repository = action == TrustCommand.Repository,
Owners = CommandLineUtility.SplitAndJoinAcrossMultipleValues(owners?.Values),
Logger = logger
};
setLogLevel(XPlatUtility.MSBuildVerbosityToNuGetLogLevel(verbosity.Value()));
// Add is the only action which does certificate chain building.
if (trustedSignersArgs.Action == TrustedSignersAction.Add)
{
X509TrustStore.InitializeForDotNetSdk(logger);
}
#pragma warning disable CS0618 // Type or member is obsolete
var sourceProvider = new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false);
#pragma warning restore CS0618 // Type or member is obsolete
var trustedSignersProvider = new TrustedSignersProvider(settings);
var runner = new TrustedSignersCommandRunner(trustedSignersProvider, sourceProvider);
Task <int> trustedSignTask = runner.ExecuteCommandAsync(trustedSignersArgs);
return(await trustedSignTask);
}
catch (InvalidOperationException e)
{
// nuget trust command handled exceptions.
if (!string.IsNullOrWhiteSpace(name))
{
var error_TrustedSignerAlreadyExistsMessage = string.Format(CultureInfo.CurrentCulture, Strings.Error_TrustedSignerAlreadyExists, name);
if (e.Message == error_TrustedSignerAlreadyExistsMessage)
{
logger.LogError(error_TrustedSignerAlreadyExistsMessage);
return(1);
}
}
if (!string.IsNullOrWhiteSpace(sourceUrl))
{
var error_TrustedRepoAlreadyExists = string.Format(CultureInfo.CurrentCulture, Strings.Error_TrustedRepoAlreadyExists, sourceUrl);
if (e.Message == error_TrustedRepoAlreadyExists)
{
logger.LogError(error_TrustedRepoAlreadyExists);
return(1);
}
}
throw;
}
catch (ArgumentException e)
{
if (e.Data is System.Collections.IDictionary)
{
logger.LogError(string.Format(CultureInfo.CurrentCulture, Strings.Error_TrustFingerPrintAlreadyExist));
return(1);
}
throw;
}
}
internal static void Register(CommandLineApplication app,
Func <ILogger> getLogger,
Action <LogLevel> setLogLevel,
Func <IVerifyCommandRunner> getCommandRunner)
{
app.Command("verify", verifyCmd =>
{
CommandArgument packagePaths = verifyCmd.Argument(
"<package-paths>",
Strings.VerifyCommandPackagePathDescription,
multipleValues: true);
CommandOption all = verifyCmd.Option(
"--all",
Strings.VerifyCommandAllDescription,
CommandOptionType.NoValue);
CommandOption fingerPrint = verifyCmd.Option(
"--certificate-fingerprint",
Strings.VerifyCommandCertificateFingerprintDescription,
CommandOptionType.MultipleValue);
CommandOption configFile = verifyCmd.Option(
"--configfile",
Strings.Option_ConfigFile,
CommandOptionType.SingleValue);
CommandOption verbosity = verifyCmd.Option(
"-v|--verbosity",
Strings.Verbosity_Description,
CommandOptionType.SingleValue);
verifyCmd.HelpOption(XPlatUtility.HelpOption);
verifyCmd.Description = Strings.VerifyCommandDescription;
verifyCmd.OnExecute(async() =>
{
ValidatePackagePaths(packagePaths);
VerifyArgs args = new VerifyArgs();
args.PackagePaths = packagePaths.Values;
args.Verifications = all.HasValue() ?
new List <Verification>()
{
Verification.All
} :
new List <Verification>()
{
Verification.Signatures
};
args.CertificateFingerprint = fingerPrint.Values;
args.Logger = getLogger();
args.Settings = XPlatUtility.ProcessConfigFile(configFile.Value());
setLogLevel(XPlatUtility.MSBuildVerbosityToNuGetLogLevel(verbosity.Value()));
X509TrustStore.InitializeForDotNetSdk(args.Logger);
var runner = getCommandRunner();
var verifyTask = runner.ExecuteCommandAsync(args);
await verifyTask;
return(verifyTask.Result);
});
});
}