/// <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);
}
}
/// <summary>
/// Try loading package into Library (including all node libraries and custom nodes)
/// and add to LocalPackages.
/// </summary>
/// <param name="package"></param>
internal void TryLoadPackageIntoLibrary(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)
{
try
{
OnRequestLoadNodeLibrary(assem.Assembly);
}
catch (LibraryLoadFailedException ex)
{
Log(ex.GetType() + ": " + ex.Message);
}
}
}
// load custom nodes
var customNodes = OnRequestLoadCustomNodeDirectory(package.CustomNodeDirectory);
package.LoadedCustomNodes.AddRange(customNodes);
package.EnumerateAdditionalFiles();
// If the additional files contained an extension manifest, then request it be loaded.
var extensionManifests = package.AdditionalFiles.Where(
file => file.Model.Name.Contains("ExtensionDefinition.xml") && !(file.Model.Name.Contains("ViewExtensionDefinition.xml"))).ToList();
foreach (var extPath in extensionManifests)
{
var extension = RequestLoadExtension?.Invoke(extPath.Model.FullName);
if (extension != null)
{
RequestAddExtension?.Invoke(extension);
}
this.requestedExtensions.Add(extension);
}
package.Loaded = true;
this.PackgeLoaded?.Invoke(package);
}
catch (Exception e)
{
Log("Exception when attempting to load package " + package.Name + " from " + package.RootDirectory);
Log(e.GetType() + ": " + e.Message);
}
}
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) : "",
CustomNodeDefinitions =
l.LoadedCustomNodes.Select(
x => dynamoViewModel.Model.CustomNodeManager.GetFunctionDefinition(x.Guid))
.ToList(),
Name = l.Name,
Package = l
};
// add additional files
l.EnumerateAdditionalFiles();
foreach (var file in l.AdditionalFiles)
{
vm.AdditionalFiles.Add(file.Model.FullName);
}
// load assemblies into reflection only context
foreach (var file in l.EnumerateAssemblyFiles())
{
Assembly assem;
var result = PackageLoader.TryReflectionOnlyLoadFrom(file, out assem);
if (result)
{
vm.Assemblies.Add(assem);
}
else
{
// if it's not a .NET assembly, we load it as an additional file
vm.AdditionalFiles.Add(file);
}
}
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 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) : "",
CustomNodeDefinitions =
l.LoadedCustomNodes.Select(
x => dynamoViewModel.Model.CustomNodeManager.GetFunctionDefinition(x.Guid))
.ToList(),
Assemblies = l.LoadedAssemblies.ToList(),
Name = l.Name,
Package = l
};
// add additional files
l.EnumerateAdditionalFiles();
foreach (var file in l.AdditionalFiles)
{
vm.AdditionalFiles.Add(file.Model.FullName);
}
// add unloaded assemblies, that are not yet loaded
var unloadedAssemblies =
l.EnumerateAssemblyFiles()
.Where(x => !l.LoadedAssemblies.Select(a => a.Location).Contains(x));
foreach (var file in unloadedAssemblies)
{
vm.Assemblies.Add(Assembly.ReflectionOnlyLoadFrom(file));
}
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 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;
// load assemblies into reflection only context
foreach (var file in l.EnumerateAssemblyFilesInBinDirectory())
{
Assembly assem;
var result = PackageLoader.TryReflectionOnlyLoadFrom(file, out assem);
if (result)
{
var isNodeLibrary = nodeLibraryNames == null || nodeLibraryNames.Contains(assem.FullName);
vm.Assemblies.Add(new PackageAssembly()
{
IsNodeLibrary = isNodeLibrary,
Assembly = assem
});
}
else
{
// if it's not a .NET assembly, we load it as an additional file
vm.AdditionalFiles.Add(file);
}
}
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);
}
/// <summary>
/// Try loading package into Library (including all node libraries and custom nodes)
/// and add to LocalPackages.
/// </summary>
/// <param name="package"></param>
private void TryLoadPackageIntoLibrary(Package package)
{
Add(package);
// Prevent duplicate loads
if (package.LoadState.State == PackageLoadState.StateTypes.Loaded)
{
return;
}
// Prevent loading packages that have been specifically marked as unloaded
if (package.LoadState.State == PackageLoadState.StateTypes.Unloaded)
{
return;
}
List <Assembly> loadedNodeLibs = new List <Assembly>();
try
{
// load node libraries
foreach (var assem in package.EnumerateAndLoadAssembliesInBinDirectory())
{
if (assem.IsNodeLibrary)
{
try
{
OnRequestLoadNodeLibrary(assem.Assembly);
loadedNodeLibs.Add(assem.Assembly);
}
catch (LibraryLoadFailedException ex)
{
Log(ex.GetType() + ": " + ex.Message);
}
}
}
// load custom nodes
var packageInfo = new Graph.Workspaces.PackageInfo(package.Name, new Version(package.VersionName));
var customNodes = OnRequestLoadCustomNodeDirectory(package.CustomNodeDirectory, packageInfo);
package.LoadedCustomNodes.AddRange(customNodes);
package.EnumerateAdditionalFiles();
// If the additional files contained an extension manifest, then request it be loaded.
var extensionManifests = package.AdditionalFiles.Where(
file => file.Model.Name.Contains("ExtensionDefinition.xml") && !file.Model.Name.Contains("ViewExtensionDefinition.xml")).ToList();
foreach (var extPath in extensionManifests)
{
var extension = RequestLoadExtension?.Invoke(extPath.Model.FullName);
if (extension != null)
{
RequestAddExtension?.Invoke(extension);
}
requestedExtensions.Add(extension);
}
package.SetAsLoaded();
PackgeLoaded?.Invoke(package);
PackagesLoaded?.Invoke(loadedNodeLibs);
PythonServices.PythonEngineManager.Instance.
LoadPythonEngine(package.LoadedAssemblies.Select(x => x.Assembly));
}
catch (CustomNodePackageLoadException e)
{
Package originalPackage =
localPackages.FirstOrDefault(x => x.CustomNodeDirectory == e.InstalledPath);
OnConflictingPackageLoaded(originalPackage, package);
package.LoadState.SetAsError(e.Message);
}
catch (Exception e)
{
if (e is DynamoServices.AssemblyBlockedException)
{
var failureMessage = string.Format(Properties.Resources.PackageLoadFailureForBlockedAssembly, e.Message);
DynamoServices.LoadLibraryEvents.OnLoadLibraryFailure(failureMessage, Properties.Resources.LibraryLoadFailureMessageBoxTitle);
}
package.LoadState.SetAsError(e.Message);
Log("Exception when attempting to load package " + package.Name + " from " + package.RootDirectory);
Log(e.GetType() + ": " + e.Message);
}
}
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 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) : "",
CustomNodeDefinitions =
l.LoadedCustomNodes.Select(
x => dynamoViewModel.Model.CustomNodeManager.GetFunctionDefinition(x.Guid))
.ToList(),
Name = l.Name,
Package = l
};
// add additional files
l.EnumerateAdditionalFiles();
foreach ( var file in l.AdditionalFiles)
{
vm.AdditionalFiles.Add(file.Model.FullName);
}
// load assemblies into reflection only context
foreach (var file in l.EnumerateAssemblyFiles())
{
Assembly assem;
var result = PackageLoader.TryReflectionOnlyLoadFrom(file, out assem);
if (result)
{
vm.Assemblies.Add(assem);
}
else
{
// if it's not a .NET assembly, we load it as an additional file
vm.AdditionalFiles.Add(file);
}
}
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;
}
/// <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);
}
}
