public static int Main(string[] args)
{
Serializer.Setup();
// Determine what operation to perform.
INapackOperation operation = NapackOperationFinder.FindOperation(args);
if (operation == null)
{
NapackOperationFinder.WriteGeneralUsageToConsole();
return(ERROR);
}
try
{
operation.PerformOperation();
}
catch (Exception ex)
{
NapackClient.Log(ex.Message);
return(ERROR);
}
return(SUCCESS);
}
private async Task SaveNapackAsync(NapackVersionIdentifier versionId, NapackVersion version)
{
string enclosingDirectory = Path.Combine(this.NapackDirectory, versionId.GetFullName());
Directory.CreateDirectory(enclosingDirectory);
List <Task> fileWriteTasks = new List <Task>();
foreach (KeyValuePair <string, NapackFile> file in version.Files)
{
fileWriteTasks.Add(this.SaveFileAsync(Path.Combine(enclosingDirectory, file.Key), file.Value.Contents));
}
fileWriteTasks.Add(GenerateTargetAsync(versionId, version.Files.ToDictionary(item => item.Key, item => item.Value.MsbuildType)));
try
{
await Task.WhenAll(fileWriteTasks).ConfigureAwait(false);
}
catch (Exception ex)
{
NapackClient.Log("Error saving napack file: " + ex.Message);
throw;
}
}
public static void WriteGeneralUsageToConsole()
{
const string separator = "******";
NapackClient.Log("Operations: ");
foreach (Type operationType in NapackOperationFinder.KnownOperations)
{
NapackClient.Log(separator + operationType.Name + separator);
CommandLineParser parser = new CommandLineParser(operationType);
StringBuilder builder = new StringBuilder();
using (TextWriter writer = new StringWriter(builder))
{
parser.WriteUsage(writer, 0);
}
string[] lines = builder.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
NapackClient.Log(line);
}
NapackClient.Log(separator + new string('*', operationType.Name.Length) + separator);
}
}
private void AcquireNapacks(NapackServerClient client, List <NapackVersionIdentifier> listedNapacks, Dictionary <string, List <NapackVersion> > knownNapacks)
{
List <NapackVersionIdentifier> newNapacks = new List <NapackVersionIdentifier>();
foreach (NapackVersionIdentifier listedNapack in listedNapacks)
{
if (!knownNapacks.Any(napack =>
napack.Key.Equals(listedNapack.NapackName, StringComparison.InvariantCulture) &&
napack.Value.Any(individualPack => individualPack.Major == listedNapack.Major)))
{
// No napack was found with the specified name and major version.
newNapacks.Add(listedNapack);
}
}
NapackClient.Log($"Found {newNapacks.Count} new napacks to download.");
// Ah, for the want of a multiple return...
List <Tuple <NapackVersionIdentifier, NapackVersion> > newDownloadedNapacks = this.DownloadNewNapacks(client, newNapacks);
List <NapackMajorVersion> dependencies = TabulateNewDependencies(knownNapacks, newDownloadedNapacks);
int level = 0;
NapackClient.Log("Processed dependency level " + level + " with " + dependencies.Count + " new dependencies found.");
while (dependencies.Any())
{
newDownloadedNapacks = DownloadDependentNapacks(client, dependencies);
dependencies = TabulateNewDependencies(knownNapacks, newDownloadedNapacks);
++level;
NapackClient.Log("Processed dependency level " + level);
}
}
/// <summary>
/// Remove folders that aren't napacks or napack major versions that aren't referenced.
/// </summary>
/// <returns>The known napacks, with napacks that don't exist removed.</returns>
private Dictionary <string, List <NapackVersion> > RemoveUnusedNapacks(IDictionary <string, List <NapackVersion> > knownNapacks)
{
if (!Directory.Exists(this.NapackDirectory))
{
Directory.CreateDirectory(this.NapackDirectory);
}
int unknownFolders = 0;
int unusedNapacks = 0;
List <NapackVersionIdentifier> versions = new List <NapackVersionIdentifier>();
foreach (string directory in Directory.EnumerateDirectories(this.NapackDirectory))
{
string napackDirectoryName = Path.GetFileName(directory);
NapackVersionIdentifier napackVersion = null;
try
{
napackVersion = new NapackVersionIdentifier(napackDirectoryName);
}
catch (Exception ex)
{
NapackClient.Log("Directory is not a Napack; removing " + napackDirectoryName);
NapackClient.Log(ex.Message);
Directory.Delete(directory, true);
++unknownFolders;
}
if (!knownNapacks.ContainsKey(napackVersion.NapackName) ||
!knownNapacks[napackVersion.NapackName].Any(version => version.Major == napackVersion.Major))
{
// This is an unknown napack or major version. Delete.
NapackClient.Log("Napack is not used, deleting: " + napackDirectoryName);
Directory.Delete(directory, true);
++unusedNapacks;
}
versions.Add(napackVersion);
}
Dictionary <string, List <NapackVersion> > redactedKnownNapacks = new Dictionary <string, List <NapackVersion> >();
foreach (KeyValuePair <string, List <NapackVersion> > napack in knownNapacks)
{
foreach (NapackVersion version in napack.Value)
{
if (versions.Any(ver => ver.NapackName.Equals(napack.Key) && ver.Major == version.Major))
{
if (!redactedKnownNapacks.ContainsKey(napack.Key))
{
redactedKnownNapacks.Add(napack.Key, new List <NapackVersion>());
}
redactedKnownNapacks[napack.Key].Add(version);
}
}
}
NapackClient.Log($"Deleted {unknownFolders} unknown folders and {unusedNapacks} unused napacks.");
return(redactedKnownNapacks);
}
public void PerformOperation()
{
// The specified napacks.
NapackClient.Log("Reading in the Napacks JSON file...");
Dictionary <string, string> rawNapacks = Serializer.Deserialize <Dictionary <string, string> >(File.ReadAllText(this.NapacksFile));
List <NapackVersionIdentifier> listedNapacks = rawNapacks.Select(item => new NapackVersionIdentifier(item.Key + "." + item.Value)).ToList();
// The specified napacks, plus those dependencies. This doesn't have to exist -- we'll detect everything as unused if it doesn't and clear the napack folder.
Dictionary <string, List <NapackVersion> > knownNapacks = new Dictionary <string, List <NapackVersion> >();
try
{
knownNapacks = Serializer.Deserialize <Dictionary <string, List <NapackVersion> > >(File.ReadAllText(this.NapacksFile + UpdateOperation.LockFileSuffix));
}
catch (Exception)
{
NapackClient.Log("Didn't find the napack lock file; packages may be redownloaded.");
}
NapackClient.Log("Reading in the Napack Settings JSON file...");
NapackClientSettings settings = Serializer.Deserialize <NapackClientSettings>(File.ReadAllText(this.NapackSettingsFile));
// Now that we've read in everything, start processing.
knownNapacks = this.RemoveUnusedNapacks(knownNapacks);
using (NapackServerClient client = new NapackServerClient(settings.NapackFrameworkServer))
{
this.AcquireNapacks(client, listedNapacks, knownNapacks);
}
// Save the lock file now that we're in an updated state.
foreach (NapackVersion knownNapack in knownNapacks.Values.SelectMany(value => value))
{
// Clear the files so we aren't duplicating them in the lock file.
knownNapack.Files.Clear();
}
File.WriteAllText(this.NapacksFile + UpdateOperation.LockFileSuffix, Serializer.Serialize(knownNapacks));
// Extract out our version identifiers
List <NapackVersionIdentifier> napackVersionIdentifiers = new List <NapackVersionIdentifier>();
Dictionary <string, NapackVersion> allNapackVersions = new Dictionary <string, NapackVersion>();
foreach (KeyValuePair <string, List <NapackVersion> > napackVersions in knownNapacks)
{
foreach (NapackVersion napackVersion in napackVersions.Value)
{
napackVersionIdentifiers.Add(new NapackVersionIdentifier(napackVersions.Key, napackVersion.Major, napackVersion.Minor, napackVersion.Patch));
allNapackVersions.Add(napackVersions.Key, napackVersion);
}
}
NapackTargets.SaveNapackTargetsFile(this.ProjectDirectory, this.NapackDirectory, napackVersionIdentifiers);
NapackAttributions.SaveNapackAttributionsFile(this.ProjectDirectory, allNapackVersions);
}
public void PerformOperation()
{
NapackClientSettings settings = Serializer.Deserialize <NapackClientSettings>(File.ReadAllText(this.NapackSettingsFile));
using (NapackServerClient client = new NapackServerClient(settings.NapackFrameworkServer))
{
string response = client.VerifyUserAsync(this.UserEmail, this.VerificationCode).GetAwaiter().GetResult();
NapackClient.Log("Verification status:");
NapackClient.Log(response);
}
}
private async Task CreateNapackPackageAsync(string packageName, NapackLocalDescriptor napackDescriptor, Dictionary <string, NapackFile> files, UserSecret secret, NapackServerClient client)
{
NewNapack newNapack = new NewNapack()
{
metadata = new NewNapackMetadata()
{
Description = napackDescriptor.Description,
MoreInformation = napackDescriptor.MoreInformation,
AuthorizedUserIds = napackDescriptor.AuthorizedUserIds,
Tags = napackDescriptor.Tags
},
NewNapackVersion = this.CreateNapackVersion(napackDescriptor, files)
};
string response = await client.CreatePackageAsync(packageName, newNapack, secret).ConfigureAwait(false);
NapackClient.Log($"Package creation result: {response}");
}
public void PerformOperation()
{
NapackClientSettings settings = Serializer.Deserialize <NapackClientSettings>(File.ReadAllText(this.NapackSettingsFile));
using (NapackServerClient client = new NapackServerClient(settings.NapackFrameworkServer))
{
UserSecret secret = client.RegisterUserAsync(this.UserEmail).GetAwaiter().GetResult();
NapackClient.Log($"User {secret.UserId} successfully registered. Secrets (order&case sensitive):");
foreach (Guid individualSecret in secret.Secrets)
{
NapackClient.Log($" {individualSecret}");
}
if (this.SaveAsDefault)
{
File.WriteAllText(NapackClient.GetDefaultCredentialFilePath(), Serializer.Serialize(new DefaultCredentials(secret.UserId, secret.Secrets)));
}
}
}
private async Task CreateOrUpdateNapackAsync(string packageName, NapackLocalDescriptor napackDescriptor, UserSecret userSecret, NapackServerClient client)
{
string rootDirectory = Path.GetFullPath(Path.GetDirectoryName(this.PackageFile));
Dictionary <string, NapackFile> files = UploadOperation.ParseNapackFiles(rootDirectory, rootDirectory);
files.Remove(Path.GetFileName(this.PackageFile));
bool packageExists = await client.ContainsNapack(packageName).ConfigureAwait(false);
if (!packageExists)
{
await this.CreateNapackPackageAsync(packageName, napackDescriptor, files, userSecret, client).ConfigureAwait(false);
}
else
{
// This is a new version creation operation.
VersionDescriptor version = await client.UpdatePackageAsync(packageName, this.CreateNapackVersion(napackDescriptor, files), userSecret).ConfigureAwait(false);
NapackClient.Log($"Updated the {packageName} package to version {version.Major}.{version.Minor}.{version.Patch}");
}
}
public void PerformOperation()
{
NapackClient.Log("Reading in the Napack settings file...");
NapackClientSettings settings = Serializer.Deserialize <NapackClientSettings>(File.ReadAllText(this.NapackSettingsFile));
string userId = this.UserId;
List <Guid> accessKeys = this.AuthorizationKeys?.Split(';').Select(key => Guid.Parse(key)).ToList();
if (string.IsNullOrWhiteSpace(this.UserId) || accessKeys == null || accessKeys.Count == 0)
{
DefaultCredentials defaultCredentials = Serializer.Deserialize <DefaultCredentials>(File.ReadAllText(NapackClient.GetDefaultCredentialFilePath()));
userId = defaultCredentials.UserId;
accessKeys = defaultCredentials.Secrets;
}
UserSecret userSecret = new UserSecret()
{
UserId = userId,
Secrets = accessKeys
};
string packageName = Path.GetFileNameWithoutExtension(this.PackageFile);
NapackLocalDescriptor napackDescriptor = Serializer.Deserialize <NapackLocalDescriptor>(File.ReadAllText(this.PackageFile));
napackDescriptor.Validate(userId, false);
using (NapackServerClient client = new NapackServerClient(settings.NapackFrameworkServer))
{
NewNapackMetadata metadata = new NewNapackMetadata()
{
AuthorizedUserIds = napackDescriptor.AuthorizedUserIds,
Description = napackDescriptor.Description,
MoreInformation = napackDescriptor.MoreInformation,
Tags = napackDescriptor.Tags
};
string response = client.UpdatePackageMetadataAsync(packageName, metadata, userSecret).GetAwaiter().GetResult();
NapackClient.Log($"Package metadata update result: {response}");
}
}
private List <Tuple <NapackVersionIdentifier, NapackVersion> > DownloadNapacks <T>(List <T> newNapacks,
Func <T, Task <NapackVersion> > downloadOperation, Func <T, NapackVersion, NapackVersionIdentifier> identifierOperation)
{
Stopwatch timer = Stopwatch.StartNew();
List <Task <Tuple <NapackVersionIdentifier, NapackVersion> > > napackDownloadTasks =
new List <Task <Tuple <NapackVersionIdentifier, NapackVersion> > >();
foreach (T napackItem in newNapacks)
{
napackDownloadTasks.Add(Task.Run(async() =>
{
NapackVersion version = await downloadOperation(napackItem).ConfigureAwait(false);
NapackVersionIdentifier identifier = identifierOperation(napackItem, version);
await this.SaveNapackAsync(identifier, version).ConfigureAwait(false);
return(Tuple.Create <NapackVersionIdentifier, NapackVersion>(identifier, version));
}));
}
Task.WhenAll(napackDownloadTasks).GetAwaiter().GetResult();
NapackClient.Log("Downloaded " + newNapacks.Count + " in " + timer.ElapsedMilliseconds + " ms.");
return(napackDownloadTasks.Select(task => task.Result).ToList());
}
public void PerformOperation()
{
NapackClientSettings settings = Serializer.Deserialize <NapackClientSettings>(File.ReadAllText(this.NapackSettingsFile));
string userId = this.UserId;
List <Guid> accessKeys = this.AuthorizationKeys?.Split(';').Select(key => Guid.Parse(key)).ToList();
if (string.IsNullOrWhiteSpace(this.UserId) || accessKeys == null || accessKeys.Count == 0)
{
DefaultCredentials defaultCredentials = Serializer.Deserialize <DefaultCredentials>(File.ReadAllText(NapackClient.GetDefaultCredentialFilePath()));
userId = defaultCredentials.UserId;
accessKeys = defaultCredentials.Secrets;
}
UserSecret userSecret = new UserSecret()
{
UserId = userId,
Secrets = accessKeys
};
string packageName = Path.GetFileNameWithoutExtension(this.PackageFile);
NapackLocalDescriptor napackDescriptor = Serializer.Deserialize <NapackLocalDescriptor>(File.ReadAllText(this.PackageFile));
napackDescriptor.Validate(userId, true);
using (NapackServerClient client = new NapackServerClient(settings.NapackFrameworkServer))
{
CreateOrUpdateNapackAsync(packageName, napackDescriptor, userSecret, client).GetAwaiter().GetResult();
}
}
