/// <summary>
/// Parses sleet.json to find the source and constructs it.
/// </summary>
public static ISleetFileSystem CreateFileSystem(LocalSettings settings, LocalCache cache, string source)
{
ISleetFileSystem result = null;
var sources = settings.Json["sources"] as JArray;
if (sources == null)
{
throw new ArgumentException("Invalid config. No sources found.");
}
if (sources != null)
{
foreach (var sourceEntry in sources)
{
if (source.Equals(sourceEntry["name"]?.ToObject <string>(), StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrEmpty(sourceEntry["path"]?.ToString()))
{
throw new ArgumentException("Missing path for account.");
}
var path = sourceEntry["path"]?.ToObject <string>();
var baseURI = sourceEntry["baseURI"]?.ToObject <string>() ?? path;
var feedSubPath = sourceEntry["feedSubPath"]?.ToObject <string>();
var type = sourceEntry["type"]?.ToObject <string>().ToLowerInvariant();
if (type == "local")
{
result = new PhysicalFileSystem(cache, UriUtility.CreateUri(path), UriUtility.CreateUri(baseURI));
}
else if (type == "azure")
{
var connectionString = sourceEntry["connectionString"]?.ToObject <string>();
var container = sourceEntry["container"]?.ToObject <string>();
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentException("Missing connectionString for azure account.");
}
if (connectionString.Equals(AzureFileSystem.AzureEmptyConnectionString, StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("Invalid connectionString for azure account.");
}
if (string.IsNullOrEmpty(container))
{
throw new ArgumentException("Missing container for azure account.");
}
var azureAccount = CloudStorageAccount.Parse(connectionString);
result = new AzureFileSystem(cache, UriUtility.CreateUri(path), UriUtility.CreateUri(baseURI), azureAccount, container, feedSubPath);
}
#if !SLEETLEGACY
else if (type == "s3")
{
string accessKeyId = sourceEntry["accessKeyId"]?.ToObject <string>();
string secretAccessKey = sourceEntry["secretAccessKey"]?.ToObject <string>();
string bucketName = sourceEntry["bucketName"]?.ToObject <string>();
string region = sourceEntry["region"]?.ToObject <string>();
if (string.IsNullOrEmpty(accessKeyId))
{
throw new ArgumentException("Missing accessKeyId for Amazon S3 account.");
}
if (string.IsNullOrEmpty(secretAccessKey))
{
throw new ArgumentException("Missing secretAccessKey for Amazon S3 account.");
}
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentException("Missing bucketName for Amazon S3 account.");
}
if (string.IsNullOrEmpty(region))
{
throw new ArgumentException("Missing region for Amazon S3 account.");
}
var amazonS3Client = new AmazonS3Client(
accessKeyId, secretAccessKey, RegionEndpoint.GetBySystemName(region));
result = new AmazonS3FileSystem(
cache,
UriUtility.CreateUri(path),
UriUtility.CreateUri(baseURI),
amazonS3Client,
bucketName,
feedSubPath);
}
#endif
}
}
}
return(result);
}
public AmazonS3FileSystem(LocalCache cache, Uri root, IAmazonS3 client, string bucketName)
: this(cache, root, root, client, bucketName, ServerSideEncryptionMethod.None)
{
}
private ISleetFile CreateAmazonS3File(SleetUriPair pair)
{
var key = GetRelativePath(pair.Root);
return(new AmazonS3File(this, pair.Root, pair.BaseURI, LocalCache.GetNewTempPath(), _client, _bucketName, key, _serverSideEncryptionMethod, _compress));
}
internal static ISleetFileSystem CreateFileSystemOrThrow(LocalSettings settings, string sourceName, LocalCache cache)
{
var sourceNamePassed = !string.IsNullOrEmpty(sourceName);
// Default to the only possible feed if one was not provided.
if (string.IsNullOrEmpty(sourceName))
{
var names = GetSourceNames(settings.Json);
if (names.Count == 1)
{
sourceName = names[0];
}
}
var fileSystem = FileSystemFactory.CreateFileSystem(settings, cache, sourceName);
if (fileSystem == null)
{
var message = "Unable to find source. Verify that the --source parameter is correct and that sleet.json contains the named source.";
if (!sourceNamePassed)
{
var names = GetSourceNames(settings.Json);
if (names.Count < 1)
{
message = "The local settings file is missing or does not contain any sources. Use 'CreateConfig' to add a source.";
}
else
{
message = "The local settings file contains multiple sources. Use --source to specify the feed to use.";
}
}
throw new InvalidOperationException(message);
}
return(fileSystem);
}
public static async Task <bool> RunAsync(LocalSettings settings, ISleetFileSystem source, string tmpPath, bool force, ILogger log)
{
var success = true;
var cleanNupkgs = true;
var token = CancellationToken.None;
LocalCache localCache = null;
// Use the tmp path if provided
if (string.IsNullOrEmpty(tmpPath))
{
localCache = new LocalCache();
}
else
{
localCache = new LocalCache(tmpPath);
}
log.LogMinimal($"Reading feed {source.BaseURI.AbsoluteUri}");
using (var feedLock = await SourceUtility.VerifyInitAndLock(settings, source, "Recreate", log, token))
{
if (!force)
{
// Validate source
await UpgradeUtility.EnsureCompatibility(source, log : log, token : token);
}
// Read settings and persist them in the new feed.
var feedSettings = await FeedSettingsUtility.GetSettingsOrDefault(source, log, token);
try
{
var downloadSuccess = await DownloadCommand.DownloadPackages(settings, source, localCache.Root.FullName, force, log, token);
if (!force && !downloadSuccess)
{
log.LogError("Unable to recreate the feed due to errors download packages. Use --force to skip this check.");
return(false);
}
var destroySuccess = await DestroyCommand.Destroy(settings, source, log, token);
if (!force && !destroySuccess)
{
log.LogError("Unable to completely remove the old feed before recreating. Use --force to skip this check.");
return(false);
}
var initSuccess = await InitCommand.InitAsync(settings, source, feedSettings, log, token);
if (!initSuccess)
{
cleanNupkgs = false;
log.LogError("Unable to initialize the new feed. The feed is currently broken and must be repaired manually.");
success = false;
return(false);
}
// Apply settings
await ApplySettingHandlers(settings, source, log, feedSettings, token);
// Skip pushing for empty feeds
if (Directory.GetFiles(localCache.Root.FullName, "*.*", SearchOption.AllDirectories).Length > 0)
{
var pushSuccess = await PushCommand.PushPackages(settings, source, new List <string>() { localCache.Root.FullName }, force : true, skipExisting : true, log : log, token : token);
if (!pushSuccess)
{
cleanNupkgs = false;
log.LogError("Unable to push packages to the new feed. Try pushing the nupkgs again manually.");
success = false;
return(false);
}
}
var validateSuccess = await ValidateCommand.Validate(settings, source, log, token);
if (!validateSuccess)
{
cleanNupkgs = false;
log.LogError("Something went wrong when recreating the feed. Feed validation has failed.");
success = false;
return(false);
}
}
finally
{
if (cleanNupkgs)
{
// Delete downloaded nupkgs
log.LogInformation($"Removing local nupkgs from {localCache.Root.FullName}");
localCache.Dispose();
}
else
{
var message = $"Encountered an error while recreating the feed. You may need to manually create the feed and push the nupkgs again. Nupkgs have been saved to: {localCache.Root.FullName}";
if (force)
{
log.LogWarning(message);
}
else
{
log.LogError(message);
}
}
}
log.LogMinimal("Feed recreation complete.");
}
return(success);
}
public AzureFileSystem(LocalCache cache, Uri root, CloudStorageAccount azureAccount, string container)
: this(cache, root, root, azureAccount, container)
{
}
public AmazonS3FileSystem(LocalCache cache, Uri root, IAmazonS3 client, string bucketName)
: this(cache, root, root, client, bucketName)
{
}
public PhysicalFileSystem(LocalCache cache, Uri root)
: this(cache, root, root)
{
}
/// <summary>
/// Parses sleet.json to find the source and constructs it.
/// </summary>
public static async Task <ISleetFileSystem> CreateFileSystemAsync(LocalSettings settings, LocalCache cache, string source)
{
ISleetFileSystem result = null;
var sources = settings.Json["sources"] as JArray;
if (sources == null)
{
throw new ArgumentException("Invalid config. No sources found.");
}
foreach (var sourceEntry in sources.Select(e => (JObject)e))
{
var sourceName = JsonUtility.GetValueCaseInsensitive(sourceEntry, "name");
if (source.Equals(sourceName, StringComparison.OrdinalIgnoreCase))
{
var path = JsonUtility.GetValueCaseInsensitive(sourceEntry, "path");
var baseURIString = JsonUtility.GetValueCaseInsensitive(sourceEntry, "baseURI");
var feedSubPath = JsonUtility.GetValueCaseInsensitive(sourceEntry, "feedSubPath");
var type = JsonUtility.GetValueCaseInsensitive(sourceEntry, "type")?.ToLowerInvariant();
string absolutePath;
if (path != null && type == "local")
{
if (settings.Path == null && !Path.IsPathRooted(NuGetUriUtility.GetLocalPath(path)))
{
throw new ArgumentException("Cannot use a relative 'path' without a sleet.json file.");
}
var nonEmptyPath = path == "" ? "." : path;
var absoluteSettingsPath = NuGetUriUtility.GetAbsolutePath(Directory.GetCurrentDirectory(), settings.Path);
var settingsDir = Path.GetDirectoryName(absoluteSettingsPath);
absolutePath = NuGetUriUtility.GetAbsolutePath(settingsDir, nonEmptyPath);
}
else
{
absolutePath = path;
}
var pathUri = absolutePath != null?UriUtility.EnsureTrailingSlash(UriUtility.CreateUri(absolutePath)) : null;
var baseUri = baseURIString != null?UriUtility.EnsureTrailingSlash(UriUtility.CreateUri(baseURIString)) : pathUri;
if (type == "local")
{
if (pathUri == null)
{
throw new ArgumentException("Missing path for account.");
}
result = new PhysicalFileSystem(cache, pathUri, baseUri);
}
else if (type == "azure")
{
var connectionString = JsonUtility.GetValueCaseInsensitive(sourceEntry, "connectionString");
var container = JsonUtility.GetValueCaseInsensitive(sourceEntry, "container");
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentException("Missing connectionString for azure account.");
}
if (connectionString.Equals(AzureFileSystem.AzureEmptyConnectionString, StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("Invalid connectionString for azure account.");
}
if (string.IsNullOrEmpty(container))
{
throw new ArgumentException("Missing container for azure account.");
}
var azureAccount = CloudStorageAccount.Parse(connectionString);
if (pathUri == null)
{
// Get the default url from the container
pathUri = AzureUtility.GetContainerPath(azureAccount, container);
}
if (baseUri == null)
{
baseUri = pathUri;
}
result = new AzureFileSystem(cache, pathUri, baseUri, azureAccount, container, feedSubPath);
}
#if !SLEETLEGACY
else if (type == "s3")
{
var profileName = JsonUtility.GetValueCaseInsensitive(sourceEntry, "profileName");
var accessKeyId = JsonUtility.GetValueCaseInsensitive(sourceEntry, "accessKeyId");
var secretAccessKey = JsonUtility.GetValueCaseInsensitive(sourceEntry, "secretAccessKey");
var bucketName = JsonUtility.GetValueCaseInsensitive(sourceEntry, "bucketName");
var region = JsonUtility.GetValueCaseInsensitive(sourceEntry, "region");
var serviceURL = JsonUtility.GetValueCaseInsensitive(sourceEntry, "serviceURL");
var compress = JsonUtility.GetBoolCaseInsensitive(sourceEntry, "compress", true);
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentException("Missing bucketName for Amazon S3 account.");
}
if (string.IsNullOrEmpty(region) && string.IsNullOrEmpty(serviceURL))
{
throw new ArgumentException("Either 'region' or 'serviceURL' must be specified for an Amazon S3 account");
}
if (!string.IsNullOrEmpty(region) && !string.IsNullOrEmpty(serviceURL))
{
throw new ArgumentException("Options 'region' and 'serviceURL' cannot be used together");
}
AmazonS3Config config = null;
if (serviceURL != null)
{
config = new AmazonS3Config()
{
ServiceURL = serviceURL,
ProxyCredentials = CredentialCache.DefaultNetworkCredentials
};
}
else
{
config = new AmazonS3Config()
{
RegionEndpoint = RegionEndpoint.GetBySystemName(region),
ProxyCredentials = CredentialCache.DefaultNetworkCredentials
};
}
AmazonS3Client amazonS3Client = null;
// Load credentials from the current profile
if (!string.IsNullOrWhiteSpace(profileName))
{
var credFile = new SharedCredentialsFile();
if (credFile.TryGetProfile(profileName, out var profile))
{
amazonS3Client = new AmazonS3Client(profile.GetAWSCredentials(profileSource: null), config);
}
else
{
throw new ArgumentException($"The specified AWS profileName {profileName} could not be found. The feed must specify a valid profileName for an AWS credentials file. For help on credential files see: https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/net-dg-config-creds.html#creds-file");
}
}
// Load credentials explicitly with an accessKey and secretKey
else if (
!string.IsNullOrWhiteSpace(accessKeyId) &&
!string.IsNullOrWhiteSpace(secretAccessKey))
{
amazonS3Client = new AmazonS3Client(new BasicAWSCredentials(accessKeyId, secretAccessKey), config);
}
// Load credentials from Environment Variables
else if (
!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(EnvironmentVariablesAWSCredentials.ENVIRONMENT_VARIABLE_ACCESSKEY)) &&
!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(EnvironmentVariablesAWSCredentials.ENVIRONMENT_VARIABLE_SECRETKEY)))
{
amazonS3Client = new AmazonS3Client(new EnvironmentVariablesAWSCredentials(), config);
}
// Load credentials from an ECS docker container
else if (
!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(ECSTaskCredentials.ContainerCredentialsURIEnvVariable)))
{
amazonS3Client = new AmazonS3Client(new ECSTaskCredentials(), config);
}
// Assume IAM role
else
{
using (var client = new AmazonSecurityTokenServiceClient(config.RegionEndpoint))
{
try
{
var identity = await client.GetCallerIdentityAsync(new GetCallerIdentityRequest());
}
catch (Exception ex)
{
throw new ArgumentException(
"Failed to determine AWS identity - ensure you have an IAM " +
"role set, have set up default credentials or have specified a profile/key pair.", ex);
}
}
amazonS3Client = new AmazonS3Client(config);
}
if (pathUri == null)
{
// Find the default path
pathUri = AmazonS3Utility.GetBucketPath(bucketName, config.RegionEndpoint.SystemName);
}
if (baseUri == null)
{
baseUri = pathUri;
}
result = new AmazonS3FileSystem(
cache,
pathUri,
baseUri,
amazonS3Client,
bucketName,
feedSubPath,
compress);
}
#endif
}
}
return(result);
}
protected FileSystemBase(LocalCache cache, Uri root)
: this(cache, root, root)
{
}
