// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using OpenTap.Cli;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Threading;
|
using OpenTap.Authentication;
|
|
namespace OpenTap.Package
|
{
|
/// <summary>
|
/// Indicates a well defined action to be performed on a package.
|
/// A number of common actions are <see cref="PackageInstallAction"/>, <see cref="PackageUninstallAction"/>, and <see cref="PackageDownloadAction"/>.
|
/// Deriving from this, and annotating the class and any public properties with <see cref="CommandLineArgumentAttribute"/> and <see cref="UnnamedCommandLineArgument"/> attributes
|
/// will allow it to be called from the OpenTAP.Package CLI.
|
/// </summary>
|
public abstract class PackageAction : ICliAction
|
{
|
/// <summary> Log source for PackageAction plugins. </summary>
|
protected static TraceSource log = OpenTap.Log.CreateSource("PackageAction");
|
|
/// <summary>
|
/// A delegate used by <see cref="ProgressUpdate"/>
|
/// </summary>
|
/// <param name="progressPercent">Indicates progress from 0 to 100.</param>
|
/// <param name="message"></param>
|
public delegate void ProgressUpdateDelegate(int progressPercent, string message);
|
/// <summary>
|
/// Called by the action to indicate how far it has gotten. Will usually be called with a progressPercent of 100 to indicate that it is done.
|
/// </summary>
|
public event ProgressUpdateDelegate ProgressUpdate;
|
|
/// <summary>
|
/// A delegate type used by the <see cref="Error"/> event.
|
/// </summary>
|
/// <param name="ex"></param>
|
public delegate void ErrorDelegate(Exception ex);
|
/// <summary>
|
/// Called when a critical error happens.
|
/// </summary>
|
public event ErrorDelegate Error;
|
|
/// <summary>
|
/// Call this to raise the <see cref="Error"/> event.
|
/// </summary>
|
/// <param name="ex"></param>
|
protected void RaiseError(Exception ex)
|
{
|
if (Error != null)
|
Error(ex);
|
}
|
|
/// <summary>
|
/// Call this to raise the <see cref="ProgressUpdate"/> event.
|
/// </summary>
|
/// <param name="progressPercent"></param>
|
/// <param name="message"></param>
|
protected void RaiseProgressUpdate(int progressPercent, string message)
|
{
|
if (ProgressUpdate != null)
|
ProgressUpdate(progressPercent, message);
|
}
|
|
/// <summary>
|
/// The code to be executed by the action.
|
/// </summary>
|
/// <returns>Return 0 to indicate success. Otherwise return a custom errorcode that will be set as the exitcode from the CLI.</returns>
|
public abstract int Execute(CancellationToken cancellationToken);
|
|
internal string[] ExtractRepositoryTokens(string[] repositories, bool saveSettings)
|
{
|
if (repositories == null) return null;
|
// Repositories can have additional arguments appended as key-value-pairs.
|
// Currently, the only supported key is 'token=<repo token>'
|
// The goal here is the following:
|
// 1. Extract the tokens
|
// 2. Add them to AuthenticationSettings
|
// 3. Save the updated settings if needed and requested
|
// 4. Return the list of repositories without the kvps
|
var result = new string[repositories.Length];
|
bool tokenAdded = false;
|
|
for (int i = 0; i < repositories.Length; i++)
|
{
|
var argument = repositories[i];
|
|
var parts = argument.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
|
var repo = parts[0];
|
string token = null;
|
|
for (int j = 1; j < parts.Length; j++)
|
{
|
var part = parts[j];
|
// A user token could contain an equal sign. It should be fine if we just use the first equal
|
// sign as a pivot. This is also the way environment variables are handled on Unix systems.
|
var pivot = part.IndexOf('=');
|
if (pivot == -1)
|
{
|
log.Warning($"Missing '=' sign in key-value-pair '{part}'. This value will be ignored.");
|
continue;
|
}
|
|
var key = part.Substring(0, pivot);
|
var value = part.Substring(pivot + 1);
|
switch (key)
|
{
|
case "token":
|
token = value;
|
break;
|
default:
|
log.Warning(
|
$"Unrecognized key '{key}' specified in repository argument '{argument}'. This value will be ignored.");
|
break;
|
}
|
}
|
|
// Only accepts tokens for http repositories
|
var repoType = PackageRepositoryHelpers.DetermineRepositoryType(repo);
|
if (repoType is HttpPackageRepository && Uri.TryCreate(repoType.Url, UriKind.Absolute, out var uri))
|
{
|
repo = repoType.Url;
|
// Add the specified token to the current authentication settings
|
if (token != null)
|
{
|
tokenAdded = true;
|
// If a token is already configured for this repo, update it
|
if (AuthenticationSettings.Current.Tokens.FirstOrDefault(t => t.Domain.Equals(uri.Authority)) is
|
TokenInfo t)
|
{
|
t.AccessToken = token;
|
}
|
// Otherwise, add it
|
else
|
{
|
AuthenticationSettings.Current.Tokens.Add(new TokenInfo(token, null, uri.Authority));
|
}
|
}
|
}
|
|
result[i] = repo;
|
}
|
|
if (saveSettings && tokenAdded)
|
{
|
try
|
{
|
AuthenticationSettings.Current.Save();
|
}
|
catch (Exception e)
|
{
|
log.Warning($"Error saving credentials: '{e.Message}");
|
log.Debug(e);
|
}
|
}
|
|
return result;
|
}
|
}
|
|
internal static class PackageActionHelper
|
{
|
private readonly static TraceSource log = OpenTap.Log.CreateSource("PackageAction");
|
|
/// <summary>
|
/// Logs the assembly name and version then executes the action with the given parameters.
|
/// </summary>
|
/// <param name="action">The oackage action to be executed.</param>
|
/// <param name="parameters">The parameters for the action.</param>
|
/// <returns>Return 0 to indicate success. Otherwise return a custom errorcode that will be set as the exitcode from the CLI.</returns>
|
public static int Execute(this PackageAction action, string[] parameters)
|
{
|
action.LogAssemblyNameAndVersion();
|
ICliAction cliAction = action;
|
return cliAction.PerformExecute(parameters);
|
}
|
|
public static List<PackageDef> FilterPreRelease(this List<PackageDef> packages, string PreRelease)
|
{
|
if (PreRelease != null)
|
packages = packages.Where(p => (p.Version.PreRelease ?? "").ToLower() == (PreRelease ?? "").ToLower()).ToList();
|
else
|
{
|
var filteredPackages = new List<PackageDef>();
|
var packageGroups = packages.GroupBy(p => p.Name);
|
foreach (var item in packageGroups)
|
{
|
if (item.Any(p => string.IsNullOrEmpty(p.Version.PreRelease)))
|
filteredPackages.AddRange(item.Where(p => string.IsNullOrEmpty(p.Version.PreRelease)));
|
else
|
filteredPackages.AddRange(item);
|
}
|
|
packages = filteredPackages;
|
}
|
|
return packages;
|
}
|
|
private static void LogAssemblyNameAndVersion(this PackageAction action)
|
{
|
log.Debug("{0} version {1}", typeof(Installer).Assembly.GetName().Name, typeof(Installer).Assembly.GetName().Version.ToString(3));
|
}
|
}
|
}
|
