public CefCommands(PackageLoader loader, DynamoModel model) { this.ProductName = !string.IsNullOrEmpty(model.HostName) ? model.HostName : "Dynamo"; this.Loader = loader; this.Model = model; this.Client = new DynamoPackagesUIClient(); }
public InstalledPackagesViewModel(DynamoViewModel dynamoViewModel, PackageLoader model) { this.Model = model; this.dynamoViewModel = dynamoViewModel; InitializeLocalPackages(); }
public void LoadPackagesReturnsNoPackagesForInvalidDirectory() { var pkgDir = Path.Combine(PackagesDirectory, "No directory"); var loader = new PackageLoader(ViewModel.Model, pkgDir); loader.LoadPackages(); Assert.AreEqual(0, loader.LocalPackages.Count); }
public void LoadPackagesReturnsNoPackagesForInvalidDirectory() { var pkgDir = Path.Combine(PackagesDirectory, "No directory"); var loader = new PackageLoader(ViewModel.Model.Loader, ViewModel.Model.Logger, pkgDir); loader.LoadPackagesIntoDynamo(ViewModel.Model.PreferenceSettings, ViewModel.Model.EngineController.LibraryServices); Assert.AreEqual(0, loader.LocalPackages.Count); }
public void LoadPackagesReturnsAllValidPackagesInValidDirectory() { var loader = new PackageLoader(ViewModel.Model.Loader, ViewModel.Model.Logger); loader.LoadPackagesIntoDynamo(ViewModel.Model.PreferenceSettings, ViewModel.Model.EngineController.LibraryServices); Assert.AreEqual(1, loader.LocalPackages.Count); }
/// <summary> /// Constructor /// </summary> /// <param name="dynamoViewModel"></param> /// <param name="model"></param> /// <param name="address"></param> public PackageManagerViewModel(PackageLoader loader, DynamoModel model, string address) { PkgMgrCommands = new PackageManagerCommands(loader, model); var path = this.GetType().Assembly.Location; var config = ConfigurationManager.OpenExeConfiguration(path); this.Address = PACKAGE_MANAGER_URL + "/#/" + address; }
public PublishCommands(PackageLoader loader, DynamoModel model) { fileCompressor = new MutatingFileCompressor(); //customNodeDefinitions = new List<CustomNodeDefinition>(); //Dependencies = new List<PackageDependency>(); //Assemblies = new List<PackageAssembly>(); //PackageAssemblyNodes = new List<TypeLoadData>(); //FilesToUpload = new List<string>(); }
public void GetOwnerPackageReturnsNullForInvalidFunction() { var loader = new PackageLoader(PackagesDirectory); var info = dynSettings.CustomNodeManager.AddFileToPath( Path.Combine(new string[] {GetTestDirectory(), "core", "combine", "combine2.dyf"})); var funcDef = dynSettings.CustomNodeManager.GetFunctionDefinition(info.Guid); Assert.IsNotNull(funcDef); var foundPkg = loader.GetOwnerPackage(funcDef); Assert.IsNull(foundPkg); }
public PackagePathViewModel(PackageLoader loader, LoadPackageParams loadParams, CustomNodeManager customNodeManager) { this.packageLoader = loader; this.loadPackageParams = loadParams; this.customNodeManager = customNodeManager; RootLocations = new ObservableCollection<string>(setting.CustomPackageFolders); AddPathCommand = new DelegateCommand(p => InsertPath()); DeletePathCommand = new DelegateCommand(p => RemovePathAt((int) p), CanDelete); MovePathUpCommand = new DelegateCommand(p => SwapPath((int) p, ((int) p) - 1), CanMoveUp); MovePathDownCommand = new DelegateCommand(p => SwapPath((int) p, ((int) p) + 1), CanMoveDown); UpdatePathCommand = new DelegateCommand(p => UpdatePathAt((int) p)); SaveSettingCommand = new DelegateCommand(CommitChanges); SelectedIndex = 0; }
public void ScanPackageDirectoryReturnsPackageForValidDirectory() { var pkgDir = Path.Combine(PackagesDirectory, "Custom Rounding"); var loader = new PackageLoader(); var pkg = loader.ScanPackageDirectory(pkgDir); Assert.IsNotNull(pkg); Assert.AreEqual("CAAD_RWTH", pkg.Group); Assert.AreEqual("Custom Rounding", pkg.Name); Assert.AreEqual("0.1.4", pkg.VersionName); Assert.AreEqual("This collection of nodes allows rounding, rounding up and rounding down to a specified precision.", pkg.Description); Assert.AreEqual("Round Up To Precision - Rounds a number *up* to a specified precision, Round Down To Precision - " + "Rounds a number *down* to a specified precision, Round To Precision - Rounds a number to a specified precision", pkg.Contents); Assert.AreEqual("0.5.2.10107", pkg.EngineVersion); pkg.Load(); Assert.AreEqual(3, pkg.LoadedCustomNodes.Count); }
/// <summary> /// Validate the package manager url and initialize the PackageManagerClient object /// </summary> public void Startup(StartupParams startupParams) { var path = this.GetType().Assembly.Location; var config = ConfigurationManager.OpenExeConfiguration(path); var key = config.AppSettings.Settings["packageManagerAddress"]; string url = null; if (key != null) { url = key.Value; } OnMessageLogged(LogMessage.Info("Dynamo will use the package manager server at : " + url)); if (!Uri.IsWellFormedUriString(url, UriKind.Absolute)) { throw new ArgumentException("Incorrectly formatted URL provided for Package Manager address.", "url"); } PackageLoader = new PackageLoader(startupParams.PathManager.PackagesDirectories); PackageLoader.MessageLogged += OnMessageLogged; RequestLoadNodeLibraryHandler = startupParams.LibraryLoader.LoadNodeLibrary; RequestLoadCustomNodeDirectoryHandler = (dir) => startupParams.CustomNodeManager .AddUninitializedCustomNodesInPath(dir, DynamoModel.IsTestMode, true); //raise the public events on this extension when the package loader requests. PackageLoader.RequestLoadExtension += RequestLoadExtension; PackageLoader.RequestAddExtension += RequestAddExtension; PackageLoader.RequestLoadNodeLibrary += RequestLoadNodeLibraryHandler; PackageLoader.RequestLoadCustomNodeDirectory += RequestLoadCustomNodeDirectoryHandler; var dirBuilder = new PackageDirectoryBuilder( new MutatingFileSystem(), new CustomNodePathRemapper(startupParams.CustomNodeManager, DynamoModel.IsTestMode)); PackageUploadBuilder.SetEngineVersion(startupParams.DynamoVersion); var uploadBuilder = new PackageUploadBuilder(dirBuilder, new MutatingFileCompressor()); PackageManagerClient = new PackageManagerClient( new GregClient(startupParams.AuthProvider, url), uploadBuilder, PackageLoader.DefaultPackagesDirectory); LoadPackages(startupParams.Preferences, startupParams.PathManager); }
public void NewPackageVersionUpload_DoesNotThrowExceptionWhenDLLIsLoadedSeveralTimes() { string packagesDirectory = Path.Combine(TestDirectory, "pkgs"); var loader = new PackageLoader(packagesDirectory); loader.LoadAll(new LoadPackageParams { Preferences = ViewModel.Model.PreferenceSettings }); PublishPackageViewModel vm = null; Assert.DoesNotThrow(() => { vm = PublishPackageViewModel.FromLocalPackage(ViewModel, loader.LocalPackages.First()); }); Assert.AreEqual(PackageUploadHandle.State.Error, vm.UploadState); }
private void AddDllFile(string filename) { try { Assembly assem; // we're not sure if this is a managed assembly or not // we try to load it, if it fails - we add it as an additional file var result = PackageLoader.TryLoadFrom(filename, out assem); if (result) { var assemName = assem.GetName().Name; // The user has attempted to load an existing dll from another path. This is not allowed // as the existing assembly cannot be modified while Dynamo is active. if (this.Assemblies.Any(x => assemName == x.Assembly.GetName().Name)) { MessageBox.Show(string.Format(Resources.PackageDuplicateAssemblyWarning, dynamoViewModel.BrandingResourceProvider.ProductName), Resources.PackageDuplicateAssemblyWarningTitle, MessageBoxButtons.OK, MessageBoxIcon.Stop); return; // skip loading assembly } Assemblies.Add(new PackageAssembly() { Assembly = assem, IsNodeLibrary = true // assume is node library when first added }); RaisePropertyChanged("PackageContents"); } else { AddAdditionalFile(filename); } } catch (Exception e) { UploadState = PackageUploadHandle.State.Error; ErrorString = String.Format(Resources.MessageFailedToAddFile, filename); dynamoViewModel.Model.Logger.Log(e); } }
public void GetOwnerPackageReturnsPackageForValidFunctionDefinition() { var loader = new PackageLoader(PackagesDirectory); loader.LoadPackages(); var pkg = loader.LocalPackages.FirstOrDefault(x => x.Name == "Custom Rounding"); Assert.AreEqual(3, pkg.LoadedCustomNodes.Count ); foreach (var nodeInfo in pkg.LoadedCustomNodes) { var funcDef = dynSettings.CustomNodeManager.GetFunctionDefinition(nodeInfo.Guid); Assert.IsNotNull(funcDef); var foundPkg = loader.GetOwnerPackage(funcDef); Assert.IsNotNull(foundPkg); Assert.AreEqual(pkg.Name, foundPkg.Name); Assert.IsTrue(pkg.Name == foundPkg.Name); } }
/// <summary> /// Enumerates all assemblies in the package /// </summary> /// <returns>The list of all node library assemblies</returns> internal IEnumerable <PackageAssembly> EnumerateAssembliesInBinDirectory() { var assemblies = new List <PackageAssembly>(); if (!Directory.Exists(BinaryDirectory)) { return(assemblies); } // Use the pkg header to determine which assemblies to load and prevent multiple enumeration // In earlier packages, this field could be null, which is correctly handled by IsNodeLibrary var nodeLibraries = Header.node_libraries; foreach (var assemFile in (new System.IO.DirectoryInfo(BinaryDirectory)).EnumerateFiles("*.dll")) { Assembly assem; // dll files may be un-managed, skip those var result = PackageLoader.TryLoadFrom(assemFile.FullName, out assem); if (result) { // IsNodeLibrary may fail, we store the warnings here and then show IList <ILogMessage> warnings = new List <ILogMessage>(); assemblies.Add(new PackageAssembly() { Assembly = assem, IsNodeLibrary = IsNodeLibrary(nodeLibraries, assem.GetName(), ref warnings) }); warnings.ToList().ForEach(this.Log); } } foreach (var assem in assemblies) { LoadedAssemblies.Add(assem); } return(assemblies); }
internal void UninstallCore(CustomNodeManager customNodeManager, PackageLoader packageLoader, IPreferences prefs, ILogger logger) { if (this.LoadedAssemblies.Any()) { this.MarkForUninstall(prefs); return; } try { LoadedCustomNodes.ToList().ForEach(x => customNodeManager.RemoveFromDynamo(x.Guid)); packageLoader.LocalPackages.Remove(this); Directory.Delete(this.RootDirectory, true); } catch (Exception e) { logger.Log("Exception when attempting to uninstall the package " + this.Name + " from " + this.RootDirectory); logger.Log(e.GetType() + ": " + e.Message); throw e; } }
internal void UninstallCore(CustomNodeManager customNodeManager, PackageLoader packageLoader, IPreferences prefs) { if (LoadedAssemblies.Any()) { MarkForUninstall(prefs); return; } try { LoadedCustomNodes.ToList().ForEach(x => customNodeManager.Remove(x.FunctionId)); packageLoader.Remove(this); Directory.Delete(RootDirectory, true); } catch (Exception e) { Log("Exception when attempting to uninstall the package " + Name + " from " + RootDirectory); Log(e.GetType() + ": " + e.Message); throw; } }
/// <summary> /// Validate the package manager url and initialize the PackageManagerClient object /// </summary> public void Startup(StartupParams startupParams) { var path = this.GetType().Assembly.Location; var config = ConfigurationManager.OpenExeConfiguration(path); var key = config.AppSettings.Settings["packageManagerAddress"]; string url = null; if (key != null) { url = key.Value; } OnMessageLogged(LogMessage.Info("Dynamo will use the package manager server at : " + url)); if (!Uri.IsWellFormedUriString(url, UriKind.Absolute)) { throw new ArgumentException("Incorrectly formatted URL provided for Package Manager address.", "url"); } PackageLoader = new PackageLoader(startupParams.PathManager.PackagesDirectories); PackageLoader.MessageLogged += OnMessageLogged; RequestLoadNodeLibraryHandler = startupParams.LibraryLoader.LoadNodeLibrary; RequestLoadCustomNodeDirectoryHandler = (dir) => startupParams.CustomNodeManager .AddUninitializedCustomNodesInPath(dir, DynamoModel.IsTestMode, true); PackageLoader.RequestLoadNodeLibrary += RequestLoadNodeLibraryHandler; PackageLoader.RequestLoadCustomNodeDirectory += RequestLoadCustomNodeDirectoryHandler; var dirBuilder = new PackageDirectoryBuilder( new MutatingFileSystem(), new CustomNodePathRemapper(startupParams.CustomNodeManager, DynamoModel.IsTestMode)); PackageUploadBuilder.SetEngineVersion(startupParams.DynamoVersion); var uploadBuilder = new PackageUploadBuilder(dirBuilder, new MutatingFileCompressor()); PackageManagerClient = new PackageManagerClient( new GregClient(startupParams.AuthProvider, url), uploadBuilder, PackageLoader.DefaultPackagesDirectory); LoadPackages(startupParams.Preferences, startupParams.PathManager); }
public void GetOwnerPackageReturnsPackageForValidFunctionDefinition() { //Assert.Inconclusive("Porting : Formula"); var loader = new PackageLoader(ViewModel.Model.Loader, ViewModel.Model.Logger, PackagesDirectory); loader.LoadPackagesIntoDynamo(ViewModel.Model.PreferenceSettings, ViewModel.Model.EngineController.LibraryServices); var pkg = loader.LocalPackages.FirstOrDefault(x => x.Name == "Custom Rounding"); Assert.AreEqual(3, pkg.LoadedCustomNodes.Count); foreach (var nodeInfo in pkg.LoadedCustomNodes) { var funcDef = ViewModel.Model.CustomNodeManager.GetFunctionDefinition(nodeInfo.Guid); Assert.IsNotNull(funcDef); var foundPkg = loader.GetOwnerPackage(funcDef); Assert.IsNotNull(foundPkg); Assert.AreEqual(pkg.Name, foundPkg.Name); Assert.IsTrue(pkg.Name == foundPkg.Name); } }
internal void UninstallCore(CustomNodeManager customNodeManager, PackageLoader packageLoader, IPreferences prefs) { if (LoadedAssemblies.Any()) { MarkForUninstall(prefs); return; } try { LoadedCustomNodes.ToList().ForEach(x => customNodeManager.Remove(x.FunctionId)); if (BuiltInPackage) { LoadState.SetAsUnloaded(); Analytics.TrackEvent(Actions.BuiltInPackageConflict, Categories.PackageManagerOperations, $"{Name } {versionName} set unloaded"); RaisePropertyChanged(nameof(LoadState)); if (!prefs.PackageDirectoriesToUninstall.Contains(RootDirectory)) { prefs.PackageDirectoriesToUninstall.Add(RootDirectory); } } else { packageLoader.Remove(this); Directory.Delete(RootDirectory, true); } } catch (Exception e) { Log("Exception when attempting to uninstall the package " + Name + " from " + RootDirectory); Log(e.GetType() + ": " + e.Message); throw; } }
private void AddDllFile(string filename) { try { Assembly assem; // we're not sure if this is a managed assembly or not // we try to load it, if it fails - we add it as an additional file var result = PackageLoader.TryLoadFrom(filename, out assem); if (result) { this.Assemblies.Add(assem); this.RaisePropertyChanged("PackageContents"); } else { AddAdditionalFile(filename); } } catch (Exception e) { this.dynamoViewModel.Model.Logger.Log(e); } }
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); }
public void ScanPackageDirectoryReturnsNullForInvalidDirectory() { var pkgDir = ""; var loader = new PackageLoader(); var pkg = loader.ScanPackageDirectory(pkgDir); }
internal void UninstallCore( CustomNodeManager customNodeManager, PackageLoader packageLoader, IPreferences prefs, ILogger logger ) { if (this.LoadedAssemblies.Any()) { this.MarkForUninstall(prefs); return; } try { LoadedCustomNodes.ToList().ForEach(x => customNodeManager.RemoveFromDynamo(x.Guid)); packageLoader.LocalPackages.Remove(this); Directory.Delete(this.RootDirectory, true); } catch (Exception e) { logger.Log("Exception when attempting to uninstall the package " + this.Name + " from " + this.RootDirectory); logger.Log(e.GetType() + ": " + e.Message); throw e; } }
/// <summary> /// Validate the package manager url and initialize the PackageManagerClient object /// </summary> public void Startup(StartupParams startupParams) { var path = this.GetType().Assembly.Location; var config = ConfigurationManager.OpenExeConfiguration(path); var key = config.AppSettings.Settings["packageManagerAddress"]; string url = null; if (key != null) { url = key.Value; } OnMessageLogged(LogMessage.Info("Dynamo will use the package manager server at : " + url)); if (!Uri.IsWellFormedUriString(url, UriKind.Absolute)) { throw new ArgumentException("Incorrectly formatted URL provided for Package Manager address.", "url"); } //Initialize the PackageLoader with the CommonDataDirectory so that packages found here are checked first for dll's with signed certificates PackageLoader = new PackageLoader(startupParams.PathManager.PackagesDirectories, new [] { startupParams.PathManager.CommonDataDirectory }); PackageLoader.MessageLogged += OnMessageLogged; PackageLoader.PackgeLoaded += OnPackageLoaded; PackageLoader.PackageRemoved += OnPackageRemoved; RequestLoadNodeLibraryHandler = (startupParams.LibraryLoader as ExtensionLibraryLoader).LoadLibraryAndSuppressZTSearchImport; //TODO: Add LoadPackages to ILibraryLoader interface in 3.0 LoadPackagesHandler = (startupParams.LibraryLoader as ExtensionLibraryLoader).LoadPackages; customNodeManager = (startupParams.CustomNodeManager as Core.CustomNodeManager); //TODO - in 3.0 we can add the other overload of AddUninitializedCustomNodesInPath to the ICustomNodeManager interface. RequestLoadCustomNodeDirectoryHandler = (dir, pkgInfo) => customNodeManager .AddUninitializedCustomNodesInPath(dir, DynamoModel.IsTestMode, pkgInfo); //when the customNodeManager requests to know the owner of a customNode handle this query. customNodeManager.RequestCustomNodeOwner += handleCustomNodeOwnerQuery; //raise the public events on this extension when the package loader requests. PackageLoader.RequestLoadExtension += RequestLoadExtension; PackageLoader.RequestAddExtension += RequestAddExtension; PackageLoader.PackagesLoaded += LoadPackagesHandler; PackageLoader.RequestLoadNodeLibrary += RequestLoadNodeLibraryHandler; PackageLoader.RequestLoadCustomNodeDirectory += RequestLoadCustomNodeDirectoryHandler; var dirBuilder = new PackageDirectoryBuilder( new MutatingFileSystem(), new CustomNodePathRemapper(startupParams.CustomNodeManager, DynamoModel.IsTestMode)); PackageUploadBuilder.SetEngineVersion(startupParams.DynamoVersion); var uploadBuilder = new PackageUploadBuilder(dirBuilder, new MutatingFileCompressor()); // Align the package upload directory with the package download directory - // either the one selected by the user or the default directory. string packageUploadDirectory; if (startupParams.Preferences is PreferenceSettings preferences) { packageUploadDirectory = string.IsNullOrEmpty(preferences.SelectedPackagePathForInstall) ? startupParams.PathManager.DefaultPackagesDirectory : preferences.SelectedPackagePathForInstall; } else { packageUploadDirectory = startupParams.PathManager.DefaultPackagesDirectory; } PackageManagerClient = new PackageManagerClient( new GregClient(startupParams.AuthProvider, url), uploadBuilder, packageUploadDirectory); LoadPackages(startupParams.Preferences, startupParams.PathManager); }
public DynamoLoader(DynamoModel model) { this.dynamoModel = model; this.PackageLoader = new PackageLoader(this, dynamoModel.Logger); }
public void LoadPackagesReturnsAllValidPackagesInValidDirectory() { var loader = new PackageLoader(ViewModel.Model); loader.LoadPackages(); Assert.AreEqual(1, loader.LocalPackages.Count); }
internal void UninstallCore(CustomNodeManager customNodeManager, PackageLoader packageLoader, IPreferences prefs) { if (LoadedAssemblies.Any()) { MarkForUninstall(prefs); return; } try { LoadedCustomNodes.ToList().ForEach(x => customNodeManager.Remove(x.FunctionId)); packageLoader.Remove(this); Directory.Delete(RootDirectory, true); } catch (Exception e) { Log("Exception when attempting to uninstall the package " + Name + " from " + RootDirectory); Log(e.GetType() + ": " + e.Message); throw; } }
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings setting) { PackageLoader loader = new PackageLoader(setting.CustomPackageFolders); LoadPackageParams loadParams = new LoadPackageParams { Preferences = setting, PathManager = Model.PathManager }; CustomNodeManager customNodeManager = Model.CustomNodeManager; return new PackagePathViewModel(loader, loadParams, customNodeManager); }
public PackageManagerCommands(PackageLoader loader, DynamoModel model) : base(loader, model) { }
public PackageManagerCommands(PackageLoader loader, DynamoModel model) { this.Loader = loader; this.Model = model; }
public DynamoLoader(DynamoModel model) { this.dynamoModel = model; this.PackageLoader = new PackageLoader(dynamoModel); }