public NodeReadConverter(CustomNodeManager manager, LibraryServices libraryServices, bool isTestMode = false)
{
this.manager = manager;
this.libraryServices = libraryServices;
this.isTestMode = isTestMode;
// We only do this in test mode because it should not be required-
// see comment below in NodeReadConverter.ReadJson - and it could be slow.
if (this.isTestMode)
{
this.loadedAssemblies = this.buildMapOfLoadedAssemblies();
}
}
internal PackageManagerClient(IGregClient client, string rootPackageDirectory, CustomNodeManager customNodeManager)
{
this.rootPackageDirectory = rootPackageDirectory;
this.customNodeManager = customNodeManager;
this.client = client;
this.authProvider = this.client.AuthProvider;
if (this.authProvider != null)
{
this.authProvider.LoginStateChanged += OnLoginStateChanged;
}
}
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 void LoadCustomNodesAndPackages(LoadPackageParams loadPackageParams, CustomNodeManager customNodeManager)
{
foreach (var path in loadPackageParams.Preferences.CustomPackageFolders)
{
customNodeManager.AddUninitializedCustomNodesInPath(path, false, false);
if (!this.packagesDirectories.Contains(path))
{
this.packagesDirectories.Add(path);
}
}
LoadAll(loadPackageParams);
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(ExecutionEnvironment env,
Type viewModelType, string context, string commandFilePath)
{
DynamoLogger.Instance.StartLogging();
dynSettings.Controller = this;
this.Context = context;
//Start heartbeat reporting
Services.InstrumentationLogger.Start();
//create the view model to which the main window will bind
//the DynamoModel is created therein
this.DynamoViewModel = (DynamoViewModel)Activator.CreateInstance(
viewModelType, new object[] { this, commandFilePath });
// custom node loader
string directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginsPath = Path.Combine(directory, "definitions");
CustomNodeManager = new CustomNodeManager(pluginsPath);
SearchViewModel = new SearchViewModel();
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
FSchemeEnvironment = env;
DynamoViewModel.Model.CurrentWorkspace.X = 0;
DynamoViewModel.Model.CurrentWorkspace.Y = 0;
DynamoLogger.Instance.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadBuiltinTypes();
//run tests
if (FScheme.RunTests(DynamoLogger.Instance.Log))
{
DynamoLogger.Instance.Log("All Tests Passed. Core library loaded OK.");
}
this.InfoBubbleViewModel = new InfoBubbleViewModel();
AddPythonBindings();
}
internal void RefreshCustomNodesFromDirectory(CustomNodeManager customNodeManager, bool isTestMode)
{
LoadedCustomNodes.Clear();
var reloadedCustomNodes = customNodeManager.AddUninitializedCustomNodesInPath(
CustomNodeDirectory,
isTestMode,
new PackageInfo(Name, new Version(versionName)));
foreach (var x in reloadedCustomNodes)
{
LoadedCustomNodes.Add(x);
}
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(ExecutionEnvironment env, Type viewModelType, string context)
{
dynSettings.Controller = this;
this.Context = context;
//Start heartbeat reporting
Services.InstrumentationLogger.Start();
//create the view model to which the main window will bind
//the DynamoModel is created therein
this.DynamoViewModel = (DynamoViewModel)Activator.CreateInstance(viewModelType, new object[] { this });
// custom node loader
string directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginsPath = Path.Combine(directory, "definitions");
CustomNodeManager = new CustomNodeManager(pluginsPath);
SearchViewModel = new SearchViewModel();
PackageManagerClient = new PackageManagerClient();
dynSettings.PackageManagerClient = PackageManagerClient;
PublishPackageViewModel = new PublishPackageViewModel(PackageManagerClient);
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
FSchemeEnvironment = env;
DynamoViewModel.Model.CurrentSpace.X = DynamoView.CANVAS_OFFSET_X;
DynamoViewModel.Model.CurrentSpace.Y = DynamoView.CANVAS_OFFSET_Y;
dynSettings.Controller.DynamoViewModel.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadBuiltinTypes();
//run tests
if (FScheme.RunTests(dynSettings.Controller.DynamoViewModel.Log))
{
dynSettings.Controller.DynamoViewModel.Log("All Tests Passed. Core library loaded OK.");
}
NodeSubmittedForRendering += new EventHandler(Controller_NodeSubmittedForRendering);
NodeRemovedFromRendering += new EventHandler(Controller_NodeRemovedFromRendering);
}
private static void RemapCustomNodeFilePaths(CustomNodeManager customNodeManager, IEnumerable <string> filePaths, string dyfRoot)
{
var defList = filePaths
.Where(x => x.EndsWith(".dyf"))
.Select(customNodeManager.GuidFromPath)
.Select(customNodeManager.GetFunctionDefinition)
.ToList();
defList.ForEach(func =>
{
var newPath = Path.Combine(dyfRoot, Path.GetFileName(func.WorkspaceModel.FileName));
func.WorkspaceModel.FileName = newPath;
customNodeManager.SetNodePath(func.FunctionId, newPath);
});
}
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;
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings setting)
{
var pathManager = new Mock <IPathManager>();
pathManager.SetupGet(x => x.PackagesDirectories).Returns(
() => setting.CustomPackageFolders);
PackageLoader loader = new PackageLoader(pathManager.Object);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = setting,
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return(new PackagePathViewModel(loader, loadParams, customNodeManager));
}
private PackagePathViewModel CreatePackagePathViewModel(PreferenceSettings settings)
{
var pathManager = new PathManager(new PathManagerParams {
})
{
Preferences = settings
};
PackageLoader loader = new PackageLoader(pathManager);
LoadPackageParams loadParams = new LoadPackageParams
{
Preferences = settings,
};
CustomNodeManager customNodeManager = Model.CustomNodeManager;
return(new PackagePathViewModel(loader, loadParams, customNodeManager));
}
private static void RemapCustomNodeFilePaths(CustomNodeManager customNodeManager, IEnumerable <string> filePaths, string dyfRoot, bool isTestMode)
{
var defList = filePaths.Where(x => x.EndsWith(".dyf"))
.Select(customNodeManager.GuidFromPath)
.Select(
id =>
{
CustomNodeWorkspaceModel def;
return
(new { Success = customNodeManager.TryGetFunctionWorkspace(id, isTestMode, out def), Workspace = def });
}).Where(result => result.Success).Select(result => result.Workspace);
foreach (var func in defList)
{
var newPath = Path.Combine(dyfRoot, Path.GetFileName(func.FileName));
func.FileName = newPath;
}
}
/// <summary>
/// Helper function to load new custom nodes and packages.
/// </summary>
/// <param name="newPaths">New package paths to load custom nodes and packages from.</param>
/// <param name="preferences">Can be a temporary local preferences object.</param>
/// <param name="customNodeManager"></param>
private void LoadCustomNodesAndPackagesHelper(IEnumerable <string> newPaths, IPreferences preferences,
CustomNodeManager customNodeManager)
{
foreach (var path in preferences.CustomPackageFolders)
{
// Append the definitions subdirectory for custom nodes.
var dir = path == DynamoModel.BuiltInPackagesToken ? PathManager.BuiltinPackagesDirectory : path;
dir = TransformPath(dir, PathManager.DefinitionsDirectoryName);
customNodeManager.AddUninitializedCustomNodesInPath(dir, false, false);
}
foreach (var path in newPaths)
{
if (DynamoModel.IsDisabledPath(path, preferences))
{
Log(string.Format(Resources.PackagesDirectorySkipped, path));
continue;
}
else
{
ScanPackageDirectories(path, preferences);
}
}
if (pathManager != null)
{
foreach (var pkg in LocalPackages)
{
if (Directory.Exists(pkg.BinaryDirectory))
{
pathManager.AddResolutionPath(pkg.BinaryDirectory);
}
}
}
if (LocalPackages.Any())
{
// Load only those recently addeed local packages (that are located in any of the new paths)
var newPackages = LocalPackages.Where(x => newPaths.Any(y => x.RootDirectory.Contains(y)));
LoadPackages(newPackages);
}
}
/// <summary>
/// This method is used when custom nodes and packages need to be loaded from new package paths
/// that have been added to preference settings.
/// </summary>
/// <param name="newPaths">New package paths to load custom nodes and packages from.</param>
/// <param name="customNodeManager"></param>
internal void LoadNewCustomNodesAndPackages(IEnumerable <string> newPaths, CustomNodeManager customNodeManager)
{
if (newPaths == null || !newPaths.Any())
{
return;
}
var preferences = (pathManager as PathManager).Preferences;
var packageDirsToScan = new List <string>();
foreach (var path in newPaths)
{
var packageDirectory = pathManager.PackagesDirectories.FirstOrDefault(x => x.StartsWith(path));
if (packageDirectory != null)
{
packageDirsToScan.Add(packageDirectory);
}
}
LoadCustomNodesAndPackagesHelper(packageDirsToScan, preferences, customNodeManager);
}
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>
/// Scan the PackagesDirectory for packages and attempt to load all of them. Beware! Fails silently for duplicates.
/// </summary>
public void LoadPackagesIntoDynamo(
IPreferences preferences, LibraryServices libraryServices, DynamoLoader loader, string context,
bool isTestMode, CustomNodeManager customNodeManager)
{
ScanAllPackageDirectories(preferences);
foreach (var pkg in LocalPackages)
{
DynamoPathManager.Instance.AddResolutionPath(pkg.BinaryDirectory);
}
foreach (var pkg in LocalPackages)
{
pkg.LoadIntoDynamo(
loader,
AsLogger(),
libraryServices,
context,
isTestMode,
customNodeManager);
}
}
private void Setup()
{
try
{
m_ViewModel.ProducerRestart = new RestartCommand(Current.Restart);
Current.ConfigurationFactory = new ProducerConfigurationFactory();
CustomNodeManager _simulator = new CustomNodeManager();
m_ToDispose.Add(_simulator);
Current.BindingFactory = _simulator;
Current.EncodingFactory = _simulator;
Current.MessageHandlerFactory = new ProducerMessageHandlerFactory(x => m_ToDispose.Add(x), m_Trace, m_ViewModel);
Current.Initialize();
Current.Run();
_simulator.Run();
m_ViewModel.ProducerErrorMessage = "Running";
}
catch (Exception ex)
{
m_ViewModel.ProducerErrorMessage = String.Format("Error: {0}", ex.Message);
Dispose();
}
}
/// <summary>
/// Load the Package into Dynamo.
/// </summary>
/// <param name="loader"></param>
/// <param name="logger"></param>
/// <param name="libraryServices"></param>
/// <param name="context"></param>
/// <param name="isTestMode"></param>
/// <param name="customNodeManager"></param>
public void LoadIntoDynamo(
DynamoLoader loader, ILogger logger, LibraryServices libraryServices, string context,
bool isTestMode, CustomNodeManager customNodeManager)
{
// Prevent duplicate loads
if (Loaded)
{
return;
}
try
{
LoadAssembliesIntoDynamo(loader, libraryServices, context);
LoadCustomNodesIntoDynamo(customNodeManager, isTestMode);
EnumerateAdditionalFiles();
Loaded = true;
}
catch (Exception e)
{
Log("Exception when attempting to load package " + Name + " from " + RootDirectory);
Log(e.GetType() + ": " + e.Message);
}
}
private bool VerifyFuncId(ref Guid funcId, string nickname)
{
if (funcId == null)
{
return(false);
}
// if the dyf does not exist on the search path...
if (this.dynamoModel.CustomNodeManager.Contains(funcId))
{
return(true);
}
CustomNodeManager manager = this.dynamoModel.CustomNodeManager;
// if there is a node with this name, use it instead
if (!manager.Contains(nickname))
{
return(false);
}
funcId = manager.GetGuidFromName(nickname);
return(true);
}
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 bool VerifyFuncId(ref Guid funcId)
{
if (funcId == null)
{
return(false);
}
// if the dyf does not exist on the search path...
if (Workspace.DynamoModel.CustomNodeManager.Contains(funcId))
{
return(true);
}
CustomNodeManager manager = Workspace.DynamoModel.CustomNodeManager;
// if there is a node with this name, use it instead
if (manager.Contains(NickName))
{
funcId = manager.GetGuidFromName(NickName);
return(true);
}
return(false);
}
// Use this for initialization
void Start()
{
WorkModels = new List <GraphModel>();
LoadedNodeModels = new List <Type>();
LoadedFunctions = new Dictionary <string, FunctionDescription>();
//create a nodeModelloader for this instance of appmodel
var nodeloaderinst = new NodeModelLoader();
var ZTnodeloaderinst = new ZTsubsetLoader();
//on program start, we load a home screen into the main canvas
//var maincanvas = GameObject.Find("Canvas");
//the home screen comtains, run, save(possibly), and the library component
//TODO for now find the object, but we should load it here instead
var homescreen = GameObject.Find("HomeCanvas");
NodeLibrary = homescreen.GetComponentInChildren <Library>();
this.PropertyChanged += NodeLibrary.HandleAppModelChanges;
LoadedNodeModels = nodeloaderinst.LoadNodeModels("Nodes", true);
Debug.Log("loaded " + LoadedNodeModels.Count.ToString() + " nodes");
LoadedNodeModels = LoadedNodeModels.Concat(ZTnodeloaderinst.LoadNodeModels("ZTNodes", false)).ToList();
Debug.Log("loaded " + LoadedNodeModels.Count.ToString() + " nodes");
LoadedFunctions = LoadedFunctions.Concat(ZTnodeloaderinst.functions).ToDictionary(x => x.Key, x => x.Value);
Debug.Log("loaded " + LoadedFunctions.Keys.Count.ToString() + " function pointers");
//the load screen will have some callbacks here that create graphmodels
// either by loading them and passing the string to parse back, or by creating a new one
CollapsedCustomGraphNodeManager = new CustomNodeManager(this);
CollapsedCustomGraphNodeManager.InfoUpdated += HandleInfoUpdated;
CollapsedCustomGraphNodeManager.AddUninitializedCustomNodesInPath(Path.Combine(Application.dataPath, "testGraphs/customnodes"), false);
Debug.Log("loaded " + CollapsedCustomGraphNodeManager.LoadedDefinitions.Count().ToString() + "cusotm node functions");
//TODO inspect logic for firing repopulation of library...
}
private static string DoPackageFileOperationsAndZip(string rootPkgDir, CustomNodeManager customNodeManager, PackageUploadRequestBody header, Package pkg, List <string> files, PackageUploadHandle uploadHandle, bool isTestMode)
{
uploadHandle.UploadState = PackageUploadHandle.State.Copying;
DirectoryInfo rootDir, dyfDir, binDir, extraDir;
FormPackageDirectory(rootPkgDir, pkg.Name, out rootDir, out dyfDir, out binDir, out extraDir); // shouldn't do anything for pkg versions
pkg.RootDirectory = rootDir.FullName;
WritePackageHeader(header, rootDir);
CopyFilesIntoPackageDirectory(files, dyfDir, binDir, extraDir);
RemoveDyfFiles(files, dyfDir);
RemapCustomNodeFilePaths(customNodeManager, files, dyfDir.FullName, isTestMode);
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(Properties.Resources.CouldNotCompressFile);
}
if (info.Length > 100 * 1024 * 1024)
{
throw new Exception(Properties.Resources.PackageTooLarge);
}
return(zipPath);
}
public void DisplayFunction(object parameters)
{
CustomNodeManager.GetFunctionDefinition((Guid)parameters);
}
/// <summary>
/// Deserializes and returns the nodeModel that is represented by the original content of this DummyNode.
/// If this node cannot be resolved, returns a new DummyNode
/// </summary>
/// <param name="json"></param>
/// <param name="libraryServices"></param>
/// <param name="factory"></param>
/// <param name="isTestMode"></param>
/// <param name="manager"></param>
internal NodeModel GetNodeModelForDummyNode(string json, LibraryServices libraryServices,
NodeFactory factory, bool isTestMode, CustomNodeManager manager)
{
var settings = new JsonSerializerSettings
{
Error = (sender, args) =>
{
args.ErrorContext.Handled = true;
Console.WriteLine(args.ErrorContext.Error);
},
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.Auto,
Formatting = Newtonsoft.Json.Formatting.Indented,
Culture = CultureInfo.InvariantCulture,
Converters = new List <JsonConverter> {
new NodeReadConverter(manager, libraryServices, factory, isTestMode),
new TypedParameterConverter()
},
ReferenceResolverProvider = () => { return(new IdReferenceResolver()); }
};
var result = SerializationExtensions.ReplaceTypeDeclarations(json, true);
var resolvedNodeModel = JsonConvert.DeserializeObject <NodeModel>(result, settings);
// If the resolved node model is not a dummy node, then copy the node view properties from the dummy node to the resolved version of that node.
if (!(resolvedNodeModel is DummyNode))
{
SetNodeViewDataOnResolvedNode(this, resolvedNodeModel);
}
else
{
this.Log(string.Format("This graph has a node with id:{0} and name:{1}, but it could not be resolved",
resolvedNodeModel.GUID, resolvedNodeModel.Name)
, WarningLevel.Moderate);
}
return(resolvedNodeModel);
}
protected DynamoModel(IStartConfiguration config)
{
ClipBoard = new ObservableCollection<ModelBase>();
pathManager = new PathManager(new PathManagerParams
{
CorePath = config.DynamoCorePath,
PathResolver = config.PathResolver
});
// Ensure we have all directories in place.
pathManager.EnsureDirectoryExistence();
Context = config.Context;
IsTestMode = config.StartInTestMode;
DebugSettings = new DebugSettings();
Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory);
MigrationManager = new MigrationManager(DisplayFutureFileMessage, DisplayObsoleteFileMessage);
MigrationManager.MessageLogged += LogMessage;
MigrationManager.MigrationTargets.Add(typeof(WorkspaceMigrations));
var thread = config.SchedulerThread ?? new DynamoSchedulerThread();
Scheduler = new DynamoScheduler(thread, IsTestMode);
Scheduler.TaskStateChanged += OnAsyncTaskStateChanged;
geometryFactoryPath = config.GeometryFactoryPath;
IPreferences preferences = CreateOrLoadPreferences(config.Preferences);
var settings = preferences as PreferenceSettings;
if (settings != null)
{
PreferenceSettings = settings;
PreferenceSettings.PropertyChanged += PreferenceSettings_PropertyChanged;
}
InitializePreferences(preferences);
InitializeInstrumentationLogger();
if (!isTestMode && this.PreferenceSettings.IsFirstRun)
{
DynamoMigratorBase migrator = null;
try
{
migrator = DynamoMigratorBase.MigrateBetweenDynamoVersions(pathManager, config.PathResolver);
}
catch (Exception e)
{
Logger.Log(e.Message);
}
if (migrator != null)
{
var isFirstRun = this.PreferenceSettings.IsFirstRun;
this.PreferenceSettings = migrator.PreferenceSettings;
// Preserve the preference settings for IsFirstRun as this needs to be set
// only by UsageReportingManager
this.PreferenceSettings.IsFirstRun = isFirstRun;
}
}
SearchModel = new NodeSearchModel();
SearchModel.ItemProduced +=
node => ExecuteCommand(new CreateNodeCommand(node, 0, 0, true, true));
NodeFactory = new NodeFactory();
NodeFactory.MessageLogged += LogMessage;
CustomNodeManager = new CustomNodeManager(NodeFactory, MigrationManager);
InitializeCustomNodeManager();
extensionManager = new ExtensionManager();
extensionManager.MessageLogged += LogMessage;
var extensions = config.Extensions ?? ExtensionManager.ExtensionLoader.LoadDirectory(pathManager.ExtensionsDirectory);
if (extensions.Any())
{
var startupParams = new StartupParams(config.AuthProvider,
pathManager, CustomNodeManager);
foreach (var ext in extensions)
{
ext.Startup(startupParams);
ext.Load(preferences, pathManager);
ext.RequestLoadNodeLibrary += LoadNodeLibrary;
ExtensionManager.Add(ext);
}
}
Loader = new NodeModelAssemblyLoader();
Loader.MessageLogged += LogMessage;
DisposeLogic.IsShuttingDown = false;
// Create a core which is used for parsing code and loading libraries
var libraryCore =
new ProtoCore.Core(new Options { RootCustomPropertyFilterPathName = string.Empty });
libraryCore.Compilers.Add(Language.kAssociative, new Compiler(libraryCore));
libraryCore.Compilers.Add(Language.kImperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
LibraryServices = new LibraryServices(libraryCore, pathManager);
LibraryServices.MessageLogged += LogMessage;
LibraryServices.LibraryLoaded += LibraryLoaded;
ResetEngineInternal();
AddHomeWorkspace();
AuthenticationManager = new AuthenticationManager(config.AuthProvider);
UpdateManager = config.UpdateManager ?? new DefaultUpdateManager(null);
UpdateManager.Log += UpdateManager_Log;
if (!IsTestMode)
{
DefaultUpdateManager.CheckForProductUpdate(UpdateManager);
}
Logger.Log(string.Format("Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
InitializeNodeLibrary(preferences);
LogWarningMessageEvents.LogWarningMessage += LogWarningMessage;
StartBackupFilesTimer();
TraceReconciliationProcessor = this;
foreach (var ext in ExtensionManager.Extensions)
{
try
{
ext.Ready(new ReadyParams());
}
catch (Exception ex)
{
Logger.Log(ex.Message);
}
}
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(string context, IUpdateManager updateManager,
IWatchHandler watchHandler, IPreferences preferences, string corePath)
{
DebugSettings = new DebugSettings();
IsCrashing = false;
dynSettings.Controller = this;
Context = context;
PreferenceSettings = preferences;
((PreferenceSettings) PreferenceSettings).PropertyChanged += PreferenceSettings_PropertyChanged;
SIUnit.LengthUnit = PreferenceSettings.LengthUnit;
SIUnit.AreaUnit = PreferenceSettings.AreaUnit;
SIUnit.VolumeUnit = PreferenceSettings.VolumeUnit;
SIUnit.NumberFormat = PreferenceSettings.NumberFormat;
UpdateManager = updateManager;
UpdateManager.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation),dynSettings.DynamoLogger, UpdateManager.UpdateDataAvailable));
WatchHandler = watchHandler;
//Start heartbeat reporting
//This needs to be done after the update manager has been initialised
//so that the version number can be reported
InstrumentationLogger.Start();
//create the model
DynamoModel = new DynamoModel ();
DynamoModel.AddHomeWorkspace();
SearchViewModel = new SearchViewModel(DynamoModel);
DynamoModel.CurrentWorkspace = DynamoModel.HomeSpace;
DynamoModel.CurrentWorkspace.X = 0;
DynamoModel.CurrentWorkspace.Y = 0;
// custom node loader
CustomNodeManager = new CustomNodeManager(DynamoPathManager.Instance.UserDefinitions);
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
EngineController = new EngineController(this);
CustomNodeManager.RecompileAllNodes(EngineController);
//This is necessary to avoid a race condition by causing a thread join
//inside the vm exec
//TODO(Luke): Push this into a resync call with the engine controller
ResetEngine();
dynSettings.DynamoLogger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadNodeModels();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
Runner = new DynamoRunner();
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(string context, IUpdateManager updateManager,
IWatchHandler watchHandler, IPreferences preferences)
{
DebugSettings = new DebugSettings();
IsCrashing = false;
dynSettings.Controller = this;
Context = context;
//Start heartbeat reporting
InstrumentationLogger.Start();
PreferenceSettings = preferences;
((PreferenceSettings)PreferenceSettings).PropertyChanged += PreferenceSettings_PropertyChanged;
SIUnit.LengthUnit = PreferenceSettings.LengthUnit;
SIUnit.AreaUnit = PreferenceSettings.AreaUnit;
SIUnit.VolumeUnit = PreferenceSettings.VolumeUnit;
SIUnit.NumberFormat = PreferenceSettings.NumberFormat;
UpdateManager = updateManager;
UpdateManager.UpdateDownloaded += updateManager_UpdateDownloaded;
UpdateManager.ShutdownRequested += updateManager_ShutdownRequested;
UpdateManager.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation), dynSettings.DynamoLogger, UpdateManager.UpdateDataAvailable));
WatchHandler = watchHandler;
//create the model
DynamoModel = new DynamoModel();
DynamoModel.AddHomeWorkspace();
DynamoModel.CurrentWorkspace = DynamoModel.HomeSpace;
DynamoModel.CurrentWorkspace.X = 0;
DynamoModel.CurrentWorkspace.Y = 0;
// custom node loader
string directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginsPath = Path.Combine(directory, "definitions");
CustomNodeManager = new CustomNodeManager(pluginsPath);
SearchViewModel = new SearchViewModel();
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
EngineController = new EngineController(this);
//This is necessary to avoid a race condition by causing a thread join
//inside the vm exec
//TODO(Luke): Push this into a resync call with the engine controller
ResetEngine();
dynSettings.DynamoLogger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadNodeModels();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
Runner = new DynamoRunner();
}
public PackagePathViewModel(PackageLoader loader, LoadPackageParams loadParams, CustomNodeManager customNodeManager)
{
this.packageLoader = loader;
this.loadPackageParams = loadParams;
this.customNodeManager = customNodeManager;
InitializeRootLocations();
InitializeCommands();
}
NodeModel GetNodeFromCommand(CreateNodeCommand command)
{
if (command.Node != null)
{
return(command.Node);
}
if (command.NodeXml != null)
{
// command was deserialized, we must create the node directly
return(NodeFactory.CreateNodeFromXml(command.NodeXml, SaveContext.File));
}
// legacy command, hold on to your butts
var name = command.Name;
var nodeId = command.NodeId;
// find nodes with of the same type with the same GUID
var query = CurrentWorkspace.Nodes.Where(n => n.GUID.Equals(nodeId) && n.Name.Equals(name));
// safely ignore a node of the same type with the same GUID
if (query.Any())
{
return(query.First());
}
// To be used in the event it's a custom node we're making.
Guid customNodeId;
if (command is CreateProxyNodeCommand)
{
var proxyCommand = command as CreateProxyNodeCommand;
return(NodeFactory.CreateProxyNodeInstance(nodeId, name,
proxyCommand.NickName, proxyCommand.Inputs, proxyCommand.Outputs));
}
// Then, we have to figure out what kind of node to make, based on the name.
NodeModel node;
// First, we check for a DSFunction by looking for a FunctionDescriptor
var functionItem = LibraryServices.GetFunctionDescriptor(name);
if (functionItem != null)
{
node = (functionItem.IsVarArg)
? new DSVarArgFunction(functionItem) as NodeModel
: new DSFunction(functionItem);
node.GUID = nodeId;
return(node);
}
// If that didn't work, let's try using the NodeFactory
if (NodeFactory.CreateNodeFromTypeName(name, out node))
{
node.GUID = nodeId;
return(node);
}
// And if that didn't work, then it must be a custom node.
if (Guid.TryParse(name, out customNodeId))
{
node = CustomNodeManager.CreateCustomNodeInstance(customNodeId);
node.GUID = nodeId;
return(node);
}
// We're out of ideas, log an error.
Logger.LogError("Could not create instance of node with name: " + name);
return(null);
}
public void LoadCustomNodesAndPackages(LoadPackageParams loadPackageParams, CustomNodeManager customNodeManager)
{
foreach(var path in loadPackageParams.Preferences.CustomPackageFolders){
customNodeManager.AddUninitializedCustomNodesInPath(path, false, false);
if (!this.packagesDirectories.Contains(path))
{
this.packagesDirectories.Add(path);
}
}
LoadAll(loadPackageParams);
}
/// <summary>
/// LoadCustomNodesAndPackages can be used to load custom nodes and packages
/// from temporary paths that do not need to be added to preference settings.
/// To load from temporary custom paths, initialize a local PreferenceSettings object
/// and add the paths to its CustomPackageFolders property, then initialize a new
/// LoadPackageParams with this preferences object and use as input to this method.
/// To load from custom paths that need to be persisted to the preferences,
/// initialize a LoadPackageParams from an existing preferences object.
/// </summary>
/// <param name="loadPackageParams">LoadPackageParams initialized with local PreferenceSettings object containing custom package path.</param>
/// <param name="customNodeManager"></param>
public void LoadCustomNodesAndPackages(LoadPackageParams loadPackageParams, CustomNodeManager customNodeManager)
{
var preferences = loadPackageParams.Preferences;
LoadCustomNodesAndPackagesHelper(preferences.CustomPackageFolders, preferences, customNodeManager);
}
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;
}
}
public NodeModelConverter(CustomNodeManager manager, LibraryServices libraryServices)
{
this.manager = manager;
this.libraryServices = libraryServices;
}
internal void RefreshCustomNodesFromDirectory(CustomNodeManager customNodeManager, bool isTestMode)
{
LoadedCustomNodes.Clear();
foreach (var x in customNodeManager.AddUninitializedCustomNodesInPath(CustomNodeDirectory, isTestMode))
LoadedCustomNodes.Add(x);
}
/// <summary>
/// Default constructor for DynamoModel
/// </summary>
/// <param name="config">Start configuration</param>
protected DynamoModel(IStartConfiguration config)
{
ClipBoard = new ObservableCollection<ModelBase>();
pathManager = new PathManager(new PathManagerParams
{
CorePath = config.DynamoCorePath,
HostPath = config.DynamoHostPath,
PathResolver = config.PathResolver
});
// Ensure we have all directories in place.
var exceptions = new List<Exception>();
pathManager.EnsureDirectoryExistence(exceptions);
Context = config.Context;
IsTestMode = config.StartInTestMode;
var config2 = config as IStartConfiguration2;
IsHeadless = (config2 != null) ? config2.IsHeadless : false;
DebugSettings = new DebugSettings();
Logger = new DynamoLogger(DebugSettings, pathManager.LogDirectory);
foreach (var exception in exceptions)
{
Logger.Log(exception); // Log all exceptions.
}
MigrationManager = new MigrationManager(DisplayFutureFileMessage, DisplayObsoleteFileMessage);
MigrationManager.MessageLogged += LogMessage;
MigrationManager.MigrationTargets.Add(typeof(WorkspaceMigrations));
var thread = config.SchedulerThread ?? new DynamoSchedulerThread();
Scheduler = new DynamoScheduler(thread, config.ProcessMode);
Scheduler.TaskStateChanged += OnAsyncTaskStateChanged;
geometryFactoryPath = config.GeometryFactoryPath;
IPreferences preferences = CreateOrLoadPreferences(config.Preferences);
var settings = preferences as PreferenceSettings;
if (settings != null)
{
PreferenceSettings = settings;
PreferenceSettings.PropertyChanged += PreferenceSettings_PropertyChanged;
}
InitializeInstrumentationLogger();
if (!IsTestMode && PreferenceSettings.IsFirstRun)
{
DynamoMigratorBase migrator = null;
try
{
var dynamoLookup = config.UpdateManager != null && config.UpdateManager.Configuration != null
? config.UpdateManager.Configuration.DynamoLookUp : null;
migrator = DynamoMigratorBase.MigrateBetweenDynamoVersions(pathManager, dynamoLookup);
}
catch (Exception e)
{
Logger.Log(e.Message);
}
if (migrator != null)
{
var isFirstRun = PreferenceSettings.IsFirstRun;
PreferenceSettings = migrator.PreferenceSettings;
// Preserve the preference settings for IsFirstRun as this needs to be set
// only by UsageReportingManager
PreferenceSettings.IsFirstRun = isFirstRun;
}
}
InitializePreferences(PreferenceSettings);
// At this point, pathManager.PackageDirectories only has 1 element which is the directory
// in AppData. If list of PackageFolders is empty, add the folder in AppData to the list since there
// is no additional location specified. Otherwise, update pathManager.PackageDirectories to include
// PackageFolders
if (PreferenceSettings.CustomPackageFolders.Count == 0)
PreferenceSettings.CustomPackageFolders = new List<string> {pathManager.UserDataDirectory};
//Make sure that the default package folder is added in the list if custom packages folder.
var userDataFolder = pathManager.GetUserDataFolder(); //Get the default user data path
if (Directory.Exists(userDataFolder) && !PreferenceSettings.CustomPackageFolders.Contains(userDataFolder))
{
PreferenceSettings.CustomPackageFolders.Add(userDataFolder);
}
pathManager.Preferences = PreferenceSettings;
SearchModel = new NodeSearchModel();
SearchModel.ItemProduced +=
node => ExecuteCommand(new CreateNodeCommand(node, 0, 0, true, true));
NodeFactory = new NodeFactory();
NodeFactory.MessageLogged += LogMessage;
CustomNodeManager = new CustomNodeManager(NodeFactory, MigrationManager);
InitializeCustomNodeManager();
extensionManager = new ExtensionManager();
extensionManager.MessageLogged += LogMessage;
var extensions = config.Extensions ?? LoadExtensions();
Loader = new NodeModelAssemblyLoader();
Loader.MessageLogged += LogMessage;
// Create a core which is used for parsing code and loading libraries
var libraryCore = new ProtoCore.Core(new Options());
libraryCore.Compilers.Add(Language.Associative, new Compiler(libraryCore));
libraryCore.Compilers.Add(Language.Imperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
LibraryServices = new LibraryServices(libraryCore, pathManager, PreferenceSettings);
LibraryServices.MessageLogged += LogMessage;
LibraryServices.LibraryLoaded += LibraryLoaded;
ResetEngineInternal();
AddHomeWorkspace();
AuthenticationManager = new AuthenticationManager(config.AuthProvider);
UpdateManager = config.UpdateManager ?? new DefaultUpdateManager(null);
// config.UpdateManager has to be cast to IHostUpdateManager in order to extract the HostVersion and HostName
// see IHostUpdateManager summary for more details
var hostUpdateManager = config.UpdateManager as IHostUpdateManager;
if (hostUpdateManager != null)
{
HostName = hostUpdateManager.HostName;
HostVersion = hostUpdateManager.HostVersion == null ? null : hostUpdateManager.HostVersion.ToString();
}
else
{
HostName = string.Empty;
HostVersion = null;
}
UpdateManager.Log += UpdateManager_Log;
if (!IsTestMode && !IsHeadless)
{
DefaultUpdateManager.CheckForProductUpdate(UpdateManager);
}
Logger.Log(string.Format("Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
InitializeNodeLibrary(PreferenceSettings);
if (extensions.Any())
{
var startupParams = new StartupParams(config.AuthProvider,
pathManager, new ExtensionLibraryLoader(this), CustomNodeManager,
GetType().Assembly.GetName().Version, PreferenceSettings);
foreach (var ext in extensions)
{
var logSource = ext as ILogSource;
if (logSource != null)
logSource.MessageLogged += LogMessage;
try
{
ext.Startup(startupParams);
}
catch (Exception ex)
{
Logger.Log(ex.Message);
}
ExtensionManager.Add(ext);
}
}
LogWarningMessageEvents.LogWarningMessage += LogWarningMessage;
StartBackupFilesTimer();
TraceReconciliationProcessor = this;
foreach (var ext in ExtensionManager.Extensions)
{
try
{
ext.Ready(new ReadyParams(this));
}
catch (Exception ex)
{
Logger.Log(ex.Message);
}
}
}
public NodeModelConverter(CustomNodeManager manager, LibraryServices libraryServices)
{
this.manager = manager;
this.libraryServices = libraryServices;
}
