/// <summary>
/// Secondary entry point for all object representations. Called primarily by
/// <see cref="Prepare(object,bool)"/>, but also recursively when preparing interactive
/// reflected objects, etc. to prepare child member values.
/// </summary>
/// <param name="representations">The representations already produced for this object.</param>
/// <param name="depth">The current object graph depth.</param>
/// <param name="obj">The current object to represent.</param>
internal void Prepare(RepresentedObject representations, int depth, object obj)
{
if (obj == null)
{
return;
}
MainThread.Ensure();
var normalizedObj = Normalize(obj);
representations.Add(normalizedObj);
if (normalizedObj == null)
{
representations.Add(ToJson(obj));
}
else
{
representations.Add(ToJson(normalizedObj));
}
var skipInteractive = false;
var interactiveObj = obj;
// It is not safe to provide Representation objects to providers
// which can cause a stack overflow in Normalize if the provider
// decides to directly pack the provied Representation object in
// another Representation object for whatever reason.
if (obj is Representation)
{
obj = ((Representation)obj).Value;
}
foreach (var provider in providers)
{
try {
foreach (var representation in provider.ProvideRepresentations(obj))
{
representations.Add(Normalize(representation));
skipInteractive |= representation
is InteractiveObject.GetMemberValueError;
}
} catch (Exception e) {
Log.Error(TAG, $"provider {provider}.ProvideRepresentation", e);
}
}
if (skipInteractive)
{
return;
}
foreach (var interactiveObject in PrepareInteractiveObjects(depth, interactiveObj))
{
interactiveObject.Handle = ObjectCache.Shared.GetHandle(interactiveObject);
interactiveObject.Initialize();
representations.Add(interactiveObject);
}
}
public void AddProvider(RepresentationProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
MainThread.Ensure();
var agentProvider = provider as AgentRepresentationProvider;
if (agentProvider != null)
{
if (agentRepresentationProvider != null)
{
throw new InvalidOperationException(
$"{agentRepresentationProvider.GetType ()} already registered; " +
$"only one {nameof (AgentRepresentationProvider)} can be registered");
}
agentRepresentationProvider = agentProvider;
}
providers.Add(provider);
}
public static void Present(this UserPresentableException e, object uiContext = null)
{
Log.Error(TAG, $"{e.Message} ({e.Details})", e.InnerException ?? e);
MainThread.Ensure();
var window = new MetroDialogWindow {
Title = e.Message,
Message = e.Details,
AffirmativeButtonText = Catalog.GetString("OK")
};
var ownerWindow = uiContext as Window;
if (ownerWindow == null)
{
window.Owner = ownerWindow;
window.Width = 400;
window.WindowStartupLocation = WindowStartupLocation.CenterScreen;
}
else
{
window.Width = ownerWindow.Width;
window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
}
window.ShowDialog();
}
public static void Present(this UserPresentableException e, object uiContext = null)
{
Log.Error(TAG, $"{e.Message} ({e.Details})", e.InnerException ?? e);
MainThread.Ensure();
uiContext = uiContext ?? e.UIContext;
var window = (uiContext as NSViewController)?.View?.Window
?? (uiContext as NSView)?.Window
?? (uiContext as NSWindowController)?.Window
?? uiContext as NSWindow;
var alert = new NSAlert {
AlertStyle = NSAlertStyle.Critical,
MessageText = e.Message,
InformativeText = e.Details
};
if (window == null)
{
alert.RunModal();
}
else
{
alert.BeginSheet(window, resp => { });
}
}
protected override void RunErrorDialog(bool isDownloadError, string message)
{
MainThread.Ensure();
MetroDialogWindow dialog;
if (isDownloadError)
{
dialog = CreateDialog(Catalog.GetString("Download Failed"), message);
dialog.ButtonStyle = MessageDialogStyle.AffirmativeAndNegative;
dialog.AffirmativeButtonText = Catalog.GetString("Download & Install Manually");
dialog.NegativeButtonText = Catalog.GetString("Cancel");
}
else
{
dialog = CreateDialog(Catalog.GetString("Installation Failed"), message);
dialog.ButtonStyle = MessageDialogStyle.Affirmative;
dialog.AffirmativeButtonText = Catalog.GetString("Close");
}
dialog.ShowDialog();
if (dialog.Result == MessageDialogResult.Affirmative && isDownloadError)
{
try {
Process.Start(UpdateItem.DownloadUrl.ToString());
} catch (Exception e) {
Log.Error(TAG, $"unable to Process.Start({UpdateItem.DownloadUrl})", e);
}
}
}
protected Agent(bool unitTestContext)
{
MainThread.Initialize();
agentServer = new AgentServer(this);
evaluationContextManager = new Lazy <EvaluationContextManager> (() => {
MainThread.Ensure();
var host = CreateEvaluationContextManager();
host.Events.Subscribe(new Observer <ICodeCellEvent> (evnt => {
switch (evnt)
{
case EvaluationInFlight _:
break;
default:
MessageChannel.Push(evnt);
break;
}
}));
return(host);
});
if (!unitTestContext)
{
RepresentationManager.AddProvider(new ReflectionRepresentationProvider());
}
}
public override void WindowDidLoad()
{
MainThread.Ensure();
Session = SessionDocument.InstanceForWindowControllers?.Session;
if (Session == null)
{
Log.Error(TAG, "Unable to get ClientSession from SessionDocument");
throw new InvalidOperationException();
}
var viewControllers = new MacClientSessionViewControllers(this);
Session.InitializeViewControllers(viewControllers);
ShouldCascadeWindows = false;
Window.FrameAutosaveName = "SessionWindow";
Window.TitleVisibility = NSWindowTitleVisibility.Hidden;
var toolbar = new NSToolbar("xi-toolbar-main-toolbar-" + Guid.NewGuid())
{
SizeMode = NSToolbarSizeMode.Regular,
DisplayMode = NSToolbarDisplayMode.Icon,
AllowsUserCustomization = false
};
new SessionToolbarDelegate(Session, viewControllers, toolbar);
Window.Toolbar = toolbar;
base.WindowDidLoad();
}
protected override Task InstallUpdateAsync()
{
MainThread.Ensure();
var window = CreateDialog(
Catalog.Format(Catalog.GetString(
"{0} must be closed before continuing.",
comment: "{0} is the application name"),
AppName),
Catalog.Format(Catalog.GetString(
"The update was downloaded successfully and is ready " +
"to be installed, but {0} must be closed first.",
comment: "{0} is the application name"),
AppName));
window.ButtonStyle = MessageDialogStyle.AffirmativeAndNegative;
window.AffirmativeButtonText = Catalog.GetString("Quit & Install Update");
window.NegativeButtonText = Catalog.GetString("Cancel Update");
window.ShowDialog();
if (window.Result != MessageDialogResult.Affirmative)
{
DeleteUpdate();
ownerWindow.Close();
return(Task.CompletedTask);
}
Process.Start(DownloadItem.TargetFile).WaitForInputIdle(2000);
App.Current.Shutdown();
return(Task.CompletedTask);
}
public AppSessionStart() : base("app.sessionStart")
{
MainThread.Ensure();
// explicitly get and set in the case where it was not persisted
// and so we were returned the default Guid.NewGuid. save it.
userId = Prefs.Telemetry.UserGuid.GetValue();
Prefs.Telemetry.UserGuid.SetValue(userId);
// force this object to init on the main thread so that we can read
// the update channel preference
Objects.Application.Initialize();
}
public async Task OneAgentProcessForManyTickets(int ticketCount)
{
MainThread.Ensure();
var ticketRequests = new Task <AgentProcessTicket> [ticketCount];
AgentIdentity firstIdentity = null;
Func <Task <AgentProcessTicket> > RequestTicketAsync = async() => {
var ticket = await workbookApp.RequestTestTicketAsync();
ticket.ShouldNotBeNull();
var identity = await ticket.GetAgentIdentityAsync();
identity.ShouldNotBeNull();
Interlocked.CompareExchange(ref firstIdentity, identity, null);
return(ticket);
};
await Task.Run(async() => {
for (var i = 0; i < ticketRequests.Length; i++)
{
ticketRequests [i] = RequestTicketAsync();
}
await Task.WhenAll(ticketRequests).ConfigureAwait(false);
});
MainThread.Ensure();
foreach (var ticketRequest in ticketRequests)
{
ticketRequest.IsCompleted.ShouldBeTrue();
var ticket = ticketRequest.Result;
var identity = await ticket.GetAgentIdentityAsync();
identity.Id.ShouldEqual(firstIdentity.Id);
identity.ShouldBeSameAs(firstIdentity);
}
observedAgentIdentityIds.ShouldNotContain(firstIdentity.Id);
observedAgentIdentityIds.Add(firstIdentity.Id);
foreach (var ticketRequest in ticketRequests)
{
ticketRequest.Result.Dispose();
}
}
void Save()
{
MainThread.Ensure();
try {
recentDocumentsFile.ParentDirectory.CreateDirectory();
using (var writer = new StreamWriter(recentDocumentsFile))
new SerializerBuilder()
.WithNamingConvention(new CamelCaseNamingConvention())
.Build()
.Serialize(writer, this);
} catch (Exception e) {
Log.Error(TAG, "Unable to save recent documents list", e);
}
}
public void AddViewHierarchyHandler(string hierarchyKind, IViewHierarchyHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
MainThread.Ensure();
if (handlers == null)
{
handlers = new OrderedMapOfList <string, IViewHierarchyHandler> ();
}
handlers.Add(hierarchyKind, handler);
}
public async Task AgentProcessTerminated()
{
MainThread.Ensure();
FixtureSetUp();
TestAgent agent = null;
TestAgent.PushAllocHandler(a => agent = a);
var taskCompletionSource = new TaskCompletionSource();
await workbookApp.RequestTestTicketAsync(taskCompletionSource.SetResult);
agent.Stop();
(await Task.WhenAny(Task.Delay(60000), taskCompletionSource.Task))
.ShouldBeSameAs(taskCompletionSource.Task);
taskCompletionSource.Task.IsCompleted.ShouldBeTrue();
}
void Load()
{
MainThread.Ensure();
try {
loading = true;
if (recentDocumentsFile.Exists)
{
using (var reader = new StreamReader(recentDocumentsFile))
Load(new DeserializerBuilder()
.WithNamingConvention(new CamelCaseNamingConvention())
.Build()
.Deserialize <RecentDocument []> (reader));
}
} catch (Exception e) {
Log.Error(TAG, "Unable to load recent documents list", e);
} finally {
loading = false;
}
}
/// <summary>
/// Prepare serializable representations for an arbitrary object.
/// </summary>
public RepresentedObject Prepare(object obj, bool allowISerializableObject = true)
{
if (obj == null)
{
return(null);
}
MainThread.Ensure();
currentPreparePassAllowsISerializableObject = allowISerializableObject;
var representations = new RepresentedObject(obj.GetType());
Prepare(representations, 0, obj);
if (representations.Count == 0)
{
return(null);
}
return(representations);
}
public override void MakeWindowControllers()
{
MainThread.Ensure();
InstanceForWindowControllers = this;
sessionWindowController = (SessionWindowController)NSStoryboard
.FromName("Main", NSBundle.MainBundle)
.InstantiateControllerWithIdentifier(nameof(SessionWindowController));
InstanceForWindowControllers = null;
Session.Subscribe(this);
Session.Workbook.EditorHub.Events.Subscribe(
new Observer <EditorEvent> (HandleEditorEvent));
AddWindowController(sessionWindowController);
Log.Info(TAG, $"Created {sessionWindowController.GetType ()}");
}
public void Dispose()
{
MainThread.Ensure();
inhibitions--;
}
public T GetValue()
{
MainThread.Ensure();
var type = typeof(T);
if (type.IsEnum)
{
return((T)Enum.Parse(
type,
PreferenceStore.Default.GetString(Key, DefaultValue.ToString()),
true));
}
var typeCode = Type.GetTypeCode(type);
switch (typeCode)
{
// Builtin IPreferenceStore types
case TypeCode.Boolean:
return((T)(object)PreferenceStore.Default.GetBoolean(Key, (bool)(object)DefaultValue));
case TypeCode.Int64:
return((T)(object)PreferenceStore.Default.GetInt64(Key, (long)(object)DefaultValue));
case TypeCode.Double:
return((T)(object)PreferenceStore.Default.GetDouble(Key, (double)(object)DefaultValue));
case TypeCode.String:
return((T)(object)PreferenceStore.Default.GetString(Key, (string)(object)DefaultValue));
// Conversion types
case TypeCode.Single:
return((T)(object)unchecked ((float)PreferenceStore.Default.GetDouble(
Key,
unchecked ((float)(object)DefaultValue))));
case TypeCode.SByte:
return((T)(object)unchecked ((sbyte)PreferenceStore.Default.GetInt64(
Key,
unchecked ((sbyte)(object)DefaultValue))));
case TypeCode.Byte:
return((T)(object)unchecked ((byte)PreferenceStore.Default.GetInt64(
Key,
unchecked ((byte)(object)DefaultValue))));
case TypeCode.Int16:
return((T)(object)unchecked ((short)PreferenceStore.Default.GetInt64(
Key,
unchecked ((short)(object)DefaultValue))));
case TypeCode.UInt16:
return((T)(object)unchecked ((ushort)PreferenceStore.Default.GetInt64(
Key,
unchecked ((ushort)(object)DefaultValue))));
case TypeCode.Int32:
return((T)(object)unchecked ((int)PreferenceStore.Default.GetInt64(
Key,
unchecked ((int)(object)DefaultValue))));
case TypeCode.UInt32:
return((T)(object)unchecked ((uint)PreferenceStore.Default.GetInt64(
Key,
unchecked ((uint)(object)DefaultValue))));
case TypeCode.UInt64:
return((T)(object)unchecked ((ulong)PreferenceStore.Default.GetInt64(
Key,
unchecked ((long)(ulong)(object)DefaultValue))));
case TypeCode.DateTime:
return((T)(object)DateTime.Parse(
PreferenceStore.Default.GetString(
Key,
"0001-01-01T00:00:00.0000000"),
CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind));
}
if (type == typeof(string []))
{
return((T)(object)PreferenceStore.Default.GetStringArray(
Key,
(string [])(object)DefaultValue));
}
throw new NotSupportedException($"preference type not supported: {type}");
}
public CancellationTokenSource CheckForUpdatesInBackground(
bool userInitiated,
Action <Task <UpdateItem> > updateHandler)
{
if (updateHandler == null)
{
throw new ArgumentNullException(nameof(updateHandler));
}
MainThread.Ensure();
if (!userInitiated)
{
var skip = false;
if (BuildInfo.IsLocalDebugBuild)
{
skip = true;
Log.Info(TAG, "skipping update check since BuildInfo.IsLocalDebugBuild == true");
}
else if (CommandLineTool.TestDriver.ShouldRun)
{
skip = true;
Log.Info(TAG, "skipping automatic update check under the tests driver");
}
if (skip)
{
updateHandler(Task.FromResult <UpdateItem> (null));
return(null);
}
}
Log.Info(TAG, "checking for updates");
var cancellationTokenSource = new CancellationTokenSource();
CheckForUpdatesAsync(cancellationTokenSource.Token).ContinueWith(task => {
if (task.IsCanceled)
{
Log.Error(TAG, "update check cancelled");
Telemetry.Events.UpdateEvent.Canceled().Post();
}
else if (task.IsFaulted)
{
Log.Error(TAG, "update check failed", task.Exception);
Telemetry.Events.UpdateEvent.CheckFailed().Post();
}
else if (task.Result == null)
{
Log.Info(TAG, "no updates are available");
}
else
{
Log.Info(TAG, $"update available: {task.Result.DownloadUrl}");
Telemetry.Events.UpdateEvent.Available(task.Result).Post();
}
MainThread.Post(() => {
try {
updateHandler(task);
} catch (Exception e) {
Log.Error(TAG, "failed to run update handler", e);
}
});
});
return(cancellationTokenSource);
}
public IDisposable Inhibit()
{
MainThread.Ensure();
inhibitions++;
return(this);
}
public void Reset()
{
MainThread.Ensure();
PreferenceStore.Default.Remove(Key);
}
void ScheduleCheckForUpdatesPeriodicallyInBackground()
{
MainThread.Ensure();
// timer callbacks may still be invoked after the timer is
// disposed, so track a generation to know if we should
// bail early if that circumstance arises.
checkTimerGeneration++;
checkTimer?.Dispose();
TimeSpan frequency;
switch (Prefs.Updater.QueryFrequency.GetValue())
{
case QueryFrequency.Never:
Log.Debug(TAG, "Skipping check (automatic update checking disabled)");
return;
case QueryFrequency.Hourly:
frequency = TimeSpan.FromHours(1);
break;
case QueryFrequency.Daily:
frequency = TimeSpan.FromDays(1);
break;
case QueryFrequency.Weekly:
frequency = TimeSpan.FromDays(7);
break;
case QueryFrequency.Startup:
default:
if (updateChecksPerformed == 0)
{
Log.Debug(TAG, "Performing single automatic startup update check");
CheckForUpdatesInBackground(false, periodicUpdateHandler);
}
Log.Debug(TAG, "Skipping check (already performed single automatic startup check)");
return;
}
var lastCheck = Prefs.Updater.LastQuery.GetValue();
var nextCheck = frequency - (DateTime.UtcNow - lastCheck);
if (nextCheck < TimeSpan.Zero)
{
nextCheck = TimeSpan.Zero;
}
Log.Debug(TAG, $"Scheduling check. Last check @ {lastCheck}; next in {nextCheck}");
checkTimer = new Timer(state => MainThread.Post(() => {
Log.Debug(TAG, "Update check timer expired");
if ((int)state != checkTimerGeneration)
{
Log.Debug(TAG, "Ignoring update check timer callback from previous generation");
return;
}
switch (Prefs.Updater.QueryFrequency.GetValue())
{
case QueryFrequency.Never:
checkTimer?.Dispose();
return;
case QueryFrequency.Startup:
if (updateChecksPerformed > 0)
{
checkTimer?.Dispose();
return;
}
break;
}
CheckForUpdatesInBackground(false, periodicUpdateHandler);
}), checkTimerGeneration, nextCheck, frequency);
}
public void SetValue(T value)
{
MainThread.Ensure();
var type = typeof(T);
if (type.IsEnum)
{
PreferenceStore.Default.Set(Key, value.ToString());
return;
}
var typeCode = Type.GetTypeCode(type);
switch (typeCode)
{
// Builtin IPreferenceStore types
case TypeCode.Boolean:
PreferenceStore.Default.Set(Key, (bool)(object)value);
return;
case TypeCode.Int64:
PreferenceStore.Default.Set(Key, (long)(object)value);
return;
case TypeCode.Double:
PreferenceStore.Default.Set(Key, (double)(object)value);
return;
case TypeCode.String:
PreferenceStore.Default.Set(Key, (string)(object)value ?? String.Empty);
return;
// Conversion types
case TypeCode.Single:
PreferenceStore.Default.Set(Key, unchecked ((float)(object)value));
return;
case TypeCode.SByte:
PreferenceStore.Default.Set(Key, unchecked ((sbyte)(object)value));
return;
case TypeCode.Byte:
PreferenceStore.Default.Set(Key, unchecked ((byte)(object)value));
return;
case TypeCode.Int16:
PreferenceStore.Default.Set(Key, unchecked ((short)(object)value));
return;
case TypeCode.UInt16:
PreferenceStore.Default.Set(Key, unchecked ((ushort)(object)value));
return;
case TypeCode.Int32:
PreferenceStore.Default.Set(Key, unchecked ((int)(object)value));
return;
case TypeCode.UInt32:
PreferenceStore.Default.Set(Key, unchecked ((uint)(object)value));
return;
case TypeCode.UInt64:
PreferenceStore.Default.Set(Key, unchecked ((long)(ulong)(object)value));
return;
case TypeCode.DateTime:
PreferenceStore.Default.Set(
Key,
((DateTime)(object)value).ToUniversalTime().ToString("O"));
return;
}
if (type == typeof(string []))
{
PreferenceStore.Default.Set(Key, (string [])(object)value);
return;
}
throw new NotSupportedException($"preference type not supported: {type}");
}
