/// <summary>
/// Returns an IObservable that continuously updates as the user's
/// physical location changes. It is super important to make sure to
/// dispose all subscriptions to this IObservable.
/// </summary>
/// <param name="minUpdateTime">Minimum update time.</param>
/// <param name="minUpdateDist">Minimum update dist.</param>
/// <param name="includeHeading">If set to <c>true</c> include heading.</param>
public static IObservable<Position> Listen(int minUpdateTime, double minUpdateDist, bool includeHeading = false)
{
if (Implementation != null) {
return Implementation.Listen(minUpdateTime, minUpdateDist, includeHeading);
}
var ret = Observable.Create<Position>(subj => {
#if ANDROID
var geo = new Geolocator(AndroidApp.Context);
#else
var geo = new Geolocator();
#endif
var disp = new CompositeDisposable();
bool isDead = false;
if (!geo.IsGeolocationAvailable || !geo.IsGeolocationEnabled) {
return Observable.Throw<Position>(new Exception("Geolocation isn't available")).Subscribe(subj);
}
// NB: This isn't very Functional, but I'm lazy.
disp.Add(Observable.FromEventPattern<PositionEventArgs>(x => geo.PositionChanged += x, x => geo.PositionChanged -= x).Subscribe(x => {
if (isDead) return;
subj.OnNext(x.EventArgs.Position);
}));
disp.Add(Observable.FromEventPattern<PositionErrorEventArgs>(x => geo.PositionError += x, x => geo.PositionError -= x).Subscribe(ex => {
isDead = true;
var toDisp = Interlocked.Exchange(ref disp, null);
if (toDisp != null) toDisp.Dispose();
subj.OnError(new GeolocationException(ex.EventArgs.Error));
}));
return disp;
});
return ret.Multicast(new Subject<Position>()).RefCount();
}
public void SetUp()
{
disposables = new CompositeDisposable
{
VirtualClock.Start()
};
clockName = Any.CamelCaseName();
targetId = Any.Word();
target = new CommandTarget(targetId);
store = new InMemoryStore<CommandTarget>(
_ => _.Id,
id => new CommandTarget(id))
{
target
};
configuration = new Configuration()
.UseInMemoryCommandScheduling()
.UseDependency<IStore<CommandTarget>>(_ => store)
.UseDependency<GetClockName>(c => _ => clockName)
.TraceScheduledCommands();
scheduler = configuration.CommandScheduler<CommandTarget>();
Command<CommandTarget>.AuthorizeDefault = (commandTarget, command) => true;
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
}
public static void Run()
{
var systems = new[] { "A", "B", "C" }.Select(CreateExternalSystem);
var observables = systems.Select(s => s.ObserveHealth()).Select(obs => obs.DistinctUntilChanged(c => c.IsAvailable)).ToList();
var disposable = new CompositeDisposable();
// observe independently
disposable.Add(new CompositeDisposable(observables.Select(c => c.Subscribe(PrintHealthCheck))));
// merge
var merged = observables.Aggregate((l, r) => l.Merge(r));
disposable.Add(merged.Subscribe(PrintHealthCheck));
// combine
var combined = observables
.Aggregate(Observable.Return(Enumerable.Empty<HealthCheck>()), (agg, obs) => agg.CombineLatest(obs, (checks, check) => checks.Concat(new[] { check })));
var scan = merged.Scan(ImmutableDictionary<string, bool>.Empty, (d, check) => d.SetItem(check.ExternalSystemName, check.IsAvailable));
disposable.Add(combined.Subscribe(e => Console.WriteLine("Combined: " + string.Join(", ", e.Select(c => $"{c.ExternalSystemName}={c.IsAvailable}")))));
disposable.Add(scan.Subscribe(d => Console.WriteLine("Scanned: " + string.Join(", ", d.Select(p => $"{p.Key}={p.Value}")))));
Console.ReadKey();
disposable.Dispose();
}
public void SetUp()
{
clockName = Any.CamelCaseName();
Clock.Reset();
disposables = new CompositeDisposable
{
Disposable.Create(Clock.Reset)
};
var configuration = new Configuration()
.UseSqlEventStore(c => c.UseConnectionString(TestDatabases.EventStore.ConnectionString))
.UseSqlStorageForScheduledCommands(c => c.UseConnectionString(TestDatabases.CommandScheduler.ConnectionString));
Configure(configuration);
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
orderRepository = configuration.Repository<Order>();
accountRepository = configuration.Repository<CustomerAccount>();
clockTrigger = configuration.SchedulerClockTrigger();
clockRepository = configuration.SchedulerClockRepository();
clockRepository.CreateClock(clockName, Clock.Now());
}
public void SetUp()
{
disposables = new CompositeDisposable
{
VirtualClock.Start()
};
clockName = Any.CamelCaseName();
targetId = Any.Word();
target = new CommandTarget(targetId);
store = new InMemoryStore<CommandTarget>(
_ => _.Id,
id => new CommandTarget(id))
{
target
};
CommandSchedulerDbContext.NameOrConnectionString =
@"Data Source=(localdb)\MSSQLLocalDB; Integrated Security=True; MultipleActiveResultSets=False; Initial Catalog=ItsCqrsTestsCommandScheduler";
configuration = new Configuration()
.UseInMemoryCommandScheduling()
.UseDependency<IStore<CommandTarget>>(_ => store)
.UseDependency<GetClockName>(c => _ => clockName)
.TraceScheduledCommands();
scheduler = configuration.CommandScheduler<CommandTarget>();
Command<CommandTarget>.AuthorizeDefault = (commandTarget, command) => true;
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
}
public void SetUp()
{
// disable authorization
Command<Order>.AuthorizeDefault = (o, c) => true;
Command<CustomerAccount>.AuthorizeDefault = (o, c) => true;
disposables = new CompositeDisposable
{
VirtualClock.Start()
};
customerAccountId = Any.Guid();
configuration = new Configuration()
.UseInMemoryCommandScheduling()
.UseInMemoryEventStore();
customerRepository = configuration.Repository<CustomerAccount>();
orderRepository = configuration.Repository<Order>();
customerRepository.Save(new CustomerAccount(customerAccountId).Apply(new ChangeEmailAddress(Any.Email())));
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
}
public IObservable<Unit> SendMessage(string message, IScheduler scheduler)
{
return Observable.Create<Unit>(observer =>
{
var disposable = new CompositeDisposable();
var buffer = Encoding.UTF8.GetBytes(message);
connectionToken.SocketEvent.SetBuffer(buffer, 0, buffer.Length);
var disposableCompletedSubscription = connectionToken.SocketEvent.Completed.Subscribe(_ =>
{
SendNotificationToObserver(observer, connectionToken.SocketEvent);
});
var disposableActions = scheduler.Schedule(() =>
{
if (!connectionToken.Socket.SendAsync(connectionToken.SocketEvent))
{
SendNotificationToObserver(observer, connectionToken.SocketEvent);
}
});
disposable.Add(disposableCompletedSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
public void SetUp()
{
disposables = new CompositeDisposable();
telemetryEvents = new List<Telemetry>();
disposables.Add(Log.TelemetryEvents().Subscribe(e => { telemetryEvents.Add(e); }));
}
public void SetUp()
{
disposables = new CompositeDisposable
{
VirtualClock.Start()
};
configuration = new Configuration()
.UseInMemoryCommandScheduling()
.UseInMemoryEventStore(traceEvents: true);
itRepo = configuration.Repository<MarcoPoloPlayerWhoIsIt>();
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
}
public IDisposable Subscribe(ReactiveSpace spaceListener)
{
CompositeDisposable subscriptions = new CompositeDisposable();
subscriptions.Add(spaceListener
.LockedHands()
.ObserveOn(UI)
.Subscribe(o =>
{
HandsCount++;
}));
subscriptions.Add(spaceListener
.LockedHands()
.Select(o =>
o
.ObserveOn(UI)
.Subscribe(oo =>
{
}, () =>
{
HandsCount--;
}))
.Subscribe());
subscriptions.Add(SubscribeCore(spaceListener));
subscriptions.Add(Disposable.Create(()=>HandsCount = 0));
return subscriptions;
}
public void Order()
{
// It is time-dependent test (i.e. lengthy and inconsistent), which is not very good but we cannot use HistoricalScheduler to test it...
var s = Scheduler.ThreadPool;
var l = new List<int> ();
var dis = new CompositeDisposable ();
try {
dis.Add (s.Schedule (() => { Thread.Sleep (1200); l.Add (1); }));
dis.Add (s.Schedule (() => { Thread.Sleep (800); l.Add (2); }));
dis.Add (s.Schedule (() => { Thread.Sleep (50); l.Add (3); }));
Thread.Sleep (1500);
Assert.AreEqual (new int [] {3, 2, 1}, l.ToArray (), "#1");
} finally {
dis.Dispose ();
}
}
public GherkinFileClassifier(ITextBuffer buffer)
{
var snapshot = buffer.CurrentSnapshot;
_spans = new List<ClassificationSpan>();
_listeners = new CompositeDisposable();
_parser = buffer.Properties.GetProperty<GherkinFileEditorParser>(typeof(GherkinFileEditorParser));
_listeners.Add(_parser.IsParsing.Where(isParsing => isParsing).Subscribe(b => _spans.Clear()));
_listeners.Add(_parser.IsParsing.Where(isParsing => !isParsing).Subscribe(b => PublishClassificationEvents()));
_listeners.Add(_parser
.ParserEvents
.Select(f => SelectClassifiable(f, snapshot))
.Subscribe((spans => _spans.AddRange(spans))));
}
public void SetUp()
{
eventStoreDbTest = new EventStoreDbTest();
clockName = Any.CamelCaseName();
Clock.Reset();
disposables = new CompositeDisposable
{
Disposable.Create(() => eventStoreDbTest.TearDown()),
Disposable.Create(Clock.Reset)
};
var bus = new FakeEventBus();
orderRepository = new SqlEventSourcedRepository<Order>(bus);
accountRepository = new SqlEventSourcedRepository<CustomerAccount>(bus);
var configuration = new Configuration();
configuration.UseEventBus(bus)
.UseDependency<IEventSourcedRepository<Order>>(t => orderRepository)
.UseDependency<IEventSourcedRepository<CustomerAccount>>(t => accountRepository);
ConfigureScheduler(configuration);
disposables.Add(ConfigurationContext.Establish(configuration));
Console.WriteLine(new { clockName });
clockTrigger = configuration.Container.Resolve<ISchedulerClockTrigger>();
clockRepository = configuration.Container.Resolve<ISchedulerClockRepository>();
clockRepository.CreateClock(clockName, Clock.Now());
}
protected override IDisposable SubscribeCore(ReactiveSpace spaceListener)
{
CompositeDisposable subscriptions = new CompositeDisposable();
subscriptions.Add(spaceListener
.LockedHands()
.ObserveOn(UI)
.SelectMany(h => h
.Select(hh => new
{
Group = h,
Hand = hh
}))
.Subscribe(h =>
{
var diff = 1000 + (h.Hand.PalmPosition.y - h.Group.Key.PalmPosition.y);
var bin = (int)(diff / MinInterval);
if(bin < PreviousBin)
{
if(OnMoveDown != null)
OnMoveDown();
}
if(bin > PreviousBin)
{
if(OnMoveUp != null)
OnMoveUp();
}
PreviousBin = bin;
}));
return subscriptions;
}
private static void CompositeDisposable()
{
Demo.DisplayHeader("The CompositeDisposable - groups multiple disposables and dispose them together");
var compositeDisposable = new CompositeDisposable(
Disposable.Create(() => Console.WriteLine("1st disposed")),
Disposable.Create(() => Console.WriteLine("2nd disposed")));
compositeDisposable.Dispose();
//The same can also be written using the Add() method
compositeDisposable = new CompositeDisposable();
compositeDisposable.Add(Disposable.Create(() => Console.WriteLine("1st disposed")));
compositeDisposable.Add(Disposable.Create(() => Console.WriteLine("2nd disposed")));
compositeDisposable.Dispose();
}
public TimelineModel(Func<TwitterStatus, bool> evaluator,
Func<long?, int, bool, IObservable<TwitterStatus>> fetcher)
{
_fetcher = fetcher;
_statusIdCache = new AVLTree<long>();
_disposable = new CompositeDisposable();
// add handler
_disposable.Add(StatusStore.StatusPublisher
.Where(sn => sn.IsAdded && evaluator(sn.Status))
.Select(s => s.Status)
.Subscribe(AddStatus));
// remove handler
_disposable.Add(StatusStore.StatusPublisher
.Where(sn => !sn.IsAdded || !evaluator(sn.Status))
.Select(s => s.StatusId)
.Subscribe(RemoveStatus));
}
public void Order()
{
// It is time-dependent test (i.e. lengthy and inconsistent), which is not very good but we cannot use HistoricalScheduler to test it...
var s = Scheduler.TaskPool;
var l = new List<int> ();
var dis = new CompositeDisposable ();
try {
// If the tasks do not run long enough, the (Task) scheduler will not use separate Threads,
// therefore Thread.Sleep(x) will block not only current task, but also tasks scheduled to run
// in the same Thread
dis.Add (s.Schedule (() => { Thread.Sleep (2400); l.Add (1); }));
dis.Add (s.Schedule (() => { Thread.Sleep (1600); l.Add (2); }));
dis.Add (s.Schedule (() => { Thread.Sleep (50); l.Add (3); }));
Thread.Sleep (2500);
Assert.AreEqual (new int [] {3, 2, 1}, l.ToArray (), "#1");
} finally {
dis.Dispose ();
}
}
public override void SetUp()
{
base.SetUp();
schedulerActivity = new List<IScheduledCommand>();
using (VirtualClock.Start(DateTimeOffset.Now.AddMonths(1)))
{
disposables = new CompositeDisposable();
Settings.Sources = new ISettingsSource[] { new ConfigDirectorySettings(@"c:\dev\.config") }.Concat(Settings.Sources);
serviceBusSettings = Settings.Get<ServiceBusSettings>();
serviceBusSettings.NamePrefix = "itscqrstests";
serviceBusSettings.ConfigureQueue = q => { q.AutoDeleteOnIdle = TimeSpan.FromMinutes(15); };
var clockName = Any.Paragraph(4);
var configuration = new Configuration()
.UseSqlEventStore()
.UseDependency<GetClockName>(_ => @event => clockName)
.UseSqlStorageForScheduledCommands()
.AddToCommandSchedulerPipeline<Order>(
schedule: async (cmd, next) =>
{
await next(cmd);
schedulerActivity.Add(cmd);
},
deliver: async (cmd, next) =>
{
await next(cmd);
schedulerActivity.Add(cmd);
});
queueSender = new ServiceBusCommandQueueSender(serviceBusSettings)
{
MessageDeliveryOffsetFromCommandDueTime = TimeSpan.FromSeconds(30)
};
disposables.Add(queueSender.Messages.Subscribe(s => Console.WriteLine("[ServiceBusCommandQueueSender] " + s.ToJson())));
disposables.Add(configuration);
disposables.Add(ConfigurationContext.Establish(configuration));
}
}
public void SetUp()
{
eventStoreDbTest = new EventStoreDbTest();
clockName = Any.CamelCaseName();
VirtualClock.Start();
disposables = new CompositeDisposable
{
Disposable.Create(() => eventStoreDbTest.TearDown())
};
var configuration = new Configuration();
Configure(configuration);
disposables.Add(ConfigurationContext.Establish(configuration));
disposables.Add(configuration);
}
public IObservable<Stream> SafeOpenFileAsync(string path, FileMode mode, FileAccess access, FileShare share, IScheduler scheduler)
{
return Observable.Create<Stream>(subj =>
{
var disp = new CompositeDisposable();
IsolatedStorageFile fs = null;
try
{
fs = IsolatedStorageFile.GetUserStoreForApplication();
disp.Add(fs);
disp.Add(Observable.Start(() => fs.OpenFile(path, mode, access, share), RxApp.TaskpoolScheduler).Select(x => (Stream)x).Subscribe(subj));
}
catch(Exception ex)
{
subj.OnError(ex);
}
return disp;
});
}
public IObservable<Stream> OpenFileForWriteAsync(string path, IScheduler scheduler)
{
return Observable.Create<Stream>(subj =>
{
var disp = new CompositeDisposable();
IsolatedStorageFile fs = null;
try
{
fs = IsolatedStorageFile.GetUserStoreForApplication();
disp.Add(fs);
disp.Add(Observable.Start(() => fs.OpenFile(path, FileMode.Create, FileAccess.Write, FileShare.None), BlobCache.TaskpoolScheduler).Subscribe(subj));
}
catch (Exception ex)
{
subj.OnError(ex);
}
return disp;
});
}
/// <summary>
/// Subscribes an event handler to events published on the bus.
/// </summary>
/// <param name="bus">The bus to whose events the handler will be subscribed.</param>
/// <param name="handlers">The handlers to be subscribed to the bus.</param>
/// <returns>
/// A disposable that can be disposed in order to cancel the subscriptions.
/// </returns>
public static IDisposable Subscribe(this IEventBus bus, params object[] handlers)
{
if (handlers == null || !handlers.Any())
{
return Disposable.Empty;
}
var disposable = new CompositeDisposable();
handlers.ForEach(handler => disposable.Add(bus.Subscribe(handler)));
return disposable;
}
public void SetUp()
{
Command<Order>.AuthorizeDefault = (order, command) => true;
disposables = new CompositeDisposable();
var configuration = new Configuration()
.UseInMemoryEventStore()
.UseInMemoryCommandScheduling();
disposables.Add(ConfigurationContext.Establish(configuration));
}
public static void Run()
{
var systems = new[] { "A", "B", "C" }.Select(CreateExternalSystem);
var observables = systems.Select(s => s.ObserveHealth()).Select(obs => obs.DistinctUntilChanged(c => c.IsAvailable)).ToList();
var disposable = new CompositeDisposable();
// observe independently
disposable.Add(new CompositeDisposable(observables.Select(c => c.Subscribe(PrintHealthCheck))));
// merge
var merged = Observable.Empty<HealthCheck>();
disposable.Add(merged.Subscribe(PrintHealthCheck));
// combine
var combined = Observable.Empty<IEnumerable<HealthCheck>>();
disposable.Add(combined.Subscribe(e => Console.WriteLine("Combined: " + string.Join(", ", e.Select(c => $"{c.ExternalSystemName}={c.IsAvailable}")))));
Console.ReadKey();
disposable.Dispose();
}
public override void SetUp()
{
base.SetUp();
using (VirtualClock.Start(DateTimeOffset.Now.AddMonths(1)))
{
disposables = new CompositeDisposable();
Settings.Sources = new ISettingsSource[] { new ConfigDirectorySettings(@"c:\dev\.config") }.Concat(Settings.Sources);
serviceBusSettings = Settings.Get<ServiceBusSettings>();
serviceBusSettings.NamePrefix = "itscqrstests";
serviceBusSettings.ConfigureQueue = q =>
{
q.AutoDeleteOnIdle = TimeSpan.FromMinutes(15);
};
bus = new FakeEventBus();
orderRepository = new SqlEventSourcedRepository<Order>(bus);
var configuration = new Configuration()
.UseSqlEventStore(() => new EventStoreDbContext())
.UseEventBus(bus)
.UseSqlCommandScheduling()
.UseDependency<IEventSourcedRepository<Order>>(t => orderRepository);
var clockName = Any.Paragraph(4);
scheduler = new SqlCommandScheduler(configuration) { GetClockName = @event => clockName };
queueSender = new ServiceBusCommandQueueSender(serviceBusSettings)
{
MessageDeliveryOffsetFromCommandDueTime = TimeSpan.FromSeconds(30)
};
disposables.Add(scheduler.Activity.Subscribe(s => Console.WriteLine("SqlCommandScheduler: " + s.ToJson())));
disposables.Add(queueSender.Messages.Subscribe(s => Console.WriteLine("ServiceBusCommandQueueSender: " + s.ToJson())));
disposables.Add(bus.Subscribe(scheduler));
disposables.Add(configuration);
disposables.Add(ConfigurationContext.Establish(configuration));
}
}
public static IObservable<Position> GetPosition(bool includeHeading = false)
{
if (Implementation != null) {
return Implementation.GetPosition(includeHeading);
}
#if !WP7 && !WP8
var ret = Observable.Create<Position>(subj => {
var geo = new Geolocator();
var cts = new CancellationTokenSource();
var disp = new CompositeDisposable();
if (!geo.IsGeolocationAvailable || !geo.IsGeolocationEnabled) {
return Observable.Throw<Position>(new Exception("Geolocation isn't available")).Subscribe(subj);
}
disp.Add(new CancellationDisposable(cts));
disp.Add(geo.GetPositionAsync(cts.Token, includeHeading).ToObservable().Subscribe(subj));
return disp;
}).Multicast(new AsyncSubject<Position>());
#else
// NB: Xamarin.Mobile.dll references CancellationTokenSource, but
// the one we have comes from the BCL Async library - if we try to
// pass in our type into the Xamarin library, it gets confused.
var ret = Observable.Create<Position>(subj => {
var geo = new Geolocator();
var disp = new CompositeDisposable();
if (!geo.IsGeolocationAvailable || !geo.IsGeolocationEnabled) {
return Observable.Throw<Position>(new Exception("Geolocation isn't available")).Subscribe(subj);
}
disp.Add(geo.GetPositionAsync(Int32.MaxValue, includeHeading).ToObservable().Subscribe(subj));
return disp;
}).Multicast(new AsyncSubject<Position>());
#endif
return ret.RefCount();
}
static InputModel()
{
_disposables = new CompositeDisposable();
_core = new InputCoreModel();
_accounts = new AccountSelectorModel(_core);
// link property changing
var icmpc = new PropertyChangedEventListener(_core);
icmpc.RegisterHandler(() => _core.CurrentInputData,
(o, e) => _accounts.CurrentInputDataChanged());
_disposables.Add(icmpc);
SetEventPropagation();
}
public async Task<IObservable<ArmaServerInfo>> GetServers(CancellationToken ct, ServerFilterWrap filter) {
var dsp = new CompositeDisposable();
// Apparently we get null ServerInfo (not even endpoints :S)
var obs = ServerResponses
.TakeUntil(RefreshComplete)
.Select(x => x.ServerInfo == null ? null : ArmaServerInfo.FromWrap(x.ServerIndex, x.ServerInfo))
.Where(x => x != null)
.Replay();
dsp.Add(obs.Connect());
obs.Subscribe(_ => { }, x => dsp.Dispose(), dsp.Dispose, ct);
ct.Register(dsp.Dispose);
await GetServerInfo(filter).ConfigureAwait(false);
return obs;
}
public void SetUp()
{
// disable authorization
Command<Order>.AuthorizeDefault = (o, c) => true;
Command<CustomerAccount>.AuthorizeDefault = (o, c) => true;
disposables = new CompositeDisposable();
var configurationContext = ConfigurationContext
.Establish(new Configuration()
.UseInMemoryEventStore()
.IgnoreScheduledCommands());
disposables.Add(configurationContext);
}
private IConnectableObservable<ArmaServerInfo> PrepareListener(CancellationToken ct, bool inclRules = false) {
var dsp = new CompositeDisposable();
var obs = BuildListener(dsp);
if (inclRules)
obs = obs
.SelectMany(async si => {
await UpdateRules(si, ct).ConfigureAwait(false);
return si;
});
var theObs = obs.Select(x => x.Info)
.Replay();
dsp.Add(theObs.Connect());
theObs.Subscribe(_ => { }, x => dsp.Dispose(), dsp.Dispose, ct);
ct.Register(dsp.Dispose);
return theObs;
}