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.
var exceptions = new List<Exception>();
pathManager.EnsureDirectoryExistence(exceptions);
Context = config.Context;
IsTestMode = config.StartInTestMode;
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, IsTestMode ? TaskProcessMode.Synchronous : TaskProcessMode.Asynchronous);
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;
}
}
// 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};
else
pathManager.LoadCustomPackageFolders(PreferenceSettings.CustomPackageFolders);
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);
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 { 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);
if (extensions.Any())
{
var startupParams = new StartupParams(config.AuthProvider,
pathManager, new ExtensionLibraryLoader(this), CustomNodeManager,
GetType().Assembly.GetName().Version, preferences);
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);
}
}
}
protected DynamoModel(StartConfiguration configuration)
{
string context = configuration.Context;
IPreferences preferences = configuration.Preferences;
string corePath = configuration.DynamoCorePath;
DynamoRunner runner = configuration.Runner;
bool isTestMode = configuration.StartInTestMode;
DynamoPathManager.Instance.InitializeCore(corePath);
UsageReportingManager.Instance.InitializeCore(this);
Runner = runner;
Context = context;
IsTestMode = isTestMode;
Logger = new DynamoLogger(this, DynamoPathManager.Instance.Logs);
DebugSettings = new DebugSettings();
#if ENABLE_DYNAMO_SCHEDULER
var thread = configuration.SchedulerThread ?? new DynamoSchedulerThread();
scheduler = new DynamoScheduler(thread);
#endif
if (preferences is PreferenceSettings)
{
this.PreferenceSettings = preferences as PreferenceSettings;
PreferenceSettings.PropertyChanged += PreferenceSettings_PropertyChanged;
}
InitializePreferences(preferences);
InitializeInstrumentationLogger();
UpdateManager.UpdateManager.Instance.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation)));
SearchModel = new SearchModel(this);
InitializeCurrentWorkspace();
this.CustomNodeManager = new CustomNodeManager(this, DynamoPathManager.Instance.UserDefinitions);
this.Loader = new DynamoLoader(this);
this.Loader.PackageLoader.DoCachedPackageUninstalls();
this.Loader.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
this.EngineController = new EngineController(this, DynamoPathManager.Instance.GeometryFactory);
this.CustomNodeManager.RecompileAllNodes(EngineController);
// Reset virtual machine to avoid a race condition by causing a
// thread join inside the vm exec. Since DynamoModel is being called
// on the main/idle thread, it is safe to call ResetEngineInternal
// directly (we cannot call virtual method ResetEngine here).
//
ResetEngineInternal();
Nodes.ForEach(n => n.RequiresRecalc = true);
Logger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
this.Loader.ClearCachedAssemblies();
this.Loader.LoadNodeModels();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
PackageManagerClient = new PackageManagerClient(this);
}
/// <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>
/// The default constructor.
/// </summary>
public DynamoLogger(DebugSettings debugSettings, string logDirectory)
{
lock (guardMutex)
{
this.debugSettings = debugSettings;
_isDisposed = false;
WarningLevel = WarningLevel.Mild;
Warning = "";
StartLogging(logDirectory);
}
}