public bool Extract( out Package pkg )
{
this.DownloadState = State.Installing;
// unzip, place files
var unzipPath = Greg.Utility.FileUtilities.UnZip(DownloadPath);
if (!Directory.Exists(unzipPath))
{
throw new Exception("The package was found to be empty and was not installed.");
}
var installedPath = BuildInstallDirectoryString();
Directory.CreateDirectory(installedPath);
// Now create all of the directories
foreach (string dirPath in Directory.GetDirectories(unzipPath, "*", SearchOption.AllDirectories))
Directory.CreateDirectory(dirPath.Replace(unzipPath, installedPath));
// Copy all the files
foreach (string newPath in Directory.GetFiles(unzipPath, "*.*", SearchOption.AllDirectories))
File.Copy(newPath, newPath.Replace(unzipPath, installedPath));
// provide handle to installed package
pkg = new Package(installedPath, Header.name, VersionName);
return true;
}
private void OnPackageRemoved(Package pkg)
{
if (PackageRemoved != null)
{
PackageRemoved(pkg);
}
}
private static string DoPackageFileOperationsAndZip(DynamoModel dynamoModel, Package pkg, List<string> files, PackageUploadHandle uploadHandle)
{
uploadHandle.UploadState = PackageUploadHandle.State.Copying;
DirectoryInfo rootDir, dyfDir, binDir, extraDir;
FormPackageDirectory(dynamoModel.Loader.PackageLoader.RootPackagesDirectory, pkg.Name, out rootDir, out dyfDir, out binDir, out extraDir); // shouldn't do anything for pkg versions
pkg.RootDirectory = rootDir.FullName;
WritePackageHeader(pkg.Header, rootDir);
CopyFilesIntoPackageDirectory(files, dyfDir, binDir, extraDir);
RemoveDyfFiles(files, dyfDir);
RemapCustomNodeFilePaths(dynamoModel.CustomNodeManager, files, dyfDir.FullName);
uploadHandle.UploadState = PackageUploadHandle.State.Compressing;
string zipPath;
FileInfo info;
try
{
zipPath = Greg.Utility.FileUtilities.Zip(rootDir.FullName);
info = new FileInfo(zipPath);
}
catch
{
// give nicer error
throw new Exception("Could not compress file. Is the file in use?");
}
if (info.Length > 15 * 1000000) throw new Exception("The package is too large! The package must be less than 15 MB!");
return zipPath;
}
public bool Extract(DynamoModel dynamoModel, string installDirectory, out Package pkg)
{
this.DownloadState = State.Installing;
// unzip, place files
var unzipPath = Greg.Utility.FileUtilities.UnZip(DownloadPath);
if (!Directory.Exists(unzipPath))
{
throw new Exception(Properties.Resources.PackageEmpty);
}
if (String.IsNullOrEmpty(installDirectory))
installDirectory = dynamoModel.PathManager.DefaultPackagesDirectory;
var installedPath = BuildInstallDirectoryString(installDirectory);
Directory.CreateDirectory(installedPath);
// Now create all of the directories
foreach (string dirPath in Directory.GetDirectories(unzipPath, "*", SearchOption.AllDirectories))
Directory.CreateDirectory(dirPath.Replace(unzipPath, installedPath));
// Copy all the files
foreach (string newPath in Directory.GetFiles(unzipPath, "*.*", SearchOption.AllDirectories))
File.Copy(newPath, newPath.Replace(unzipPath, installedPath));
// provide handle to installed package
pkg = new Package(installedPath, Header.name, VersionName, Header.license);
return true;
}
private void OnPackageAdded(Package pkg)
{
if (PackageAdded != null)
{
PackageAdded(pkg);
}
}
public static PackageUploadRequestBody NewPackageHeader( Package l )
{
var engineVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
var engineMetadata = "";
return new PackageUploadRequestBody(l.Name, l.VersionName, l.Description, l.Keywords, "MIT", l.Contents, "dynamo",
engineVersion, engineMetadata, l.Group, l.Dependencies );
}
internal void Add(Package pkg)
{
if (!this.localPackages.Contains(pkg))
{
this.localPackages.Add(pkg);
pkg.MessageLogged += OnPackageMessageLogged;
OnPackageAdded(pkg);
}
}
public PackageVersionUpload NewPackageVersionUpload(Package package, string packagesDirectory, IEnumerable<string> files, PackageUploadHandle handle)
{
if (package == null) throw new ArgumentNullException("package");
if (packagesDirectory == null) throw new ArgumentNullException("packagesDirectory");
if (files == null) throw new ArgumentNullException("files");
if (handle == null) throw new ArgumentNullException("handle");
return new PackageVersionUpload(NewRequestBody(package), BuildAndZip(package, packagesDirectory, files, handle).Name);
}
internal void Remove(Package pkg)
{
if (this.localPackages.Contains(pkg))
{
this.localPackages.Remove(pkg);
pkg.MessageLogged -= OnPackageMessageLogged;
OnPackageRemoved(pkg);
}
}
private IFileInfo BuildAndZip(Package package, string packagesDirectory, IEnumerable<string> files, PackageUploadHandle handle)
{
handle.UploadState = PackageUploadHandle.State.Copying;
var dir = builder.BuildDirectory(package, packagesDirectory, files);
handle.UploadState = PackageUploadHandle.State.Compressing;
return Zip(dir);
}
public static PackageUploadRequestBody NewRequestBody(Package package)
{
if (package == null) throw new ArgumentNullException("package");
var engineVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
var engineMetadata = "";
return new PackageUploadRequestBody(package.Name, package.VersionName, package.Description, package.Keywords, package.License, package.Contents, PackageManagerClient.PackageEngineName,
engineVersion, engineMetadata, package.Group, package.Dependencies,
package.SiteUrl, package.RepositoryUrl, package.ContainsBinaries, package.NodeLibraries.Select(x => x.FullName));
}
/// <summary>
/// Forms a properly formed package directory
/// </summary>
/// <param name="package">The package to be formed</param>
/// <param name="packagesDirectory">The parent directory for the parent directory</param>
/// <param name="files">The collection of files to be moved</param>
/// <returns></returns>
public IDirectoryInfo BuildDirectory(Package package, string packagesDirectory, IEnumerable<string> files)
{
IDirectoryInfo rootDir, dyfDir, binDir, extraDir;
FormPackageDirectory(packagesDirectory, package.Name, out rootDir, out dyfDir, out binDir, out extraDir); // shouldn't do anything for pkg versions
package.RootDirectory = rootDir.FullName;
WritePackageHeader(package, rootDir);
CopyFilesIntoPackageDirectory(files, dyfDir, binDir, extraDir);
RemoveDyfFiles(files, dyfDir);
RemapCustomNodeFilePaths(files, dyfDir.FullName);
return rootDir;
}
private static string DoPackageFileOperationsAndZip(Package pkg, List<string> files, PackageUploadHandle uploadHandle)
{
uploadHandle.UploadState = PackageUploadHandle.State.Copying;
DirectoryInfo rootDir, dyfDir, binDir, extraDir;
FormPackageDirectory(dynSettings.PackageLoader.RootPackagesDirectory, pkg.Name, out rootDir, out dyfDir, out binDir, out extraDir); // shouldn't do anything for pkg versions
pkg.RootDirectory = rootDir.FullName;
WritePackageHeader(pkg.Header, rootDir);
CopyFilesIntoPackageDirectory(files, dyfDir, binDir, extraDir);
RemoveDyfFiles(files, dyfDir);
RemapCustomNodeFilePaths(files, dyfDir.FullName);
uploadHandle.UploadState = PackageUploadHandle.State.Compressing;
var zipPath = Greg.Utility.FileUtilities.Zip(rootDir.FullName);
return zipPath;
}
private PackageUploadHandle PublishPackage( bool isNewVersion,
Package l,
List<string> files,
PackageUploadHandle packageUploadHandle )
{
ThreadStart start = () =>
{
try
{
int maxRetries = 5;
int count = 0;
ResponseBody ret = null;
if (isNewVersion)
{
var pkg = PackageUploadBuilder.NewPackageVersion(l, files, packageUploadHandle);
while (ret == null && count < maxRetries)
{
count++;
ret = Client.ExecuteAndDeserialize(pkg);
}
}
else
{
var pkg = PackageUploadBuilder.NewPackage(l, files, packageUploadHandle);
while (ret == null && count < maxRetries)
{
count++;
ret = Client.ExecuteAndDeserialize(pkg);
}
}
if (ret == null)
{
packageUploadHandle.Error("Failed to submit. Try again later.");
return;
}
if (ret != null && !ret.success)
{
packageUploadHandle.Error(ret.message);
return;
}
packageUploadHandle.Done(null);
}
catch (Exception e)
{
packageUploadHandle.Error(e.GetType() + ": " + e.Message);
}
};
new Thread(start).Start();
return packageUploadHandle;
}
private void WritePackageHeader(Package package, IDirectoryInfo rootDir)
{
var pkgHeader = PackageUploadBuilder.NewRequestBody(package);
// build the package header json, which will be stored with the pkg
var jsSer = new JsonSerializer();
var pkgHeaderStr = jsSer.Serialize(pkgHeader);
// write the pkg header to the root directory of the pkg
var headerPath = Path.Combine(rootDir.FullName, PackageJsonName);
if (fileSystem.FileExists(headerPath))
{
fileSystem.DeleteFile(headerPath);
}
fileSystem.WriteAllText(headerPath, pkgHeaderStr);
}
public static PublishPackageViewModel FromLocalPackage(DynamoViewModel dynamoViewModel, Package l)
{
var defs = new List<CustomNodeDefinition>();
foreach (var x in l.LoadedCustomNodes)
{
CustomNodeDefinition def;
if (dynamoViewModel.Model.CustomNodeManager.TryGetFunctionDefinition(
x.FunctionId,
DynamoModel.IsTestMode,
out def))
{
defs.Add(def);
}
}
var vm = new PublishPackageViewModel(dynamoViewModel)
{
Group = l.Group,
Description = l.Description,
Keywords = l.Keywords != null ? String.Join(" ", l.Keywords) : "",
CustomNodeDefinitions = defs,
Name = l.Name,
RepositoryUrl = l.RepositoryUrl ?? "",
SiteUrl = l.SiteUrl ?? "",
Package = l,
License = l.License
};
// add additional files
l.EnumerateAdditionalFiles();
foreach (var file in l.AdditionalFiles)
{
vm.AdditionalFiles.Add(file.Model.FullName);
}
var nodeLibraryNames = l.Header.node_libraries;
var assembliesLoadedTwice = new List<string>();
// load assemblies into reflection only context
foreach (var file in l.EnumerateAssemblyFilesInBinDirectory())
{
Assembly assem;
var result = PackageLoader.TryReflectionOnlyLoadFrom(file, out assem);
switch (result)
{
case AssemblyLoadingState.Success:
{
var isNodeLibrary = nodeLibraryNames == null || nodeLibraryNames.Contains(assem.FullName);
vm.Assemblies.Add(new PackageAssembly()
{
IsNodeLibrary = isNodeLibrary,
Assembly = assem
});
break;
}
case AssemblyLoadingState.NotManagedAssembly:
{
// if it's not a .NET assembly, we load it as an additional file
vm.AdditionalFiles.Add(file);
break;
}
case AssemblyLoadingState.AlreadyLoaded:
{
assembliesLoadedTwice.Add(file);
break;
}
}
}
if (assembliesLoadedTwice.Any())
{
vm.UploadState = PackageUploadHandle.State.Error;
vm.ErrorString = Resources.OneAssemblyWasLoadedSeveralTimesErrorMessage + string.Join("\n", assembliesLoadedTwice);
}
if (l.VersionName == null) return vm;
var parts = l.VersionName.Split('.');
if (parts.Count() != 3) return vm;
vm.MajorVersion = parts[0];
vm.MinorVersion = parts[1];
vm.BuildVersion = parts[2];
return vm;
}
public static PackageVersionUpload NewPackageVersion(Package pkg, List<string> files, PackageUploadHandle uploadHandle)
{
var zipPath = DoPackageFileOperationsAndZip(pkg, files, uploadHandle);
return BuildPackageVersionUpload(pkg.Header, zipPath);
}
internal PackageUploadHandle PublishAsync(Package package, IEnumerable<string> files, bool isNewVersion)
{
var packageUploadHandle = new PackageUploadHandle(PackageUploadBuilder.NewRequestBody(package));
Task.Factory.StartNew(() =>
{
Publish(package, files, isNewVersion, packageUploadHandle);
});
return packageUploadHandle;
}
private PackageUploadHandle PublishPackage( bool isNewVersion,
Package l,
List<string> files,
PackageUploadHandle packageUploadHandle )
{
Task.Factory.StartNew(() =>
{
try
{
ResponseBody ret = null;
if (isNewVersion)
{
var pkg = PackageUploadBuilder.NewPackageVersion(this.dynamoModel, l, files, packageUploadHandle);
packageUploadHandle.UploadState = PackageUploadHandle.State.Uploading;
ret = Client.ExecuteAndDeserialize(pkg);
}
else
{
var pkg = PackageUploadBuilder.NewPackage(this.dynamoModel, l, files, packageUploadHandle);
packageUploadHandle.UploadState = PackageUploadHandle.State.Uploading;
ret = Client.ExecuteAndDeserialize(pkg);
}
if (ret == null)
{
packageUploadHandle.Error("Failed to submit. Try again later.");
return;
}
if (ret != null && !ret.success)
{
packageUploadHandle.Error(ret.message);
return;
}
packageUploadHandle.Done(null);
}
catch (Exception e)
{
packageUploadHandle.Error(e.GetType() + ": " + e.Message);
}
});
return packageUploadHandle;
}
public static Package FromJson(string headerPath, ILogger logger)
{
try
{
var pkgHeader = File.ReadAllText(headerPath);
var body = JsonConvert.DeserializeObject<PackageUploadRequestBody>(pkgHeader);
if (body.name == null || body.version == null)
throw new Exception("The header is missing a name or version field.");
var pkg = new Package(
Path.GetDirectoryName(headerPath),
body.name,
body.version,
body.license)
{
Group = body.@group,
Description = body.description,
Keywords = body.keywords,
VersionName = body.version,
EngineVersion = body.engine_version,
Contents = body.contents,
SiteUrl = body.site_url,
RepositoryUrl = body.repository_url,
Header = body
};
foreach (var dep in body.dependencies)
pkg.Dependencies.Add(dep);
return pkg;
}
catch (Exception e)
{
logger.Log("Failed to form package from json header.");
logger.Log(e.GetType() + ": " + e.Message);
return null;
}
}
public PackageUploadHandle Publish( Package l, List<string> files, bool isNewVersion )
{
this.OnRequestAuthentication();
var nv = new ValidateAuth();
var pkgResponse = Client.ExecuteAndDeserialize(nv);
if (pkgResponse == null)
{
throw new AuthenticationException(
"It looks like you're not logged into Autodesk 360. Log in to submit a package.");
}
var packageUploadHandle = new PackageUploadHandle(l.Header);
return PublishPackage(isNewVersion, l, files, packageUploadHandle);
}
public PackageUploadHandle Publish( Package l, List<string> files, bool isNewVersion )
{
OnAuthenticationRequested();
int maxRetries = 5;
int count = 0;
var nv = new ValidateAuth();
ResponseBody pkgResponse = null;
while (pkgResponse == null && count < maxRetries)
{
count++;
pkgResponse = Client.ExecuteAndDeserialize(nv);
}
if (pkgResponse == null)
{
throw new AuthenticationException(
"It looks like you're not logged into Autodesk 360. Log in to submit a package.");
}
var packageUploadHandle = new PackageUploadHandle(l.Header);
return PublishPackage(isNewVersion, l, files, packageUploadHandle);
}
internal void Publish(Package package, IEnumerable<string> files, bool isNewVersion, PackageUploadHandle packageUploadHandle)
{
try
{
ResponseBody ret = null;
if (isNewVersion)
{
var pkg = uploadBuilder.NewPackageVersionUpload(package, packagesDirectory, files,
packageUploadHandle);
packageUploadHandle.UploadState = PackageUploadHandle.State.Uploading;
ret = this.client.ExecuteAndDeserialize(pkg);
}
else
{
var pkg = uploadBuilder.NewPackageUpload(package, packagesDirectory, files,
packageUploadHandle);
packageUploadHandle.UploadState = PackageUploadHandle.State.Uploading;
ret = this.client.ExecuteAndDeserialize(pkg);
}
if (ret == null)
{
packageUploadHandle.Error("Failed to submit. Try again later.");
return;
}
if (ret != null && !ret.success)
{
packageUploadHandle.Error(ret.message);
return;
}
packageUploadHandle.Done(null);
}
catch (Exception e)
{
packageUploadHandle.Error(e.GetType() + ": " + e.Message);
}
}
public static Package FromJson(string headerPath, ILogger logger)
{
try
{
var pkgHeader = File.ReadAllText(headerPath);
var body = JsonConvert.DeserializeObject<PackageUploadRequestBody>(pkgHeader);
if (body.name == null || body.version == null)
{
throw new Exception("The header is missing a name or version field.");
}
var pkg = new Package(Path.GetDirectoryName(headerPath), body.name, body.version);
pkg.Group = body.group;
pkg.Description = body.description;
pkg.Keywords = body.keywords;
pkg.VersionName = body.version;
pkg.License = body.license;
pkg.EngineVersion = body.engine_version;
pkg.Contents = body.contents;
body.dependencies.ToList().ForEach(pkg.Dependencies.Add);
return pkg;
}
catch (Exception e)
{
logger.Log("Failed to form package from json header.");
logger.Log(e.GetType() + ": " + e.Message);
return null;
}
}
/// <summary>
/// Load the package into Dynamo (including all node libraries and custom nodes)
/// and add to LocalPackages
/// </summary>
public void Load(Package package)
{
this.Add(package);
// Prevent duplicate loads
if (package.Loaded) return;
try
{
// load node libraries
foreach (var assem in package.EnumerateAssembliesInBinDirectory())
{
if (assem.IsNodeLibrary)
{
OnRequestLoadNodeLibrary(assem.Assembly);
}
}
// load custom nodes
var customNodes = OnRequestLoadCustomNodeDirectory(package.CustomNodeDirectory);
package.LoadedCustomNodes.AddRange(customNodes);
package.EnumerateAdditionalFiles();
package.Loaded = true;
}
catch (Exception e)
{
Log("Exception when attempting to load package " + package.Name + " from " + package.RootDirectory);
Log(e.GetType() + ": " + e.Message);
}
}
public static PackageUpload NewPackage(DynamoModel dynamoModel, Package pkg, List<string> files, PackageUploadHandle uploadHandle)
{
var zipPath = DoPackageFileOperationsAndZip(dynamoModel, pkg, files, uploadHandle);
return BuildPackageUpload(pkg.Header, zipPath);
}
public static PublishPackageViewModel FromLocalPackage(DynamoViewModel dynamoViewModel, Package l)
{
var vm = new PublishPackageViewModel(dynamoViewModel)
{
Group = l.Group,
Description = l.Description,
Keywords = l.Keywords != null ? String.Join(" ", l.Keywords) : "",
FunctionDefinitions =
l.LoadedCustomNodes.Select(
x => dynamoViewModel.Model.CustomNodeManager.GetFunctionDefinition(x.Guid))
.ToList(),
Name = l.Name,
Package = l
};
if (l.VersionName == null) return vm;
var parts = l.VersionName.Split('.');
if (parts.Count() != 3) return vm;
vm.MajorVersion = parts[0];
vm.MinorVersion = parts[1];
vm.BuildVersion = parts[2];
return vm;
}