public static IDisposable HandleClients(TcpListener listener, Func<TcpClient, string, Task> handleClientAccessPolicy, string policyResponse)
{
listener.Start();
var disposableHandler = ThreadPoolScheduler.Instance.ScheduleAsync(async (scheduler, ct) =>
{
var disposable = new BooleanDisposable();
while (!disposable.IsDisposed)
{
var client = await listener.AcceptTcpClientAsync();
await handleClientAccessPolicy(client, policyResponse);
await scheduler.Yield();
}
return disposable;
});
var compositeDisposable = new CompositeDisposable();
compositeDisposable.Add(Disposable.Create(() => listener.Stop()));
compositeDisposable.Add(disposableHandler);
return compositeDisposable;
}
public IObservable<string> Receive(byte[] buffer, IScheduler scheduler)
{
return Observable.Create<string>(observer =>
{
var disposable = new CompositeDisposable();
this.connectionToken.SocketEvent.SetBuffer(buffer, 0, buffer.Length);
var subject = new Subject<Unit>();
var disposableEventSubscription = connectionToken.SocketEvent.Completed.Subscribe(_ =>
{
if (SendNotificationToObserver(observer, connectionToken.SocketEvent))
{
subject.OnNext(Unit.Default);
}
});
var disposableActions = subject.ObserveOn(scheduler).Subscribe(_ =>
{
if (!connectionToken.Socket.ReceiveAsync(connectionToken.SocketEvent))
{
if (SendNotificationToObserver(observer, connectionToken.SocketEvent))
{
subject.OnNext(Unit.Default);
}
}
});
subject.OnNext(Unit.Default);
disposable.Add(disposableEventSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
internal static void Initialize()
{
if (!Setting.IsLoaded || !Setting.IsBehaviorLogEnabled.Value)
{
return;
}
var disposables = new CompositeDisposable();
try
{
var file = new FileStream(
Path.Combine(App.ConfigurationDirectoryPath, App.BehaviorLogFileName),
FileMode.Append,
FileAccess.Write,
FileShare.ReadWrite);
var writer = new StreamWriter(file) { AutoFlush = true };
_writer = writer.WriteLine;
disposables.Add(Disposable.Create(() => _writer = null));
disposables.Add(writer);
disposables.Add(file);
}
finally
{
_disposable = disposables;
}
}
public IObservable<string> Receive(Socket connectedSocket, SocketAsyncEventArgs socketEventArgs, IScheduler scheduler, byte[] buffer)
{
if (connectedSocket == null)
throw new ArgumentNullException("connectedSocket");
if (socketEventArgs == null)
throw new ArgumentNullException("socketEventArgs");
return Observable.Create<string>(observer =>
{
var disposable = new CompositeDisposable();
var disposableEventSubscription = socketEventArgs.CompletedObservable().ObserveOn(scheduler).Subscribe(_ =>
{
SendNotificationToObserver(observer, socketEventArgs);
});
var disposableActions = scheduler.Schedule(() =>
{
socketEventArgs.SetBuffer(buffer, 0, buffer.Length);
if (!connectedSocket.ReceiveAsync(socketEventArgs))
{
SendNotificationToObserver(observer, socketEventArgs);
}
});
disposable.Add(disposableEventSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
public IObservable<Socket> Connect(string host, int port, IScheduler scheduler)
{
return Observable.Create<Socket>(observer =>
{
var disposable = new CompositeDisposable();
var socket = socketFactory();
var socketEvent = socketEventsFactory();
socketEvent.RemoteEndPoint = new DnsEndPoint(host, port);
socketEvent.UserToken = socket;
var disposableEventSubscription = socketEvent.CompletedObservable().ObserveOn(scheduler).Subscribe(_ =>
{
SendNotificationToObserver(observer, socketEvent);
});
var disposableActions = scheduler.Schedule(() =>
{
if (!socket.ConnectAsync(socketEvent))
{
SendNotificationToObserver(observer, socketEvent);
}
});
disposable.Add(disposableEventSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
public IObservable<Unit> SendMessage(Socket connectedSocket, SocketAsyncEventArgs socketEventArgs, IScheduler scheduler, string message)
{
if (connectedSocket == null)
throw new ArgumentNullException("connectedSocket");
if (socketEventArgs == null)
throw new ArgumentNullException("socketEventArgs");
return Observable.Create<Unit>(observer =>
{
var disposable = new CompositeDisposable();
var buffer = Encoding.UTF8.GetBytes(message);
var disposableCompletedSubscription = socketEventArgs.CompletedObservable().ObserveOn(scheduler).Subscribe(_ =>
{
SendNotificationToObserver(observer, socketEventArgs);
});
var disposableActions = scheduler.Schedule(() =>
{
socketEventArgs.SetBuffer(buffer, 0, buffer.Length);
if (!connectedSocket.SendAsync(socketEventArgs))
{
SendNotificationToObserver(observer, socketEventArgs);
}
});
disposable.Add(disposableCompletedSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
public IObservable<ConnectionToken> BuildConnectionToken(string host, int port, IScheduler scheduler)
{
return Observable.Create<ConnectionToken>(observer =>
{
var disposable = new CompositeDisposable();
var socket = socketFactory();
var socketEvent = socketEventsFactory();
socketEvent.RemoteEndPoint = new DnsEndPoint(host, port);
socketEvent.SocketClientAccessPolicyProtocol = System.Net.Sockets.SocketClientAccessPolicyProtocol.Tcp;
var connectionToken = new ConnectionToken(socket, socketEvent);
var disposableEventSubscription = socketEvent.Completed.Subscribe(_ =>
{
SendNotificationToObserver(observer, socketEvent, connectionToken);
});
var disposableActions = scheduler.Schedule(() =>
{
if (!socket.ConnectAsync(socketEvent))
{
SendNotificationToObserver(observer, socketEvent, connectionToken);
}
});
disposable.Add(disposableEventSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
public void SetUp()
{
Clock.Reset();
disposables = new CompositeDisposable
{
Disposable.Create(Clock.Reset)
};
schedule = GetScheduleDelegate();
commandsScheduled = new ConcurrentBag<IScheduledCommand>();
commandsDelivered = new ConcurrentBag<IScheduledCommand>();
var configuration = new Configuration()
.TraceScheduledCommands() // trace to console
.TraceScheduledCommands(
onScheduling: _ => { },
onScheduled: c => commandsScheduled.Add(c),
onDelivering: _ => { },
onDelivered: c => commandsDelivered.Add(c));
Configure(configuration, d => disposables.Add(d));
disposables.Add(ConfigurationContext.Establish(configuration));
}
public void SetUp()
{
disposables = new CompositeDisposable();
Command<Order>.AuthorizeDefault = (order, command) => true;
configuration = GetConfiguration();
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
}
public IDisposable ShowView(FrameworkElement view) {
var disp = new CompositeDisposable();
disp.Add(scheduler.Schedule(() => {
disp.Add(showView(view));
}));
return Disposable.Create(() => {
scheduler.Schedule(() => {
disp.Dispose();
});
});
}
//public IObservable<string> TailV2(IFile file)
//{
// return ObservableFile.WatchLines(file.GetNativePath(), Encoding.Default);
//}
public IObservable<string> Tail(IFile file, IScheduler scheduler = null)
{
return Observable.Create<string>(subj =>
{
var disposable = new CompositeDisposable();
scheduler = scheduler ?? RxApp.TaskpoolScheduler;
var abortSignal = new ManualResetEvent(false);
disposable.Add(Disposable.Create(() => abortSignal.Set()));
disposable.Add(scheduler.Schedule(abortSignal, (sched, state) =>
{
using (var reader = new StreamReader(
file.GetContent().OpenStream(FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
long lastOffset = reader.BaseStream.Length;
if (reader.BaseStream.Length > 0)
{
// Send the last 10 kb of text to the reader.
lastOffset = Math.Max(0, reader.BaseStream.Length - (1024 * 10));
}
while (!state.WaitOne(100))
{
// Idle if file hasn't changed.
if (reader.BaseStream.Length <= lastOffset)
{
if (reader.BaseStream.Length < lastOffset)
{
lastOffset = reader.BaseStream.Length;
}
continue;
}
// Read the data.
reader.BaseStream.Seek(lastOffset, SeekOrigin.Begin);
var delta = reader.BaseStream.Length - lastOffset;
var buffer = new char[delta];
reader.ReadBlock(buffer, 0, buffer.Length);
// Publish the data.
subj.OnNext(new string(buffer));
// Update the offset.
lastOffset = reader.BaseStream.Position;
}
}
return Disposable.Empty;
}));
return disposable;
});
}
public void AddTwice()
{
int i = 0;
var d = new CompositeDisposable ();
var item = Disposable.Create (() => i++);
d.Add (item);
d.Add (item);
// this results in two items registered.
Assert.AreEqual (2, d.Count, "#1");
d.Dispose ();
// though, since the first disposal takes effect, it never invokes Dispose() on item twice.
Assert.AreEqual (1, i, "#2");
}
/// <summary>
/// Schedules action to be executed after dueTime.
/// </summary>
public IDisposable Schedule(Action action, TimeSpan dueTime)
{
if (action == null)
throw new ArgumentNullException("action");
var dt = Scheduler.Normalize(dueTime);
var g = new CompositeDisposable();
g.Add(ThreadPoolScheduler.Instance.Schedule(() => g.Add(Schedule(action)), dt));
return g;
}
public void PrimeExperiment()
{
IObservable<long> xs = Observable.Interval(TimeSpan.FromSeconds(1))
.Do(ConsoleOutput(Text.Generated))
.Take(3);
IObservable<long> pruned = xs.PublishLast().Prime();
for (int r = 0; r < 2; r++)
{
using (var subscriptions = new CompositeDisposable())
{
for (int s = 0; s < 5; s++)
{
Thread.Sleep(TimeSpan.FromSeconds(.4));
TraceLine(Text.SubscribingFormat, s);
subscriptions.Add(
pruned.Subscribe(ConsoleOutput(Text.NamedObserverFormat, s)));
}
Thread.Sleep(TimeSpan.FromSeconds(2));
}
}
}
public void AddAfterDisposal()
{
int i1 = 0, i2 = 0;
var d = new CompositeDisposable ();
d.Add (Disposable.Create (() => i1++));
d.Dispose ();
Assert.AreEqual (1, i1, "#1");
d.Dispose ();
Assert.AreEqual (1, i1, "#2"); // no further addition
d.Add (Disposable.Create (() => i2++));
Assert.AreEqual (1, i2, "#3");
d.Dispose ();
Assert.AreEqual (1, i2, "#4"); // no further addition
d.Add (Disposable.Create (() => i2++)); // should be immediately disposed
Assert.AreEqual (2, i2, "#5");
}
public void SetUp()
{
disposables = new CompositeDisposable();
Command<Order>.AuthorizeDefault = (order, command) => true;
EventStoreDbTest.SetConnectionStrings();
configuration = GetConfiguration();
disposables.Add(ConfigurationContext.Establish(configuration));
}
public static IDisposable DisposeWith(this IDisposable disposable, CompositeDisposable compositeDisposable)
{
if (disposable == null)
{
return(disposable);
}
compositeDisposable?.Add(disposable);
return(disposable);
}
public void SetUp()
{
disposables = new CompositeDisposable();
Command<Order>.AuthorizeDefault = (order, command) => true;
CommandSchedulerDbContext.NameOrConnectionString =
@"Data Source=(localdb)\MSSQLLocalDB; Integrated Security=True; MultipleActiveResultSets=False; Initial Catalog=ItsCqrsTestsCommandScheduler";
configuration = GetConfiguration();
disposables.Add(ConfigurationContext.Establish(configuration));
}
public void SetUp()
{
Command<Order>.AuthorizeDefault = (order, command) => true;
disposables = new CompositeDisposable();
var configuration = new Configuration()
.UseInMemoryEventStore()
.UseInMemoryCommandScheduling();
disposables.Add(ConfigurationContext.Establish(configuration));
}
public ModalDialogContext(string title = null) {
var activeView = new SerialDisposable();
ModalDialogView dialog = null;// new ModalDialogView();
var dispatcher = Application.Current.Dispatcher;
//var dispatcher = dialog.Dispatcher;
dispatcher.BeginInvoke(() => {
dialog = new ModalDialogView();
if (!disposables.IsDisposed) {
disposables.Add(
Disposable.Create(
() => dispatcher.BeginInvoke(
()=>dialog.Close()
)
)
);
dialog.Header = title;
dialog.Owner = Application.Current.MainWindow;
dialog.WindowStartupLocation = WindowStartupLocation.CenterOwner;
dialog.SizeToContent = SizeToContent.WidthAndHeight;
dialog.ShowInTaskbar = false;
dialog.ShowDialog();
activeView.Dispose();
}
});
var presenter = ViewPresenter.Create(view => {
var disp = new CompositeDisposable();
activeView.Disposable = disp;
dispatcher.BeginInvoke(()=>{
dbg.Assert(dialog != null);
if (!disp.IsDisposed) {
dbg.Assert(dialog.Content == null);
dialog.Content = view;
var header = NavigationContext.GetTitle(view);
dialog.Header = header ?? title;
disp.Add( Disposable.Create(() => {
dispatcher.BeginInvoke(() => {
dbg.Assert(dialog.Content == view);
dialog.Header = title;
dialog.Content = null;
var d = view as IDisposable;
if (d != null) {
d.Dispose();
}
});
}));
}
});
return disp;
});
container.RegisterInstance<IViewPresenter>(presenter);
}
public static IDisposable Schedule(this IScheduler scheduler, Action<Action> action)
{
// InvokeRec1
var group = new CompositeDisposable(1);
var gate = new object();
Action recursiveAction = null;
recursiveAction = () => action(() =>
{
var isAdded = false;
var isDone = false;
var d = default(IDisposable);
d = scheduler.Schedule(() =>
{
lock (gate)
{
if (isAdded)
group.Remove(d);
else
isDone = true;
}
recursiveAction();
});
lock (gate)
{
if (!isDone)
{
group.Add(d);
isAdded = true;
}
}
});
group.Add(scheduler.Schedule(recursiveAction));
return group;
}
public void SetUp()
{
// this is a shim to make sure that the Test.Domain.Ordering.Api assembly is loaded into the AppDomain, otherwise Web API won't discover the controller type
var controller = new OrderApiController();
disposables = new CompositeDisposable();
Command<Order>.AuthorizeDefault = (order, command) => true;
var configuration = new Configuration()
.UseInMemoryEventStore()
.UseInMemoryCommandScheduling();
disposables.Add(ConfigurationContext.Establish(configuration));
}
public void when_Dispose_is_called_then_added_IDisposable_is_disposed()
{
var disposables = new CompositeDisposable();
var eventWasFired = false;
var disposable = AnonymousDisposable.Create(() => eventWasFired = true);
disposables.Add(disposable);
Assert.That(eventWasFired, Is.False);
disposables.Dispose();
Assert.That(eventWasFired, Is.True);
}
public override void DidReceiveLocalNotification(UILocalNotification localNotification, Action<WKUserNotificationInterfaceType> completionHandler)
{
_compositeDisposable.Dispose();
_compositeDisposable = new CompositeDisposable();
var trade = GetTrade(localNotification);
var currencyPair = GetCurrencyPair(localNotification, _priceSubject.AsObservable());
SetupWormholePriceStream(trade);
_trader = GetTrader(currencyPair, _priceSubject.AsObservable());
_compositeDisposable.Add(_trader);
SetupInterface(trade);
SetupStreams(_trader);
completionHandler(WKUserNotificationInterfaceType.Custom);
}
public IObservable<IList<string>> IdentitiesActivated(IScheduler scheduler)
{
return Observable.Create<IList<string>>(
o =>
{
if (!IsSupported)
{
return Observable.Empty<IList<string>>().Subscribe(o);
o.OnError(new InvalidOperationException("Bluetooth not currently supported on this device."));
return Disposable.Empty;
}
var resources = new CompositeDisposable();
try
{
var listener = StartBluetoothListener();
resources.Add(Disposable.Create(listener.Stop));
var subscription = Task.Factory.FromAsync<BluetoothClient>(listener.BeginAcceptBluetoothClient,
listener.EndAcceptBluetoothClient,
null, TaskCreationOptions.None)
.ToObservable()
.Log(_logger, "AcceptBluetoothClient")
.SelectMany(btClient => this.GetIdentities(btClient, scheduler))
.Subscribe(o);
resources = new CompositeDisposable(subscription, resources);
}
catch (Exception ex)
{
o.OnError(ex);
}
return resources;
})
.Log(_logger, "IdentitiesActivated")
.SubscribeOn(scheduler);
}
public static void DisposeWith(this IDisposable disposable, CompositeDisposable compositeDisposable)
{
compositeDisposable.Add(disposable);
}
public void Dispose()
{
_disposables.Add(Formatting.Formatter.ResetToDefault);
_disposables.Dispose();
}
public async Task <IActionResult> ConnectWebSocket(
string cryptoCode,
bool includeTransaction = true,
CancellationToken cancellation = default(CancellationToken))
{
if (!HttpContext.WebSockets.IsWebSocketRequest)
{
return(NotFound());
}
GetNetwork(cryptoCode); // Internally check if cryptoCode is correct
var listenedBlocks = new ConcurrentDictionary <string, string>();
var listenedDerivations = new ConcurrentDictionary <(Network, DerivationStrategyBase), DerivationStrategyBase>();
WebsocketMessageListener server = new WebsocketMessageListener(await HttpContext.WebSockets.AcceptWebSocketAsync(), _SerializerSettings);
CompositeDisposable subscriptions = new CompositeDisposable();
subscriptions.Add(_EventAggregator.Subscribe <Events.NewBlockEvent>(async o =>
{
if (listenedBlocks.ContainsKey(o.CryptoCode))
{
var chain = ChainProvider.GetChain(o.CryptoCode);
if (chain == null)
{
return;
}
var block = chain.GetBlock(o.BlockId);
if (block != null)
{
await server.Send(new Models.NewBlockEvent()
{
CryptoCode = o.CryptoCode,
Hash = block.HashBlock,
Height = block.Height,
PreviousBlockHash = block?.Previous.HashBlock
});
}
}
}));
subscriptions.Add(_EventAggregator.Subscribe <Events.NewTransactionMatchEvent>(async o =>
{
var network = Waiters.GetWaiter(o.CryptoCode);
if (network == null)
{
return;
}
if (listenedDerivations.ContainsKey((network.Network.NBitcoinNetwork, o.Match.DerivationStrategy)))
{
var chain = ChainProvider.GetChain(o.CryptoCode);
if (chain == null)
{
return;
}
var blockHeader = o.BlockId == null ? null : chain.GetBlock(o.BlockId);
await server.Send(new Models.NewTransactionEvent()
{
CryptoCode = o.CryptoCode,
DerivationStrategy = o.Match.DerivationStrategy,
BlockId = blockHeader?.HashBlock,
TransactionData = ToTransactionResult(includeTransaction, chain, new[] { o.SavedTransaction }),
Inputs = o.Match.Inputs,
Outputs = o.Match.Outputs
});
}
}));
try
{
while (server.Socket.State == WebSocketState.Open)
{
object message = await server.NextMessageAsync(cancellation);
switch (message)
{
case Models.NewBlockEventRequest r:
r.CryptoCode = r.CryptoCode ?? cryptoCode;
listenedBlocks.TryAdd(r.CryptoCode, r.CryptoCode);
break;
case Models.NewTransactionEventRequest r:
r.CryptoCode = r.CryptoCode ?? cryptoCode;
var network = Waiters.GetWaiter(r.CryptoCode)?.Network;
if (network == null)
{
break;
}
foreach (var derivation in r.DerivationSchemes)
{
var parsed = new DerivationStrategyFactory(network.NBitcoinNetwork).Parse(derivation);
listenedDerivations.TryAdd((network.NBitcoinNetwork, parsed), parsed);
}
break;
default:
break;
}
}
}
catch when(server.Socket.State != WebSocketState.Open)
{
}
finally { subscriptions.Dispose(); await server.DisposeAsync(cancellation); }
return(new EmptyResult());
}
public static void DisposeWith(this IDisposable disposable, CompositeDisposable composite)
{
if (composite == null || disposable == null)
return;
composite.Add(disposable);
}
public void Initialize()
{
#region bind events
CompositeDisposable.Add(
Observable.FromEvent <bool>(
h => MainWindowModel.WindowCommandsDisplayChanged += h,
h => MainWindowModel.WindowCommandsDisplayChanged -= h)
.Subscribe(visible =>
{
var offset = visible
? Interlocked.Increment(ref _visibleCount)
: Interlocked.Decrement(ref _visibleCount);
ShowWindowCommands = offset >= 0;
}));
CompositeDisposable.Add(
Observable.FromEvent <TaskDialogOptions>(
h => MainWindowModel.TaskDialogRequested += h,
h => MainWindowModel.TaskDialogRequested -= h)
.Subscribe(options => this.Messenger.RaiseSafe(() =>
new TaskDialogMessage(options))));
CompositeDisposable.Add(
Observable.FromEvent(
h => MainWindowModel.StateStringChanged += h,
h => MainWindowModel.StateStringChanged -= h)
.Subscribe(_ => RaisePropertyChanged(() => StateString)));
CompositeDisposable.Add(
Observable.Interval(TimeSpan.FromSeconds(0.5))
.Subscribe(_ => UpdateStatistics()));
CompositeDisposable.Add(
Observable.FromEvent <AccountSelectDescription>(
h => MainWindowModel.AccountSelectActionRequested += h,
h => MainWindowModel.AccountSelectActionRequested -= h)
.Subscribe(
desc =>
{
// ensure close before opening.
_globalAccountSelectionFlipViewModel.Close();
_globalAccountSelectionFlipViewModel.SelectedAccounts =
desc.SelectionAccounts;
_globalAccountSelectionFlipViewModel.SelectionReason = "";
switch (desc.AccountSelectionAction)
{
case AccountSelectionAction.Favorite:
_globalAccountSelectionFlipViewModel.SelectionReason =
"favorite";
break;
case AccountSelectionAction.Retweet:
_globalAccountSelectionFlipViewModel.SelectionReason =
"retweet";
break;
}
IDisposable disposable = null;
disposable = Observable.FromEvent(
h => _globalAccountSelectionFlipViewModel.Closed += h,
h => _globalAccountSelectionFlipViewModel.Closed -= h)
.Subscribe(_ =>
{
if (disposable == null)
{
return;
}
disposable.Dispose();
disposable = null;
desc.Callback(
this._globalAccountSelectionFlipViewModel
.SelectedAccounts);
});
_globalAccountSelectionFlipViewModel.Open();
}));
CompositeDisposable.Add(
Observable.FromEvent(
h => ThemeManager.ThemeChanged += h,
h => ThemeManager.ThemeChanged -= h
).Subscribe(_ => this.Messenger.RaiseAsync(new InteractionMessage("InvalidateTheme"))));
#endregion
#region special navigations
// check first boot
if (Setting.IsFirstGenerated)
{
var kovm = new KeyOverrideViewModel();
Messenger.RaiseSafeSync(() => new TransitionMessage(
typeof(KeyOverrideWindow),
kovm, TransitionMode.Modal, null));
}
// register new account if accounts haven't been authorized yet
if (!Setting.Accounts.Collection.Any())
{
var auth = new AuthorizationViewModel();
auth.AuthorizeObservable
.Subscribe(Setting.Accounts.Collection.Add);
Messenger.RaiseSafeSync(() => new TransitionMessage(
typeof(AuthorizationWindow),
auth, TransitionMode.Modal, null));
}
#endregion
TabManager.Load();
TabManager.Save();
if (TabManager.Columns.Count == 1 && TabManager.Columns[0].Tabs.Count == 0)
{
// lost tab info
this.ReInitTabs();
}
// check cleanup parameter
if (Setting.AutoCleanupTweets.Value &&
Setting.AutoCleanupThreshold.Value < 0)
{
var msg = this.Messenger.GetResponseSafe(() =>
new TaskDialogMessage(new TaskDialogOptions
{
Title = AppInitResources.MsgCleanupConfigTitle,
MainIcon = VistaTaskDialogIcon.Information,
MainInstruction = AppInitResources.MsgCleanupConfigInst,
Content = AppInitResources.MsgCleanupConfigContent,
ExpandedInfo = AppInitResources.MsgCleanupConfigExInfo,
CommonButtons = TaskDialogCommonButtons.YesNo
}));
Setting.AutoCleanupTweets.Value = msg.Response.Result == TaskDialogSimpleResult.Yes;
Setting.AutoCleanupThreshold.Value = 100000;
}
// check execution properties
if (Setting.ShowStartupConfigurationWarning.Value)
{
if (App.ExecutionMode == ExecutionMode.Standalone)
{
var msg = this.Messenger.GetResponseSafe(() =>
new TaskDialogMessage(new TaskDialogOptions
{
Title = AppInitResources.MsgExecModeWarningTitle,
MainIcon = VistaTaskDialogIcon.Warning,
MainInstruction = AppInitResources.MsgExecModeWarningInst,
Content = AppInitResources.MsgExecModeWarningContent,
FooterIcon = VistaTaskDialogIcon.Error,
FooterText = AppInitResources.MsgExecModeWarningFooter,
CommonButtons = TaskDialogCommonButtons.Close,
VerificationText = Resources.MsgDoNotShowAgain
}));
Setting.ShowStartupConfigurationWarning.Value = !msg.Response.VerificationChecked.GetValueOrDefault();
}
else if (App.DatabaseDirectoryUserSpecified)
{
var msg = this.Messenger.GetResponseSafe(() =>
new TaskDialogMessage(new TaskDialogOptions
{
Title = AppInitResources.MsgDatabasePathWarningTitle,
MainIcon = VistaTaskDialogIcon.Warning,
MainInstruction = AppInitResources.MsgDatabasePathWarningInst,
Content = AppInitResources.MsgDatabasePathWarningContent,
FooterIcon = VistaTaskDialogIcon.Error,
FooterText = AppInitResources.MsgDatabasePathWarningFooter,
CommonButtons = TaskDialogCommonButtons.Close,
VerificationText = Resources.MsgDoNotShowAgain
}));
Setting.ShowStartupConfigurationWarning.Value = !msg.Response.VerificationChecked.GetValueOrDefault();
}
}
Task.Run(() => App.RaiseUserInterfaceReady());
// initially focus to timeline
MainWindowModel.SetFocusTo(FocusRequest.Timeline);
PostInitialize();
}
public ToolViewViewModel(
IKCVDBClient client,
string sessionId,
IDispatcher dispatcher)
: base(dispatcher)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (sessionId == null)
{
throw new ArgumentNullException(nameof(sessionId));
}
Client = client;
SessionId = sessionId;
// Register metrics
CustomMetrics.Add(new StartedTimeMetrics(DateTimeOffset.Now));
CustomMetrics.Add(new TransferredApiCountMetrics(Client));
CustomMetrics.Add(new SuccessCountMetrics(Client));
CustomMetrics.Add(new FailureCountMetrics(Client));
CustomMetrics.Add(new TransferredDataAmountMetrics(Client));
CustomMetrics.Add(new TransferredDataAmountPerHourMetrics(Client));
// Register a listener to update history
Observable.FromEventPattern <ApiDataSentEventArgs>(Client, nameof(Client.ApiDataSent))
.Select(x => x.EventArgs)
.Select(x => {
var now = DateTimeOffset.Now;
return(x.ApiData.Select(apiData => new HistoryItem {
Time = now,
Body = apiData.RequestUri.PathAndQuery,
Success = true,
}));
})
.SubscribeOnDispatcher(System.Windows.Threading.DispatcherPriority.Normal)
.Subscribe(historyItems => {
try {
HistoryItems = new ObservableCollection <HistoryItem>(
historyItems.Reverse().Concat(HistoryItems).Take(MaxHistoryCount));
}
catch (Exception ex) {
TelemetryClient.TrackException("Failed to update history.", ex);
if (ex.IsCritical())
{
throw;
}
}
});
// Register a listener to notify chinese option chaning
Subscriptions.Add(Observable.FromEventPattern <PropertyChangedEventArgs>(Settings.Default, nameof(Settings.PropertyChanged))
.Where(x => x.EventArgs.PropertyName == nameof(Settings.ShowTraditionalChinese))
.SubscribeOnDispatcher()
.Subscribe(_ => {
try {
RaisePropertyChanged(nameof(EnableSendingTelemetry));
RaisePropertyChanged(nameof(ShowTraditionalChinese));
}
catch (Exception ex) {
TelemetryClient.TrackException("Failed to raise property chaning of show traditional chinese option", ex);
if (ex.IsCritical())
{
throw;
}
}
}));
// Register a listener to receive language switching event
Subscriptions.Add(Observable.FromEventPattern <PropertyChangedEventArgs>(ResourceHolder.Instance, nameof(ResourceHolder.PropertyChanged))
.Where(x => x.EventArgs.PropertyName == nameof(ResourceHolder.Culture))
.SubscribeOnDispatcher()
.Subscribe(_ => {
try {
CurrentLanguageTwoLetterName = ResourceHolder.Instance.Culture?.TwoLetterISOLanguageName;
}
catch (Exception ex) {
TelemetryClient.TrackException("Failed to update current language two letter name.", ex);
if (ex.IsCritical())
{
throw;
}
}
}));
CurrentLanguageTwoLetterName = ResourceHolder.Instance.Culture?.TwoLetterISOLanguageName;
}
public VirtualClockTests(ITestOutputHelper output)
{
disposables.Add(LogEvents.Subscribe(e => output.WriteLine(e.ToLogString())));
}
public void AddDisposable(IDisposable disposable)
{
disposables.Add(disposable);
}
private IDisposable StartStreaming(IInternalResultCursor cursor,
IObserver <IRecord> recordObserver = null, IObserver <IResultSummary> summaryObserver = null)
{
var cancellation = new CompositeDisposable(2);
if (summaryObserver != null)
{
cancellation.Add(_summary.Subscribe(summaryObserver));
}
if (StartStreaming())
{
if (recordObserver != null)
{
cancellation.Add(_records.Subscribe(recordObserver));
}
var streamingCancellation = new CancellationDisposable();
cancellation.Add(streamingCancellation);
Task.Run(async() =>
{
try
{
// Ensure that we propagate any errors from the KeysAsync call
await cursor.KeysAsync().ConfigureAwait(false);
if (!_records.HasObservers)
{
cursor.Cancel();
}
else
{
streamingCancellation.Token.Register(cursor.Cancel);
}
while (await cursor.FetchAsync().ConfigureAwait(false))
{
_records.OnNext(cursor.Current);
}
_records.OnCompleted();
}
catch (Exception exc)
{
_records.OnError(exc);
if (summaryObserver != null)
{
_summary.OnError(exc);
}
}
try
{
_summary.OnNext(await cursor.ConsumeAsync().ConfigureAwait(false));
_summary.OnCompleted();
}
catch (Exception exc)
{
_summary.OnError(exc);
}
CompleteStreaming();
}, streamingCancellation.Token);
}
else
{
recordObserver?.OnError(new ResultConsumedException(
"Streaming has already started and/or finished with a previous Records or Summary subscription."));
}
return(cancellation);
}
public void Events_committed_to_the_event_store_are_caught_up_by_multiple_independent_read_model_stores()
{
var productName = Any.Paragraph(4);
var projector1 = new Projector <Order.ItemAdded>(() => new ReadModels1DbContext())
{
OnUpdate = (work, e) => new ReadModels1DbContext().DisposeAfter(db => UpdateReservedInventory(db, e))
};
var projector2 = new Projector <Order.ItemAdded>(() => new ReadModels2DbContext())
{
OnUpdate = (work, e) => new ReadModels2DbContext().DisposeAfter(db => UpdateReservedInventory(db, e))
};
var numberOfEvents = Any.Int(10, 50);
using (var disposables = new CompositeDisposable())
using (var catchup1 = CreateReadModelCatchup <ReadModels1DbContext>(projector1))
using (var catchup2 = CreateReadModelCatchup <ReadModels2DbContext>(projector2))
{
catchup1.Progress.ForEachAsync(p => Console.WriteLine("catchup1: " + p));
catchup2.Progress.ForEachAsync(p => Console.WriteLine("catchup2: " + p));
Action <string, ThreadStart> startThread =
(name, start) =>
{
var thread = new Thread(() =>
{
Console.WriteLine("starting thread (" + Thread.CurrentThread.ManagedThreadId + ")");
start();
Console.WriteLine("ended thread (" + Thread.CurrentThread.ManagedThreadId + ")");
});
thread.Name = name;
thread.Start();
disposables.Add(Disposable.Create(thread.Abort));
};
Events.Write(numberOfEvents, i => new Order.ItemAdded
{
ProductName = productName,
Quantity = 1,
AggregateId = Any.Guid()
});
// TODO: (Events_committed_to_the_event_store_are_caught_up_by_multiple_independent_read_model_stores) is this leading to intermittent test failures by leaving a dangling app lock?
startThread("catchup1", () =>
{
catchup1.Run().Wait();
catchup1.Dispose();
});
startThread("catchup2", () =>
{
catchup2.Run().Wait();
catchup2.Dispose();
});
Console.WriteLine("Waiting on catchups to complete");
// wait on both catchups to complete
catchup1
.Progress
.Merge(catchup2.Progress)
.Where(p => p.IsEndOfBatch)
.Take(2)
.Timeout(DefaultTimeout)
.Wait();
}
Action <DbContext> verify = db =>
{
var readModelInfoName = ReadModelInfo.NameForProjector(projector1);
var readModelInfos = db.Set <ReadModelInfo>();
Console.WriteLine(new { readModelInfos }.ToLogString());
readModelInfos
.Single(i => i.Name == readModelInfoName)
.CurrentAsOfEventId
.Should()
.Be(HighestEventId + numberOfEvents);
var productInventories = db.Set <ProductInventory>();
Console.WriteLine(new { productInventories }.ToLogString());
productInventories
.Single(pi => pi.ProductName == productName)
.QuantityReserved
.Should()
.Be(numberOfEvents);
};
Console.WriteLine("verifying ReadModels1DbContext...");
new ReadModels1DbContext().DisposeAfter(r => verify(r));
Console.WriteLine("verifying ReadModels2DbContext...");
new ReadModels2DbContext().DisposeAfter(r => verify(r));
}
protected void AddToDisposable(IDisposable disposable)
{
disposables.Add(disposable);
}
public TestDependencyTests(ITestOutputHelper output)
{
disposables.Add(LogEvents.Subscribe(e => output.WriteLine(e.ToLogString())));
}
private ValidationBinding(IObservable <Unit> validationObservable)
{
_disposables.Add(validationObservable.Subscribe());
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
onUnloaded = new CompositeDisposable();
var keyboardHost = VisualAndLogicalTreeHelper.FindVisualParent <KeyboardHost>(this);
// If key isn't visible, it won't have a visual parent and this is okay.
if (keyboardHost == null && !this.IsVisible)
{
return;
}
var mainViewModel = keyboardHost.DataContext as MainViewModel;
var keyStateService = mainViewModel.KeyStateService;
var capturingStateManager = mainViewModel.CapturingStateManager;
//Calculate KeyDownState
if (Value != null)
{
var keyStateSubscription = keyStateService.KeyDownStates[Value]
.OnPropertyChanges(kds => kds.Value)
.Subscribe(value => KeyDownState = value);
onUnloaded.Add(keyStateSubscription);
}
KeyDownState = (Value == null) ? KeyDownStates.Up : keyStateService.KeyDownStates[Value].Value;
//Calculate SelectionProgress and SelectionInProgress
if (Value != null)
{
var keySelectionProgressSubscription = keyStateService.KeySelectionProgress[Value]
.OnPropertyChanges(ksp => ksp.Value)
.Subscribe(value =>
{
SelectionProgress = value;
SelectionInProgress = value > 0d;
});
onUnloaded.Add(keySelectionProgressSubscription);
}
var progress = (Value == null) ? 0 : keyStateService.KeySelectionProgress[Value].Value;
SelectionProgress = progress;
SelectionInProgress = progress > 0d;
//Calculate IsEnabled
Action calculateIsEnabled = () => IsEnabled = keyStateService.KeyEnabledStates[Value];
var keyEnabledSubscription = keyStateService.KeyEnabledStates
.OnAnyPropertyChanges()
.Subscribe(_ => calculateIsEnabled());
onUnloaded.Add(keyEnabledSubscription);
calculateIsEnabled();
//Calculate IsCurrent
Action <KeyValue> calculateIsCurrent = value => IsCurrent = value != null && Value != null && value.Equals(Value);
var currentPositionSubscription = mainViewModel.OnPropertyChanges(vm => vm.CurrentPositionKey)
.Subscribe(calculateIsCurrent);
onUnloaded.Add(currentPositionSubscription);
calculateIsCurrent(mainViewModel.CurrentPositionKey);
//Calculate DisplayShiftDownText
//Display shift down text (upper case text) if shift is locked down, or down (but NOT when we are capturing a multi key selection)
Action <KeyDownStates, bool> calculateDisplayShiftDownText = (shiftDownState, capturingMultiKeySelection) =>
DisplayShiftDownText = shiftDownState == KeyDownStates.LockedDown ||
(shiftDownState == KeyDownStates.Down && !capturingMultiKeySelection);
var capturingMultiKeySelectionSubscription = capturingStateManager
.OnPropertyChanges(csm => csm.CapturingMultiKeySelection)
.Subscribe(value => calculateDisplayShiftDownText(keyStateService.KeyDownStates[KeyValues.LeftShiftKey].Value, value));
onUnloaded.Add(capturingMultiKeySelectionSubscription);
var leftShiftKeyStateSubscription = keyStateService.KeyDownStates[KeyValues.LeftShiftKey]
.OnPropertyChanges(sds => sds.Value)
.Subscribe(value => calculateDisplayShiftDownText(value, capturingStateManager.CapturingMultiKeySelection));
onUnloaded.Add(leftShiftKeyStateSubscription);
calculateDisplayShiftDownText(keyStateService.KeyDownStates[KeyValues.LeftShiftKey].Value, capturingStateManager.CapturingMultiKeySelection);
//Publish own version of KeySelection event
var keySelectionSubscription = Observable.FromEventPattern <KeyValue>(
handler => mainViewModel.KeySelection += handler,
handler => mainViewModel.KeySelection -= handler)
.Subscribe(pattern =>
{
if (Value != null &&
pattern.EventArgs.Equals(Value) &&
Selection != null)
{
Selection(this, null);
}
});
onUnloaded.Add(keySelectionSubscription);
}
/// <summary>
/// Initializes a new instance of the <see cref="BasePropertyValidation{TViewModel}"/> class.
/// </summary>
protected BasePropertyValidation()
{
// subscribe to the valid subject so we can assign the validity
_disposables.Add(_isValidSubject.Subscribe(v => _isValid = v));
}
public RepositoryHosts(
IRepositoryHostFactory repositoryHostFactory,
ISharedCache sharedCache,
IConnectionManager connectionManager)
{
Guard.ArgumentNotNull(repositoryHostFactory, nameof(repositoryHostFactory));
Guard.ArgumentNotNull(sharedCache, nameof(sharedCache));
Guard.ArgumentNotNull(connectionManager, nameof(connectionManager));
this.connectionManager = connectionManager;
RepositoryHostFactory = repositoryHostFactory;
GitHubHost = DisconnectedRepositoryHost;
EnterpriseHost = DisconnectedRepositoryHost;
var persistEntepriseHostObs = this.WhenAny(x => x.EnterpriseHost, x => x.Value)
.Skip(1) // The first value will be null or something already in the db
.SelectMany(enterpriseHost =>
{
if (!enterpriseHost.IsLoggedIn)
{
return(sharedCache.UserAccount
.InvalidateObject <Uri>(EnterpriseHostApiBaseUriCacheKey)
.Catch <Unit, Exception>(ex =>
{
log.Warn("Failed to invalidate enterprise host uri", ex);
return Observable.Return(Unit.Default);
}));
}
return(sharedCache.UserAccount
.InsertObject(EnterpriseHostApiBaseUriCacheKey, enterpriseHost.Address.ApiUri)
.Catch <Unit, Exception>(ex =>
{
log.Warn("Failed to persist enterprise host uri", ex);
return Observable.Return(Unit.Default);
}));
});
isLoggedInToAnyHost = this.WhenAny(
x => x.GitHubHost.IsLoggedIn,
x => x.EnterpriseHost.IsLoggedIn,
(githubLoggedIn, enterpriseLoggedIn) => githubLoggedIn.Value || enterpriseLoggedIn.Value)
.ToProperty(this, x => x.IsLoggedInToAnyHost);
// This part is strictly to support having the IConnectionManager request that a connection
// be logged in. It doesn't know about hosts or load anything reactive, so it gets
// informed of logins by an observable returned by the event
connectionManager.DoLogin += RunLoginHandler;
// monitor the list of connections so we can log out hosts when connections are removed
disposables.Add(
connectionManager.Connections.CreateDerivedCollection(x => x)
.ItemsRemoved
.SelectMany(async x =>
{
var host = LookupHost(x.HostAddress);
if (host.Address != x.HostAddress)
{
host = await RepositoryHostFactory.Create(x.HostAddress);
}
return(host);
})
.Select(h => LogOut(h))
.Merge().ToList().Select(_ => Unit.Default).Subscribe());
// Wait until we've loaded (or failed to load) an enterprise uri from the db and then
// start tracking changes to the EnterpriseHost property and persist every change to the db
disposables.Add(persistEntepriseHostObs.Subscribe());
}
public BindingDiagDialog(IServiceProvider provider, Site site)
: base(provider)
{
InitializeComponent();
var container = new CompositeDisposable();
FormClosed += (sender, args) => container.Dispose();
container.Add(
Observable.FromEventPattern <EventArgs>(btnGenerate, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
txtResult.Clear();
try
{
Debug($"System Time: {DateTime.Now}");
Debug($"Processor Architecture: {Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE")}");
Debug($"OS: {Environment.OSVersion}");
Debug($"Server Type: {site.Server.Mode.AsString(EnumFormat.Description)}");
Debug("-----");
var adapters = Dns.GetHostEntry(string.Empty).AddressList.Where(address => !address.IsIPv6LinkLocal).ToList();
if (adapters.Count == 0)
{
Warn("This machine has no suitable IP address to accept external traffic.");
}
else
{
Info($"This machine has {adapters.Count} IP addresses to take external traffic.");
foreach (IPAddress address in adapters)
{
Info($"* {address}.");
}
}
Debug("-----");
Debug($"[W3SVC/{site.Id}]");
Debug($"ServerComment : {site.Name}");
Debug($"ServerAutoStart: {site.ServerAutoStart}");
Debug($"ServerState : {site.State}");
Debug(string.Empty);
var feature = new ReservedUrlsFeature((Module)provider);
feature.Load();
foreach (Binding binding in site.Bindings)
{
Debug($"BINDING: {binding.Protocol} {binding}");
if (binding.Protocol == "https" || binding.Protocol == "http")
{
if (binding.Host != "localhost")
{
if (site.Server.Mode == WorkingMode.IisExpress)
{
var reservation = binding.ToUrlPrefix();
if (!feature.Items.Any(item => item.UrlPrefix == reservation))
{
Warn($"URL reservation {reservation} is missing. So this binding only works if IIS Express runs as administrator.");
}
}
Info($"This site can take external traffic if,");
Info($" * TCP port {binding.EndPoint.Port} must be opened on Windows Firewall (or any other equivalent products).");
}
if (binding.EndPoint.Address.Equals(IPAddress.Any))
{
if (binding.Host != "localhost")
{
Info($" * Requests from web browsers must be routed to following end points on this machine,");
foreach (IPAddress address in adapters)
{
Info($" * {address}:{binding.EndPoint.Port}.");
}
}
if (Socket.OSSupportsIPv4)
{
Debug($"This site can take local traffic at {IPAddress.Loopback}:{binding.EndPoint.Port}.");
}
if (Socket.OSSupportsIPv6)
{
Debug($"This site can take local traffic at [{IPAddress.IPv6Loopback}]:{binding.EndPoint.Port}.");
}
}
else
{
Info($" * The networking must be properly set up to forward requests from web browsers to {binding.EndPoint} on this machine.");
}
if (binding.Host == "*" || binding.Host == string.Empty)
{
if (binding.EndPoint.Address.Equals(IPAddress.Any))
{
Info($" * Web browsers can use several URLs, such as");
foreach (IPAddress address in adapters)
{
Debug($" * {binding.Protocol}://{address}:{binding.EndPoint.Port}.");
}
Info($" * {binding.Protocol}://localhost:{binding.EndPoint.Port}.");
Info($" * {binding.Protocol}://{IPAddress.Loopback}:{binding.EndPoint.Port}.");
Info($" * {binding.Protocol}://[{IPAddress.IPv6Loopback}]:{binding.EndPoint.Port}.");
}
else
{
Info($" * Web browsers should use URL {binding.Protocol}://{binding.EndPoint.Address}:{binding.EndPoint.Port}.");
}
}
else
{
Info($" * Web browsers should use URL {binding.Protocol}://{binding.Host}:{binding.EndPoint.Port}. Requests must have Host header {binding.Host}.");
var entry = Dns.GetHostEntry(binding.Host);
var list = entry.AddressList;
var found = false;
foreach (var address in list)
{
if (adapters.Any(item => address.Equals(item)))
{
found = true;
break;
}
if (address.Equals(IPAddress.Loopback))
{
found = true;
}
}
if (!found)
{
Warn($" DNS query does not return a known IP address for any network adapter of this machine. Please review your DNS settings or modify the hosts file.");
}
}
if (binding.Protocol == "https")
{
Warn($"Please run SSL Diagnostics at server level to analyze SSL configuration. More information can be found at https://www.jexusmanager.com/en/latest/tutorials/ssl-diagnostics.html.");
}
}
Debug(string.Empty);
}
}
catch (CryptographicException ex)
{
Debug(ex.ToString());
RollbarDotNet.Rollbar.Report(ex, custom: new Dictionary <string, object> {
{ "hResult", ex.HResult }
});
}
catch (Exception ex)
{
Debug(ex.ToString());
RollbarDotNet.Rollbar.Report(ex);
}
}));
container.Add(
Observable.FromEventPattern <EventArgs>(btnSave, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
var fileName = DialogHelper.ShowSaveFileDialog(null, "Text Files|*.txt|All Files|*.*");
if (string.IsNullOrEmpty(fileName))
{
return;
}
File.WriteAllText(fileName, txtResult.Text);
}));
}
public ImportCertificateDialog(IServiceProvider serviceProvider)
: base(serviceProvider)
{
InitializeComponent();
cbStore.SelectedIndex = 0;
if (Environment.OSVersion.Version < Version.Parse("6.2"))
{
// IMPORTANT: WebHosting store is available since Windows 8.
cbStore.Enabled = false;
}
if (!Helper.IsRunningOnMono())
{
JexusManager.NativeMethods.TryAddShieldToButton(btnOK);
}
var container = new CompositeDisposable();
FormClosed += (sender, args) => container.Dispose();
container.Add(
Observable.FromEventPattern <EventArgs>(btnBrowse, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
DialogHelper.ShowFileDialog(txtFile, ".pfx|*.pfx|*.*|*.*");
}));
container.Add(
Observable.FromEventPattern <EventArgs>(txtFile, "TextChanged")
.Sample(TimeSpan.FromSeconds(1))
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
btnOK.Enabled = !string.IsNullOrWhiteSpace(txtFile.Text);
}));
container.Add(
Observable.FromEventPattern <EventArgs>(btnOK, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
try
{
// Load your certificate from file
Item = new X509Certificate2(txtFile.Text, txtPassword.Text, X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet);
Store = cbStore.SelectedIndex == 0 ? "Personal" : "WebHosting";
var service = (IConfigurationService)GetService(typeof(IConfigurationService));
if (service.ServerManager.Mode == WorkingMode.Jexus)
{
var server = (JexusServerManager)service.Server;
// Public Key;
StringBuilder publicBuilder = new StringBuilder();
publicBuilder.AppendLine("-----BEGIN CERTIFICATE-----");
publicBuilder.AppendLine(Convert.ToBase64String(Item.Export(X509ContentType.Cert), Base64FormattingOptions.InsertLineBreaks));
publicBuilder.AppendLine("-----END CERTIFICATE-----");
var file = AsyncHelper.RunSync(() => server.SaveCertificateAsync(publicBuilder.ToString()));
server.SetCertificate(file);
// Private Key
RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)Item.PrivateKey;
MemoryStream memoryStream = new MemoryStream();
TextWriter streamWriter = new StreamWriter(memoryStream);
PemWriter pemWriter = new PemWriter(streamWriter);
AsymmetricCipherKeyPair keyPair = DotNetUtilities.GetRsaKeyPair(rsa);
pemWriter.WriteObject(keyPair.Private);
streamWriter.Flush();
string output = Encoding.ASCII.GetString(memoryStream.GetBuffer()).Trim();
int indexOfFooter = output.IndexOf("-----END RSA PRIVATE KEY-----", StringComparison.Ordinal);
memoryStream.Close();
streamWriter.Close();
string key = output.Substring(0, indexOfFooter + 29);
var keyFile = AsyncHelper.RunSync(() => server.SaveKeyAsync(key));
server.SetKeyFile(keyFile);
service.ServerManager.CommitChanges();
}
else
{
try
{
using (var process = new Process())
{
// add certificate
var start = process.StartInfo;
start.Verb = "runas";
start.FileName = "cmd";
start.Arguments = string.Format(
"/c \"\"{4}\" /f:\"{0}\" /p:{1} /n:\"{2}\" /s:{3}\"",
txtFile.Text,
txtPassword.Text,
Item.FriendlyName,
cbStore.SelectedIndex == 0 ? "MY" : "WebHosting",
Path.Combine(Environment.CurrentDirectory, "certificateinstaller.exe"));
start.CreateNoWindow = true;
start.WindowStyle = ProcessWindowStyle.Hidden;
process.Start();
process.WaitForExit();
if (process.ExitCode == 0)
{
DialogResult = DialogResult.OK;
}
else
{
MessageBox.Show(process.ExitCode.ToString());
}
}
}
catch (Exception)
{
// elevation is cancelled.
}
}
}
catch (Exception ex)
{
ShowError(ex, string.Empty, false);
}
}));
}
/// <summary>
/// Helper function to add IDisposables to a composible disposable.
/// This allows for easy chaining when using Reactive Extensions.
/// </summary>
/// <param name="disposable"></param>
/// <param name="compositeDisposable"></param>
public static void AddTo(this IDisposable disposable, CompositeDisposable compositeDisposable)
{
compositeDisposable.Add(disposable);
}
public WebServerTests(ITestOutputHelper output)
{
_disposables.Add(output.SubscribeToPocketLogger());
}
public CompositeKernelTests(ITestOutputHelper output)
{
_disposables.Add(output.SubscribeToPocketLogger());
}
protected void DisposeAfterTest(IDisposable disposable)
{
_disposables.Add(disposable);
}
public async Task BridgeTo(string destination, BridgeOptions options, Action<EventMessage> onProgress = null)
{
if (!IsAnswered && !IsPreAnswered)
{
return;
}
Log.Debug(() => "Channel {0} is attempting a bridge to {1}".Fmt(UUID, destination));
if (string.IsNullOrEmpty(options.UUID))
{
options.UUID = Guid.NewGuid().ToString();
}
var subscriptions = new CompositeDisposable();
subscriptions.Add(
eventSocket.Events.Where(x => x.UUID == options.UUID)
.Take(1)
.Subscribe(x => Bridge = new BridgeStatus(false, "In Progress", new BridgedChannel(x, eventSocket))));
if (onProgress != null)
{
subscriptions.Add(
eventSocket.Events.Where(x => x.UUID == options.UUID && x.EventName == EventName.ChannelProgress)
.Take(1)
.Subscribe(onProgress));
}
var result = await eventSocket.Bridge(UUID, destination, options).ConfigureAwait(false);
Log.Debug(() => "Channel {0} bridge complete {1} {2}".Fmt(UUID, result.Success, result.ResponseText));
subscriptions.Dispose();
Bridge = new BridgeStatus(result.Success, result.ResponseText, Bridge.Channel);
}
public SetRestrictionsDialog(IServiceProvider serviceProvider, ConfigurationSection section)
: base(serviceProvider)
{
InitializeComponent();
cbDomain.Checked = (bool)section["enableReverseDns"];
cbAccess.SelectedIndex = (bool)section["allowUnlisted"] ? 0 : 1;
cbProxy.Enabled = section.Schema.AttributeSchemas["enabled"] != null;
if (cbProxy.Enabled)
{
cbProxy.Checked = (bool)section["enableProxyMode"];
}
cbAction.Enabled = section.Schema.AttributeSchemas["denyAction"] != null;
if (cbAction.Enabled)
{
var action = (long)section["denyAction"];
if (action == 0L)
{
cbAction.SelectedIndex = 0;
}
else if (action == 401L)
{
cbAction.SelectedIndex = 1;
}
else if (action == 403L)
{
cbAction.SelectedIndex = 2;
}
else
{
cbAction.SelectedIndex = 3;
}
}
var container = new CompositeDisposable();
FormClosed += (sender, args) => container.Dispose();
container.Add(
Observable.FromEventPattern <EventArgs>(btnOK, "Click")
.ObserveOn(System.Threading.SynchronizationContext.Current)
.Subscribe(evt =>
{
section["enableReverseDns"] = cbDomain.Checked;
section["allowUnlisted"] = cbAccess.SelectedIndex == 0;
if (cbProxy.Enabled)
{
section["enableProxyMode"] = cbProxy.Checked;
}
if (cbAction.Enabled)
{
if (cbAction.SelectedIndex == 0)
{
section["denyAction"] = 0L;
}
else if (cbAction.SelectedIndex == 1)
{
section["denyAction"] = 401L;
}
else if (cbAction.SelectedIndex == 2)
{
section["denyAction"] = 403L;
}
else
{
section["denyAction"] = 404L;
}
}
DialogResult = DialogResult.OK;
}));
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
onUnloaded = new CompositeDisposable();
var keyboardHost = VisualAndLogicalTreeHelper.FindVisualParent<KeyboardHost>(this);
var mainViewModel = keyboardHost.DataContext as MainViewModel;
var keyStateService = mainViewModel.KeyStateService;
var capturingStateManager = mainViewModel.CapturingStateManager;
//Calculate KeyDownState
var keyStateSubscription = keyStateService.KeyDownStates[Value]
.OnPropertyChanges(kds => kds.Value)
.Subscribe(value => KeyDownState = value);
onUnloaded.Add(keyStateSubscription);
KeyDownState = keyStateService.KeyDownStates[Value].Value;
//Calculate SelectionProgress
var keySelectionProgressSubscription = keyStateService.KeySelectionProgress[Value]
.OnPropertyChanges(ksp => ksp.Value)
.Subscribe(value => SelectionProgress = value);
onUnloaded.Add(keySelectionProgressSubscription);
SelectionProgress = keyStateService.KeySelectionProgress[Value].Value;
//Calculate IsEnabled
Action calculateIsEnabled = () => IsEnabled = keyStateService.KeyEnabledStates[Value];
var keyEnabledSubscription = keyStateService.KeyEnabledStates
.OnAnyPropertyChanges()
.Subscribe(_ => calculateIsEnabled());
onUnloaded.Add(keyEnabledSubscription);
calculateIsEnabled();
//Calculate IsCurrent
Action<KeyValue?> calculateIsCurrent = value => IsCurrent = value != null && value.Value.Equals(Value);
var currentPositionSubscription = mainViewModel.OnPropertyChanges(vm => vm.CurrentPositionKey)
.Subscribe(calculateIsCurrent);
onUnloaded.Add(currentPositionSubscription);
calculateIsCurrent(mainViewModel.CurrentPositionKey);
//Calculate DisplayShiftDownText
Action<KeyDownStates, bool> calculateDisplayShiftDownText = (shiftDownState, capturingMultiKeySelection) =>
DisplayShiftDownText = shiftDownState == KeyDownStates.LockedDown
|| (shiftDownState == KeyDownStates.Down && !capturingMultiKeySelection);
var capturingMultiKeySelectionSubscription = capturingStateManager
.OnPropertyChanges(csm => csm.CapturingMultiKeySelection)
.Subscribe(value => calculateDisplayShiftDownText(keyStateService.KeyDownStates[KeyValues.LeftShiftKey].Value, value));
onUnloaded.Add(capturingMultiKeySelectionSubscription);
var leftShiftKeyStateSubscription = keyStateService.KeyDownStates[KeyValues.LeftShiftKey]
.OnPropertyChanges(sds => sds.Value)
.Subscribe(value => calculateDisplayShiftDownText(value, capturingStateManager.CapturingMultiKeySelection));
onUnloaded.Add(leftShiftKeyStateSubscription);
calculateDisplayShiftDownText(keyStateService.KeyDownStates[KeyValues.LeftShiftKey].Value, capturingStateManager.CapturingMultiKeySelection);
//Publish own version of KeySelection event
var keySelectionSubscription = Observable.FromEventPattern<KeyValue>(
handler => mainViewModel.KeySelection += handler,
handler => mainViewModel.KeySelection -= handler)
.Subscribe(pattern =>
{
if (pattern.EventArgs.Equals(Value)
&& Selection != null)
{
Selection(this, null);
}
});
onUnloaded.Add(keySelectionSubscription);
}
public MainWindowViewModel()
{
CompositeDisposable.Add(new PropertyChangedEventListener(m_Model, (s, ev) =>
{
switch (ev.PropertyName)
{
case nameof(m_Model.LyricsSource):
RaisePropertyChanged(nameof(LyricsSource));
break;
case nameof(m_Model.IsModified):
RaisePropertyChanged(nameof(IsModified));
break;
case nameof(m_Model.SavedFileNameWithoutExtension):
RaisePropertyChanged(nameof(DocumentName));
break;
}
}));
var synchronizationContext = SynchronizationContext.Current;
Debug.Assert(synchronizationContext != null, "SynchronizationContext.Current is null");
CompositeDisposable.Add(
m_Model.AsPropertyChanged(nameof(m_Model.ParserErrors))
.Throttle(TimeSpan.FromMilliseconds(1000))
.ObserveOn(synchronizationContext)
.Subscribe(_ =>
{
ParserErrors.Clear();
foreach (var item in m_Model.ParserErrors)
{
ParserErrors.Add(item);
}
})
);
CompositeDisposable.Add(new PropertyChangedEventListener(this, async(s, ev) =>
{
switch (ev.PropertyName)
{
case nameof(CaretLocation):
if (LyricsSource != null)
{
var logicalLineIndex = LyricsSource.LineMap.GetLogicalLineIndexByPhysical(CaretLocation.Line - 1);
if (logicalLineIndex >= 0)
{
await ForcusViewSyllableAsync(logicalLineIndex, 0);
}
}
break;
case nameof(CurrentSyllable):
if (LyricsSource != null)
{
var physicalLineIndex = LyricsSource.LineMap.GetPhysicalLineIndexByLogical(CurrentSyllable.Line);
await FocusEditorCharacterAsync(physicalLineIndex + 1, -1, false);
}
break;
}
}));
NewCommand = new HotKeyCommand(async() => await NewAsync())
{
Gesture = new KeyGesture(Key.N, ModifierKeys.Control)
};
OpenCommand = new HotKeyCommand(async() => await OpenAsync())
{
Gesture = new KeyGesture(Key.O, ModifierKeys.Control)
};
SaveAsCommand = new ViewModelCommand(async() => await SaveAsAsync());
SaveCommand = new HotKeyCommand(async() => await SaveAsync())
{
Gesture = new KeyGesture(Key.S, ModifierKeys.Control)
};
AutoSetRubyInSelectionCommand = new ViewModelCommand(AutoSetRubyInSelection);
HighlightFirstCommand = new ViewModelCommand(async() => await HighlightLyricsAsync(LyricsHighlightRequest.First));
HighlightNextCommand = new ViewModelCommand(async() => await HighlightLyricsAsync(LyricsHighlightRequest.Next));
HighlightPreviousCommand = new ViewModelCommand(async() => await HighlightLyricsAsync(LyricsHighlightRequest.Previous));
HighlightNextLineCommand = new ViewModelCommand(async() => await HighlightLyricsAsync(LyricsHighlightRequest.NextLine));
HighlightPreviousLineCommand = new ViewModelCommand(async() => await HighlightLyricsAsync(LyricsHighlightRequest.PreviousLine));
MoveCaretToSelectedErrorCommand = new ViewModelCommand(async() => await MoveCaretToSelectedErrorAsync());
}
public NewRuleBlockingDialog(IServiceProvider serviceProvider, InboundFeature rewriteFeature)
: base(serviceProvider)
{
InitializeComponent();
cbMode.SelectedIndex = 1;
cbInput.SelectedIndex = 0;
cbMatch.SelectedIndex = 0;
cbResponse.SelectedIndex = 1;
var container = new CompositeDisposable();
FormClosed += (sender, args) => container.Dispose();
container.Add(
Observable.FromEventPattern <EventArgs>(cbInput, "SelectedIndexChanged")
.Merge(Observable.FromEventPattern <EventArgs>(cbMode, "SelectedIndexChanged"))
.Subscribe(evt =>
{
switch (cbInput.SelectedIndex)
{
case 0:
lblPattern.Text = "Pattern (URL Path):";
lblExample.Text = cbMode.SelectedIndex == 1 ? "Example: IMG*.jpg" : "Example: ^IMG.*\\.jpg$";
break;
case 1:
lblPattern.Text = "Pattern (User-agent Header):";
lblExample.Text = cbMode.SelectedIndex == 1 ? "Example: Mozilla/4*" : "Example: ^Mozilla/[1234].*";
break;
case 2:
lblPattern.Text = "Pattern (IP Address):";
lblExample.Text = cbMode.SelectedIndex == 1 ? "Exmaple: 192.168.1.*" : "Example: 192\\.168\\.1\\.[1-9]";
break;
case 3:
lblPattern.Text = "Pattern (Query String):";
lblExample.Text = cbMode.SelectedIndex == 1 ? "Example: *id=*&p=*" : "Example: id=[0-9]+&p=[a-z]+";
break;
case 4:
lblPattern.Text = "Pattern (Referer):";
lblExample.Text = cbMode.SelectedIndex == 1 ? "Example: http://*.consoto.com" : "Example: http://(?:www\\.)?contoso\\.com$";
break;
case 5:
lblPattern.Text = "Pattern (Host Header):";
lblExample.Text = cbMode.SelectedIndex == 1 ? "Example: *.consoto.com" : "Example: (?:www\\.)?contoso\\.com$";
break;
}
}));
container.Add(
Observable.FromEventPattern <EventArgs>(txtPattern, "TextChanged")
.Sample(TimeSpan.FromSeconds(1))
.Subscribe(evt =>
{
btnOK.Enabled = !string.IsNullOrWhiteSpace(txtPattern.Text);
}));
container.Add(
Observable.FromEventPattern <EventArgs>(btnOK, "Click")
.Subscribe(evt =>
{
var inputType = cbInput.SelectedIndex;
var pattern = txtPattern.Text;
var match = cbMatch.SelectedIndex;
var response = cbResponse.SelectedIndex;
var mode = cbMode.SelectedIndex;
int index = 0;
string name;
do
{
index++;
name = string.Format("RequestBlockingRule{0}", index);
}while (rewriteFeature.Items.All(item => item.Name != name));
var newRule = new InboundRule(null);
newRule.Name = name;
newRule.Input = "URL Path";
newRule.Enabled = true;
newRule.PatternSyntax = mode == 0 ? 0L : 1L;
newRule.PatternUrl = mode == 0 ? ".*" : "*";
newRule.Type = response == 3 ? 4L : 3L;
newRule.ActionUrl = "{C:1}";
newRule.RedirectType = 301;
newRule.StatusCode = GetStatusCode(response);
newRule.SubStatusCode = 0;
newRule.StatusReason = GetReason(response);
newRule.StatusDescription = GetMessage(response);
newRule.Conditions.Add(
new ConditionItem(null)
{
Input = GetInput(inputType),
MatchType = match == 0 ? 4 : 5,
Pattern = pattern,
IgnoreCase = true
});
rewriteFeature.AddItem(newRule);
DialogResult = DialogResult.OK;
}));
}
private void ProcessSubscription(string subscriptionId,
IMessage message,
RequestStreamHandler <TRequest, TUpdate> requestStreamHandler)
{
// In order to prevent races/resource-leaks here we must:
// * Monitor session diconnections before attempting to create a request context.
// - Otherwise, a session could be destroyed and we would never clean up its resources, as we'd
// miss the notification.
// * Create the subscription to monitor sessions and add update our state all within a single
// critical region. In addition to this, we must ensure session destruction callbacks are
// fired on a different thread.
// - Otherwise, we may attempt to remove the session's resources before they are added.
var sessionId = message.SessionId;
var replyDestination = message.ReplyTo;
var subscription = new CompositeDisposable();
TRequest request;
if (!TryDeserializeRequest(subscriptionId, message, out request))
{
return;
}
var clientId = message.Properties.GetString(OperationKeys.ClientId);
if (clientId == null)
{
Log.Warning("No ClientId found. Ignoring.");
return;
}
var sessionDestroyedHandler = new AnonymousUserSessionHandler(_ => { },
_ =>
{
lock (_subscriptions)
{
// TODO: Make the Java version clean all resources hooked up here.
// ReSharper disable once AccessToDisposedClosure
subscription.Dispose();
_subscriptions.Remove(subscriptionId);
}
});
lock (_subscriptions)
{
// TODO: How do we clean up when IsSessionRequired == false?
if (IsSessionRequired)
{
subscription.Add(UserSessionCache.Subscribe(sessionId, sessionDestroyedHandler));
}
var context = CreateRequestContext(message);
if (context == null)
{
Log.Warning("Failed to create request context. Ignoring.");
subscription.Dispose(); // Don't listen for session destruction if it doesn't exist.
return;
}
// At this point we know the session exists or existed and we know it will be cleared up (after we
// exit the critical region) by the sessionResourceCleaner if it is destroyed.
_subscriptions.Add(subscriptionId, subscription);
try
{
const int notFinished = 0;
const int finished = 1;
var subscriptionState = notFinished;
var notificationSubscription = requestStreamHandler(context,
request,
new AnonymousStreamHandler <TUpdate>(
// TODO: I remove the session from the lookup AND ALSO dipose subscription here.
// This is analagous to the AutoDetachObserver<T> in Rx. Should we do the same in the Java version?
// Review with John. -ZB
update => OnUpdated(subscriptionId, replyDestination, update),
error =>
{
if (Interlocked.Exchange(ref subscriptionState, finished) ==
notFinished)
{
OnFailed(subscriptionId, replyDestination, error);
}
},
() =>
{
if (Interlocked.Exchange(ref subscriptionState, finished) ==
notFinished)
{
OnCompleted(subscriptionId, replyDestination);
}
}));
subscription.Add(Disposable.Create(() =>
{
var hasAlreadyFinished = Interlocked.Exchange(ref subscriptionState, finished) == finished;
if (!hasAlreadyFinished)
{
notificationSubscription.Dispose();
}
}));
}
catch (Exception e)
{
const string error = "Failed to process request";
OnFailed(subscriptionId, replyDestination, new MessagingException(error, e));
Log.Error(error, e);
}
}
SendAck(subscriptionId, replyDestination, clientId);
}
public CodeEditor() : base(new TextArea(), null)
{
TextArea.IndentationStrategy = null;
_shell = IoC.Get <IShell>();
_snippetManager = IoC.Get <SnippetManager>();
_lineNumberMargin = new LineNumberMargin(this);
_breakpointMargin = new BreakPointMargin(this, IoC.Get <IDebugManager2>()?.Breakpoints);
_selectedLineBackgroundRenderer = new SelectedLineBackgroundRenderer(this);
_bracketMatchingBackgroundRenderer = new BracketMatchingBackgroundRenderer(this);
_selectedWordBackgroundRenderer = new SelectedWordBackgroundRenderer();
_columnLimitBackgroundRenderer = new ColumnLimitBackgroundRenderer();
_selectedDebugLineBackgroundRenderer = new SelectedDebugLineBackgroundRenderer();
TextArea.TextView.Margin = new Thickness(10, 0, 0, 0);
TextArea.TextView.BackgroundRenderers.Add(_selectedDebugLineBackgroundRenderer);
TextArea.TextView.LineTransformers.Add(_selectedDebugLineBackgroundRenderer);
TextArea.TextView.BackgroundRenderers.Add(_bracketMatchingBackgroundRenderer);
TextArea.SelectionBrush = Brush.Parse("#AA569CD6");
TextArea.SelectionCornerRadius = 0;
void tunneledKeyUpHandler(object send, KeyEventArgs ee)
{
if (CaretOffset > 0)
{
_intellisenseManager?.OnKeyUp(ee, CaretOffset, TextArea.Caret.Line, TextArea.Caret.Column);
}
}
void tunneledKeyDownHandler(object send, KeyEventArgs ee)
{
if (CaretOffset > 0)
{
_intellisenseManager?.OnKeyDown(ee, CaretOffset, TextArea.Caret.Line, TextArea.Caret.Column);
if (ee.Key == Key.Tab && _currentSnippetContext == null && Editor is ICodeEditor codeEditor && codeEditor.LanguageService != null)
{
var wordStart = Document.FindPrevWordStart(CaretOffset);
if (wordStart > 0)
{
string word = Document.GetText(wordStart, CaretOffset - wordStart);
var codeSnippet = _snippetManager.GetSnippet(codeEditor.LanguageService, Editor.SourceFile.Project?.Solution, Editor.SourceFile.Project, word);
if (codeSnippet != null)
{
var snippet = SnippetParser.Parse(codeEditor.LanguageService, CaretOffset, TextArea.Caret.Line, TextArea.Caret.Column, codeSnippet.Snippet);
_intellisenseManager.CloseIntellisense();
using (Document.RunUpdate())
{
Document.Remove(wordStart, CaretOffset - wordStart);
_intellisenseManager.IncludeSnippets = false;
_currentSnippetContext = snippet.Insert(TextArea);
}
if (_currentSnippetContext.ActiveElements.Count() > 0)
{
IDisposable disposable = null;
disposable = Observable.FromEventPattern <SnippetEventArgs>(_currentSnippetContext, nameof(_currentSnippetContext.Deactivated)).Take(1).Subscribe(o =>
{
_currentSnippetContext = null;
_intellisenseManager.IncludeSnippets = true;
disposable.Dispose();
});
}
else
{
_currentSnippetContext = null;
_intellisenseManager.IncludeSnippets = true;
}
}
}
}
}
}
_disposables = new CompositeDisposable {
this.GetObservable(LineNumbersVisibleProperty).Subscribe(s =>
{
if (s)
{
TextArea.LeftMargins.Add(_lineNumberMargin);
}
else
{
TextArea.LeftMargins.Remove(_lineNumberMargin);
}
}),
this.GetObservable(ShowBreakpointsProperty).Subscribe(s =>
{
if (s)
{
TextArea.LeftMargins.Insert(0, _breakpointMargin);
}
else
{
TextArea.LeftMargins.Remove(_breakpointMargin);
}
}),
this.GetObservable(HighlightSelectedWordProperty).Subscribe(s =>
{
if (s)
{
TextArea.TextView.BackgroundRenderers.Add(_selectedWordBackgroundRenderer);
}
else
{
TextArea.TextView.BackgroundRenderers.Remove(_selectedWordBackgroundRenderer);
}
}),
this.GetObservable(HighlightSelectedLineProperty).Subscribe(s =>
{
if (s)
{
TextArea.TextView.BackgroundRenderers.Insert(0, _selectedLineBackgroundRenderer);
}
else
{
TextArea.TextView.BackgroundRenderers.Remove(_selectedLineBackgroundRenderer);
}
}),
this.GetObservable(ShowColumnLimitProperty).Subscribe(s =>
{
if (s)
{
TextArea.TextView.BackgroundRenderers.Add(_columnLimitBackgroundRenderer);
}
else
{
TextArea.TextView.BackgroundRenderers.Remove(_columnLimitBackgroundRenderer);
}
}),
this.GetObservable(ColumnLimitProperty).Subscribe(limit =>
{
_columnLimitBackgroundRenderer.Column = limit;
this.TextArea.TextView.InvalidateLayer(KnownLayer.Background);
}),
this.GetObservable(ContextActionsIconProperty).Subscribe(icon =>
{
if (_contextActionsRenderer != null)
{
_contextActionsRenderer.IconImage = icon;
}
}),
this.GetObservable(ColorSchemeProperty).Subscribe(colorScheme =>
{
if (colorScheme != null)
{
Background = colorScheme.Background;
Foreground = colorScheme.Text;
_lineNumberMargin.Background = colorScheme.Background;
if (_diagnosticMarkersRenderer != null)
{
_diagnosticMarkersRenderer.ColorScheme = colorScheme;
}
_textColorizer?.RecalculateBrushes();
TextArea.TextView.InvalidateLayer(KnownLayer.Background);
TextArea.TextView.Redraw();
}
}),
this.GetObservable(CaretOffsetProperty).Subscribe(s =>
{
if (Document?.TextLength > s)
{
CaretOffset = s;
TextArea.Caret.BringCaretToView();
}
}),
BackgroundRenderersProperty.Changed.Subscribe(s =>
{
if (s.Sender == this)
{
if (s.OldValue != null)
{
foreach (var renderer in (ObservableCollection <IBackgroundRenderer>)s.OldValue)
{
TextArea.TextView.BackgroundRenderers.Remove(renderer);
}
}
if (s.NewValue != null)
{
foreach (var renderer in (ObservableCollection <IBackgroundRenderer>)s.NewValue)
{
TextArea.TextView.BackgroundRenderers.Add(renderer);
}
}
}
}),
DocumentLineTransformersProperty.Changed.Subscribe(s =>
{
if (s.Sender == this)
{
if (s.OldValue != null)
{
foreach (var renderer in (ObservableCollection <IVisualLineTransformer>)s.OldValue)
{
TextArea.TextView.LineTransformers.Remove(renderer);
}
}
if (s.NewValue != null)
{
foreach (var renderer in (ObservableCollection <IVisualLineTransformer>)s.NewValue)
{
TextArea.TextView.LineTransformers.Add(renderer);
}
}
}
}),
Observable.FromEventPattern(TextArea.Caret, nameof(TextArea.Caret.PositionChanged)).Subscribe(e =>
{
if (_isLoaded && Document != null)
{
_lastLine = TextArea.Caret.Line;
EditorCaretOffset = TextArea.Caret.Offset;
Line = TextArea.Caret.Line;
Column = TextArea.Caret.Column;
var location = new TextViewPosition(Document.GetLocation(CaretOffset));
var visualLocation = TextArea.TextView.GetVisualPosition(location, VisualYPosition.LineBottom);
var visualLocationTop = TextArea.TextView.GetVisualPosition(location, VisualYPosition.LineTop);
var position = visualLocation - TextArea.TextView.ScrollOffset;
position = position.Transform(TextArea.TextView.TransformToVisual(TextArea).Value);
_intellisenseControl.SetLocation(position);
}
}),
Observable.FromEventPattern(TextArea.Caret, nameof(TextArea.Caret.PositionChanged)).Throttle(TimeSpan.FromMilliseconds(100)).ObserveOn(AvaloniaScheduler.Instance).Subscribe(e =>
{
if (Document != null)
{
var location = new TextViewPosition(Document.GetLocation(CaretOffset));
if (_intellisenseManager != null && !_textEntering)
{
if (TextArea.Selection.IsEmpty)
{
_intellisenseManager.SetCursor(CaretOffset, location.Line, location.Column, UnsavedFiles.ToList());
}
else if (_currentSnippetContext != null)
{
var offset = Document.GetOffset(TextArea.Selection.StartPosition.Location);
_intellisenseManager.SetCursor(offset, TextArea.Selection.StartPosition.Line, TextArea.Selection.StartPosition.Column, UnsavedFiles.ToList());
}
}
_selectedWordBackgroundRenderer.SelectedWord = GetWordAtOffset(CaretOffset);
TextArea.TextView.InvalidateLayer(KnownLayer.Background);
}
}),
this.WhenAnyValue(x => x.DebugHighlight).Where(loc => loc != null).Subscribe(location =>
{
if (location.Line != -1)
{
SetDebugHighlight(location.Line, location.StartColumn, location.EndColumn);
}
else
{
ClearDebugHighlight();
}
}),
this.GetObservable(EditorProperty).Subscribe(editor =>
{
if (editor != null)
{
if (editor.SourceFile.Project?.Solution != null)
{
_snippetManager.InitialiseSnippetsForSolution(editor.SourceFile.Project.Solution);
}
if (editor.SourceFile.Project != null)
{
_snippetManager.InitialiseSnippetsForProject(editor.SourceFile.Project);
}
SyntaxHighlighting = CustomHighlightingManager.Instance.GetDefinition(editor.SourceFile.ContentType);
if (editor.Document is AvalonStudioTextDocument td && Document != td.Document)
{
Document = td.Document;
if (editor.Offset <= Document.TextLength)
{
CaretOffset = editor.Offset;
}
_textColorizer = new TextColoringTransformer(Document);
_scopeLineBackgroundRenderer = new ScopeLineBackgroundRenderer(Document);
TextArea.TextView.BackgroundRenderers.Add(_scopeLineBackgroundRenderer);
TextArea.TextView.LineTransformers.Insert(0, _textColorizer);
_diagnosticMarkersRenderer = new TextMarkerService(Document);
_contextActionsRenderer = new ContextActionsRenderer(this, _diagnosticMarkersRenderer);
TextArea.LeftMargins.Add(_contextActionsRenderer);
TextArea.TextView.BackgroundRenderers.Add(_diagnosticMarkersRenderer);
}
if (editor is ICodeEditor codeEditor)
{
if (codeEditor.Highlights != null)
{
_disposables.Add(
Observable.FromEventPattern <NotifyCollectionChangedEventArgs>(codeEditor.Highlights, nameof(codeEditor.Highlights.CollectionChanged))
.Subscribe(observer =>
{
var e = observer.EventArgs;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var(tag, highlightList) in e.NewItems.Cast <(object tag, SyntaxHighlightDataList highlightList)>())
{
_textColorizer.SetTransformations(tag, highlightList);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var(tag, highlightList) in e.OldItems.Cast <(object tag, SyntaxHighlightDataList highlightList)>())
{
_textColorizer.RemoveAll(i => i.Tag == tag);
}
break;
case NotifyCollectionChangedAction.Reset:
foreach (var(tag, highlightList) in e.OldItems.Cast <(object tag, SyntaxHighlightDataList highlightList)>())
{
_textColorizer.RemoveAll(i => true);
}
break;
default:
throw new NotSupportedException();
}
TextArea.TextView.Redraw();
}));
_disposables.Add(
Observable.FromEventPattern <NotifyCollectionChangedEventArgs>(codeEditor.Diagnostics, nameof(codeEditor.Diagnostics.CollectionChanged))
.Subscribe(observer =>
{
var e = observer.EventArgs;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var(tag, diagnostics) in e.NewItems.Cast <(object tag, IEnumerable <Diagnostic> diagnostics)>())
{
_diagnosticMarkersRenderer.SetDiagnostics(tag, diagnostics);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var(tag, diagnostics) in e.OldItems.Cast <(object tag, IEnumerable <Diagnostic> diagnostics)>())
{
_diagnosticMarkersRenderer.RemoveAll(x => x.Tag == tag);
}
break;
case NotifyCollectionChangedAction.Reset:
foreach (var(tag, diagnostics) in e.OldItems.Cast <(object tag, IEnumerable <Diagnostic> diagnostics)>())
{
_diagnosticMarkersRenderer.RemoveAll(i => true);
}
break;
default:
throw new NotSupportedException();
}
TextArea.TextView.Redraw();
_contextActionsRenderer.OnDiagnosticsUpdated();
}));
_disposables.Add(codeEditor.WhenAnyValue(x => x.CodeIndex).Subscribe(codeIndex =>
{
_scopeLineBackgroundRenderer.ApplyIndex(codeIndex);
}));
_scopeLineBackgroundRenderer.ApplyIndex(codeEditor.CodeIndex);
foreach (var(tag, diagnostics) in codeEditor.Diagnostics)
{
_diagnosticMarkersRenderer.SetDiagnostics(tag, diagnostics);
}
foreach (var(tag, highlights) in codeEditor.Highlights)
{
_textColorizer.SetTransformations(tag, highlights);
}
TextArea.TextView.Redraw();
}
_intellisenseManager = new IntellisenseManager(editor, Intellisense, _completionAssistant, codeEditor.LanguageService, editor.SourceFile, offset =>
{
var location = new TextViewPosition(Document.GetLocation(offset));
var visualLocation = TextArea.TextView.GetVisualPosition(location, VisualYPosition.LineBottom);
var visualLocationTop = TextArea.TextView.GetVisualPosition(location, VisualYPosition.LineTop);
var position = visualLocation - TextArea.TextView.ScrollOffset;
position = position.Transform(TextArea.TextView.TransformToVisual(TextArea).Value);
_completionAssistantControl.SetLocation(position);
});
_disposables.Add(_intellisenseManager);
foreach (var contextActionProvider in codeEditor.LanguageService.GetContextActionProviders())
{
_contextActionsRenderer.Providers.Add(contextActionProvider);
}
}
Dispatcher.UIThread.Post(() =>
{
TextArea.ScrollToLine(Line);
Focus();
});
}
else
{
if (Document != null)
{
Document = null;
}
}
}),
this.GetObservable(RenameOpenProperty).Subscribe(open =>
{
if (_isLoaded && Editor != null)
{
var token = Editor.Document.GetToken(CaretOffset);
var location = new TextViewPosition(Document.GetLocation(token.Offset));
var visualLocation = TextArea.TextView.GetVisualPosition(location, VisualYPosition.LineBottom);
var visualLocationTop = TextArea.TextView.GetVisualPosition(location, VisualYPosition.LineTop);
var position = visualLocation - TextArea.TextView.ScrollOffset;
position = position.Transform(TextArea.TextView.TransformToVisual(TextArea).Value);
_renameControl.SetLocation(position);
_renameControl.Open(this, Editor.Document.GetText(token));
}
}),
AddHandler(KeyDownEvent, tunneledKeyDownHandler, RoutingStrategies.Tunnel),
AddHandler(KeyUpEvent, tunneledKeyUpHandler, RoutingStrategies.Tunnel)
};
Options = new AvaloniaEdit.TextEditorOptions
{
ConvertTabsToSpaces = true,
IndentationSize = 4,
EnableHyperlinks = false,
EnableEmailHyperlinks = false,
};
//BackgroundRenderersProperty.Changed.Subscribe(s =>
//{
// if (s.Sender == this)
// {
// if (s.OldValue != null)
// {
// foreach (var renderer in (ObservableCollection<IBackgroundRenderer>)s.OldValue)
// {
// TextArea.TextView.BackgroundRenderers.Remove(renderer);
// }
// }
// if (s.NewValue != null)
// {
// foreach (var renderer in (ObservableCollection<IBackgroundRenderer>)s.NewValue)
// {
// TextArea.TextView.BackgroundRenderers.Add(renderer);
// }
// }
// }
//});
//DocumentLineTransformersProperty.Changed.Subscribe(s =>
//{
// if (s.Sender == this)
// {
// if (s.OldValue != null)
// {
// foreach (var renderer in (ObservableCollection<IVisualLineTransformer>)s.OldValue)
// {
// TextArea.TextView.LineTransformers.Remove(renderer);
// }
// }
// if (s.NewValue != null)
// {
// foreach (var renderer in (ObservableCollection<IVisualLineTransformer>)s.NewValue)
// {
// TextArea.TextView.LineTransformers.Add(renderer);
// }
// }
// }
//});
/*_analysisTriggerEvents.Select(_ => Observable.Timer(TimeSpan.FromMilliseconds(300)).ObserveOn(AvaloniaScheduler.Instance)
* .SelectMany(o => DoCodeAnalysisAsync())).Switch().Subscribe(_ => { });*/
Intellisense = new IntellisenseViewModel();
_completionAssistant = new CompletionAssistantViewModel(Intellisense);
TextArea.TextEntering += TextArea_TextEntering;
TextArea.TextEntered += TextArea_TextEntered;
}
~CodeEditor()
{
}
public MainWindowViewModel()
{
CompositeDisposable.Add(SubWindowViewModel);
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartStdIO startStdIO = null,
StartHttp startHttp = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var disposeOnQuit = new CompositeDisposable();
startServer ??= (startupOptions, invocationContext) =>
{
var webHost = Program.ConstructWebHost(startupOptions);
disposeOnQuit.Add(webHost);
webHost.Run();
};
jupyter ??= JupyterCommand.Do;
startStdIO ??= StdIOCommand.Do;
startHttp ??= HttpCommand.Do;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
var clearTextProperties = new[]
{
"frontend"
};
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel,
"dotnet/interactive/cli");
var filter = new TelemetryFilter(
Sha256Hasher.HashWithNormalizedCasing,
clearTextProperties,
(commandResult, directives, entryItems) =>
{
// add frontend
var frontendTelemetryAdded = false;
foreach (var directive in directives)
{
switch (directive.Key)
{
case "vscode":
case "jupyter":
case "synapse":
frontendTelemetryAdded = true;
entryItems.Add(new KeyValuePair <string, string>("frontend", directive.Key));
break;
}
}
if (!frontendTelemetryAdded)
{
if (commandResult.Command.Name == "jupyter")
{
entryItems.Add(new KeyValuePair <string, string>("frontend", "jupyter"));
}
}
});
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var pathOption = new Option <DirectoryInfo>(
"--path",
"Installs the kernelspecs to the specified directory")
.ExistingOnly();
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
if (context.ParseResult.Errors.Count == 0)
{
telemetry.SendFiltered(filter, context.ParseResult);
}
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddGlobalOption(logPathOption);
command.AddGlobalOption(verboseOption);
return(command);
}
Command Jupyter()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services",
isDefault: true);
var command = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
command.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext, CancellationToken>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
httpPortRangeOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, HttpPortRange, DirectoryInfo>(InstallHandler);
command.AddCommand(installCommand);
return(command);
Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
services = RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ => new HtmlNotebookFrontedEnvironment());
serviceCollection.AddSingleton <FrontendEnvironment>(c =>
c.GetService <HtmlNotebookFrontedEnvironment>());
});
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(c =>
{
return(CommandScheduler.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(
c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
}
Task <int> InstallHandler(IConsole console, InvocationContext context, HttpPortRange httpPortRange, DirectoryInfo path)
{
var jupyterInstallCommand = new JupyterInstallCommand(console, new JupyterKernelSpecInstaller(console), httpPortRange, path);
return(jupyterInstallCommand.InvokeAsync());
}
}
Command HttpServer()
{
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
},
isDefault: true);
var command = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption
};
command.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ =>
{
var frontendEnvironment = new BrowserFrontendEnvironment();
return(frontendEnvironment);
});
serviceCollection.AddSingleton <FrontendEnvironment>(c => c.GetRequiredService <BrowserFrontendEnvironment>());
});
return(startHttp(startupOptions, console, startServer, context));
});
return(command);
}
Command StdIO()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services");
var command = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext, CancellationToken>(
(startupOptions, options, console, context, cancellationToken) =>
{
if (startupOptions.EnableHttpApi)
{
RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ => new HtmlNotebookFrontedEnvironment());
serviceCollection.AddSingleton <FrontendEnvironment>(c =>
c.GetService <HtmlNotebookFrontedEnvironment>());
}, kernel =>
{
StdIOCommand.CreateServer(kernel, console);
kernel.UseQuiCommand(disposeOnQuit, cancellationToken);
});
return(startHttp(startupOptions, console, startServer, context));
}
{
var kernel = CreateKernel(options.DefaultKernel, new BrowserFrontendEnvironment(),
startupOptions);
disposeOnQuit.Add(kernel);
kernel.UseQuiCommand(disposeOnQuit, cancellationToken);
return(startStdIO(
startupOptions,
kernel,
console));
}
});
return(command);
}
public PackageTests(ITestOutputHelper output)
{
_disposables.Add(output.SubscribeToPocketLogger());
_disposables.Add(VirtualClock.Start());
}
private static ISampleProvider ReadWaveFile(WaveFileReader reader, CompositeDisposable disposables)
{
disposables.Add(reader);
// if resampling is needed, do it.
if (reader.WaveFormat.SampleRate != SampleRate)
{
var resampler = new MediaFoundationResampler(reader,
WaveFormat.CreateIeeeFloatWaveFormat(SampleRate, ChannelCount));
disposables.Add(resampler);
return resampler.ToSampleProvider();
}
return reader.ToSampleProvider();
}
