public void TimeStampGenerator00()
{
var scheduler = new DynamoScheduler(new SampleSchedulerThread());
Assert.AreEqual(1024, scheduler.NextTimeStamp.Identifier);
Assert.AreEqual(1025, scheduler.NextTimeStamp.Identifier);
Assert.AreEqual(1026, scheduler.NextTimeStamp.Identifier);
}
/// <summary>
/// Constructs an instance of AsyncTask object.
/// </summary>
/// <param name="scheduler">A reference to the DynamoScheduler, this
/// parameter cannot be null.</param>
///
protected AsyncTask(DynamoScheduler scheduler)
{
if (scheduler == null)
throw new ArgumentNullException("scheduler");
this.scheduler = scheduler;
CreationTime = scheduler.NextTimeStamp;
}
/// <summary>
/// Constructs an instance of AsyncTask object.
/// </summary>
/// <param name="scheduler">A reference to the DynamoScheduler, this
/// parameter cannot be null.</param>
/// <param name="callback">A delegate to be invoked when the AsyncTask
/// completes asynchronously. This parameter is optional.</param>
///
protected AsyncTask(DynamoScheduler scheduler, Action<AsyncTask> callback)
{
if (scheduler == null)
throw new ArgumentNullException("scheduler");
this.scheduler = scheduler;
this.callback = callback;
CreationTime = scheduler.NextTimeStamp;
}
public void Initialize(DynamoScheduler owningScheduler)
{
scheduler = owningScheduler;
internalThread = new Thread(ThreadProc)
{
IsBackground = true,
Name = "DynamoSchedulerThread"
};
internalThread.Start();
}
public HomeWorkspaceModel(
EngineController engine,
DynamoScheduler scheduler,
NodeFactory factory,
IEnumerable<KeyValuePair<Guid, List<string>>> traceData,
IEnumerable<NodeModel> e,
IEnumerable<NoteModel> n,
IEnumerable<AnnotationModel> a,
IEnumerable<PresetModel> presets,
ElementResolver resolver,
WorkspaceInfo info,
bool verboseLogging,
bool isTestMode)
: base(e, n,a, info, factory,presets, resolver)
{
EvaluationCount = 0;
// This protects the user from a file that might have crashed during
// its last run. As a side effect, this also causes all files set to
// run auto but lacking the HasRunWithoutCrash flag to run manually.
if (info.RunType == RunType.Automatic && !info.HasRunWithoutCrash)
{
info.RunType = RunType.Manual;
}
RunSettings = new RunSettings(info.RunType, info.RunPeriod);
PreloadedTraceData = traceData;
this.scheduler = scheduler;
this.verboseLogging = verboseLogging;
IsTestMode = isTestMode;
EngineController = engine;
// The first time the preloaded trace data is set, we cache
// the data as historical. This will be used after the initial
// run of this workspace, when the PreloadedTraceData has been
// nulled, to check for node deletions and reconcile the trace data.
// We do a deep copy of this data because the PreloadedTraceData is
// later set to null before the graph update.
var copiedData = new List<KeyValuePair<Guid, List<string>>>();
foreach (var kvp in PreloadedTraceData)
{
var strings = kvp.Value.Select(string.Copy).ToList();
copiedData.Add(new KeyValuePair<Guid, List<string>>(kvp.Key, strings));
}
historicalTraceData = copiedData;
}
public virtual void ShutDown(bool shutDownHost)
{
ShutdownRequested = true;
CleanWorkbench();
EngineController.Dispose();
EngineController = null;
PreferenceSettings.Save();
OnCleanup();
Logger.Dispose();
InstrumentationLogger.End();
#if ENABLE_DYNAMO_SCHEDULER
if (scheduler != null)
{
scheduler.Shutdown();
scheduler = null;
}
#endif
}
internal UpdateRenderPackageAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
nodeGuid = Guid.Empty;
renderPackages = new List<IRenderPackage>();
}
internal UpdateGraphAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
internal SetTraceDataAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
protected virtual void ShutDownCore(bool shutdownHost)
{
CleanWorkbench();
EngineController.Dispose();
EngineController = null;
PreferenceSettings.Save();
PreferenceSettings.PropertyChanged -= PreferenceSettings_PropertyChanged;
OnCleanup();
Logger.Dispose();
DynamoSelection.DestroyInstance();
UsageReportingManager.DestroyInstance();
InstrumentationLogger.End();
#if ENABLE_DYNAMO_SCHEDULER
if (scheduler != null)
{
scheduler.Shutdown();
scheduler.TaskStateChanged -= OnAsyncTaskStateChanged;
scheduler = null;
}
#endif
}
public void TestTaskQueuePreProcessing06()
{
var schedulerThread = new SampleSchedulerThread();
var scheduler = new DynamoScheduler(schedulerThread, false);
schedulerThread.GetSchedulerToProcessTasks();
Assert.Pass("Scheduler thread successfully exits");
}
internal DelegateBasedAsyncTask(DynamoScheduler scheduler, Action<AsyncTask> callback)
: base(scheduler, callback)
{
}
internal DelegateBasedAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
internal UpdateGraphAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
internal SetTraceDataAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
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);
}
}
}
internal PrioritizedAsyncTask(DynamoScheduler scheduler, int priority)
: base(scheduler)
{
CurrPriority = priority; // Assign task priority.
}
internal InconsequentialAsyncTask(DynamoScheduler scheduler, int punch)
: base(scheduler)
{
Punch = punch;
}
public void TestTaskStateChangedEventHandling()
{
var observer = new TaskEventObserver();
var schedulerThread = new SampleSchedulerThread();
var scheduler = new DynamoScheduler(schedulerThread, false);
scheduler.TaskStateChanged += observer.OnTaskStateChanged;
// Start scheduling a bunch of tasks.
var asyncTasks = new AsyncTask[]
{
new ErrorProneAsyncTask(scheduler, 7),
new InconsequentialAsyncTask(scheduler, 100),
new PrioritizedAsyncTask(scheduler, 1),
new PrioritizedAsyncTask(scheduler, 5),
new ErrorProneAsyncTask(scheduler, 3),
new InconsequentialAsyncTask(scheduler, 500),
new InconsequentialAsyncTask(scheduler, 300),
new PrioritizedAsyncTask(scheduler, 3),
new ErrorProneAsyncTask(scheduler, 5),
};
foreach (SampleAsyncTask asyncTask in asyncTasks)
scheduler.ScheduleForExecution(asyncTask);
schedulerThread.GetSchedulerToProcessTasks();
// Drops all InconsequentialAsyncTask and leave behind one.
// Kept all PrioritizedAsyncTask instances and sorted them.
var expected = new List<string>
{
// Scheduling notifications...
"Scheduled: ErrorProneAsyncTask: 7",
"Scheduled: InconsequentialAsyncTask: 100",
"Scheduled: PrioritizedAsyncTask: 1",
"Scheduled: PrioritizedAsyncTask: 5",
"Scheduled: ErrorProneAsyncTask: 3",
"Scheduled: InconsequentialAsyncTask: 500",
"Scheduled: InconsequentialAsyncTask: 300",
"Scheduled: PrioritizedAsyncTask: 3",
"Scheduled: ErrorProneAsyncTask: 5",
// Task discarded notifications...
"Discarded: InconsequentialAsyncTask: 100",
"Discarded: InconsequentialAsyncTask: 300",
// Execution of remaining tasks...
"ExecutionStarting: ErrorProneAsyncTask: 7",
"ExecutionFailed: ErrorProneAsyncTask: 7",
"CompletionHandled: ErrorProneAsyncTask: 7",
"ExecutionStarting: PrioritizedAsyncTask: 1",
"ExecutionCompleted: PrioritizedAsyncTask: 1",
"CompletionHandled: PrioritizedAsyncTask: 1",
"ExecutionStarting: PrioritizedAsyncTask: 5",
"ExecutionCompleted: PrioritizedAsyncTask: 5",
"CompletionHandled: PrioritizedAsyncTask: 5",
"ExecutionStarting: ErrorProneAsyncTask: 3",
"ExecutionFailed: ErrorProneAsyncTask: 3",
"CompletionHandled: ErrorProneAsyncTask: 3",
"ExecutionStarting: PrioritizedAsyncTask: 3",
"ExecutionCompleted: PrioritizedAsyncTask: 3",
"CompletionHandled: PrioritizedAsyncTask: 3",
"ExecutionStarting: ErrorProneAsyncTask: 5",
"ExecutionFailed: ErrorProneAsyncTask: 5",
"CompletionHandled: ErrorProneAsyncTask: 5",
// Execution of InconsequentialAsyncTask last...
"ExecutionStarting: InconsequentialAsyncTask: 500",
"ExecutionCompleted: InconsequentialAsyncTask: 500",
"CompletionHandled: InconsequentialAsyncTask: 500"
};
Assert.AreEqual(expected.Count, observer.Results.Count());
int index = 0;
foreach (var actual in observer.Results)
{
Assert.AreEqual(expected[index++], actual);
}
}
internal ErrorProneAsyncTask(DynamoScheduler scheduler, int value)
: base(scheduler)
{
Value = value;
}
internal CompileCustomNodeAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
internal void GrabTimeStamp(DynamoScheduler scheduler)
{
// Get the time-stamp value from the scheduler.
this.TimeStampValue = scheduler.NextTimeStamp;
this.doneEvent.Set(); // Done with grabbing.
}
/// <summary>
/// DynamoModel calls this method prior to scheduling a graph update for
/// the home workspace. This method is called to schedule custom node
/// compilation since the home workspace update may depend on it. Any
/// updates to a CustomNodeDefinition will cause GraphSyncData to be added
/// to "pendingCustomNodeSyncData" queue.
/// </summary>
/// <param name="scheduler">The scheduler on which custom node compilation
/// task can be scheduled.</param>
///
internal void ProcessPendingCustomNodeSyncData(DynamoScheduler scheduler)
{
while (pendingCustomNodeSyncData.Count > 0)
{
var initParams = new CompileCustomNodeParams()
{
SyncData = pendingCustomNodeSyncData.Dequeue(),
EngineController = this
};
var compileTask = new CompileCustomNodeAsyncTask(scheduler);
if (compileTask.Initialize(initParams))
scheduler.ScheduleForExecution(compileTask);
}
}
internal void OnTaskStateChanged(
DynamoScheduler scheduler,
TaskStateChangedEventArgs e)
{
AddToResultList(e.Task.ToString(), e.CurrentState);
}
internal SetTraceDataAsyncTask(DynamoScheduler scheduler, Action<AsyncTask> callback)
: base(scheduler, callback)
{
}
public void TimeStampGenerator01()
{
const int EventCount = 16;
var events = new ManualResetEvent[EventCount];
var grabbers = new TimeStampGrabber[EventCount];
// Initialize events and time stamp grabbers.
for (int index = 0; index < EventCount; ++index)
{
events[index] = new ManualResetEvent(false);
grabbers[index] = new TimeStampGrabber(events[index]);
}
// Start all time-stamp grabbers "at one go".
var scheduler = new DynamoScheduler(new SampleSchedulerThread(), true);
Parallel.For(0, EventCount, ((index) =>
{
grabbers[index].GrabTimeStamp(scheduler);
}));
WaitHandle.WaitAll(events);
var values = new List<TimeStamp>();
for (int index = 0; index < EventCount; ++index)
values.Add(grabbers[index].TimeStampValue);
// Ensure we get a list of time stamps, and that these numbers are
// all unique (i.e. the distinct set of numbers returned should have
// the same count as the original list).
//
Assert.AreEqual(EventCount, values.Count);
var distinct = values.Distinct();
Assert.AreEqual(values.Count, distinct.Count());
}
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);
}
public void TestSchedulerCreationDestruction()
{
var schedulerThread = new SampleSchedulerThread();
Assert.IsFalse(schedulerThread.Initialized);
Assert.IsFalse(schedulerThread.Destroyed);
var scheduler = new DynamoScheduler(schedulerThread, false);
Assert.IsTrue(schedulerThread.Initialized);
Assert.IsFalse(schedulerThread.Destroyed);
scheduler.Shutdown();
Assert.IsTrue(schedulerThread.Initialized);
Assert.IsTrue(schedulerThread.Destroyed);
}
public HomeWorkspaceModel(EngineController engine, DynamoScheduler scheduler,
NodeFactory factory, bool verboseLogging, bool isTestMode, string fileName="")
: this(
engine,
scheduler,
factory,
Enumerable.Empty<KeyValuePair<Guid, List<string>>>(),
Enumerable.Empty<NodeModel>(),
Enumerable.Empty<NoteModel>(),
Enumerable.Empty<AnnotationModel>(),
Enumerable.Empty<PresetModel>(),
new ElementResolver(),
new WorkspaceInfo(){FileName = fileName, Name = "Home"},
verboseLogging,
isTestMode) { }
public void TestTaskQueuePreProcessing05()
{
var schedulerThread = new SampleSchedulerThread();
var scheduler = new DynamoScheduler(schedulerThread, false);
// Start scheduling a bunch of tasks.
var asyncTasks = new AsyncTask[]
{
new PrioritizedAsyncTask(scheduler, 1),
new InconsequentialAsyncTask(scheduler, 100),
};
var results = new List<string>();
foreach (SampleAsyncTask asyncTask in asyncTasks)
{
asyncTask.InitializeWithResultList(results);
scheduler.ScheduleForExecution(asyncTask);
}
schedulerThread.GetSchedulerToProcessTasks();
// Drops all InconsequentialAsyncTask and leave behind one.
// Kept all PrioritizedAsyncTask instances and sorted them.
Assert.AreEqual(2, results.Count);
Assert.AreEqual("PrioritizedAsyncTask: 1", results[0]);
Assert.AreEqual("InconsequentialAsyncTask: 100", results[1]);
}
internal DelegateBasedAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
internal SampleAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}
/// <summary>
/// This event handler is invoked when DynamoScheduler changes the state
/// of an AsyncTask object. See TaskStateChangedEventArgs.State for more
/// details of these state changes.
/// </summary>
/// <param name="sender">The scheduler which raised the event.</param>
/// <param name="e">Task state changed event argument.</param>
///
private void OnAsyncTaskStateChanged(DynamoScheduler sender, TaskStateChangedEventArgs e)
{
switch (e.CurrentState)
{
case TaskStateChangedEventArgs.State.ExecutionStarting:
if (e.Task is UpdateGraphAsyncTask)
ExecutionEvents.OnGraphPreExecution();
break;
case TaskStateChangedEventArgs.State.ExecutionCompleted:
if (e.Task is UpdateGraphAsyncTask)
{
// Record execution time for update graph task.
long start = e.Task.ExecutionStartTime.TickCount;
long end = e.Task.ExecutionEndTime.TickCount;
var executionTimeSpan = new TimeSpan(end - start);
InstrumentationLogger.LogAnonymousTimedEvent(
"Perf",
e.Task.GetType().Name,
executionTimeSpan);
Debug.WriteLine(String.Format(Resources.EvaluationCompleted, executionTimeSpan));
ExecutionEvents.OnGraphPostExecution();
}
break;
}
}
internal CompileCustomNodeAsyncTask(DynamoScheduler scheduler)
: base(scheduler)
{
}