public static DataReaderObservableRunner RunAsync(IDbCommand command, IObserver<IDictionary<string, object>> observer)
{
var instance = new DataReaderObservableRunner(command, observer);
var asyncAction = new Action(instance.Run);
asyncAction.BeginInvoke(asyncAction.EndInvoke, null);
return instance;
}
protected AppendEntryBaseTest()
{
// Arrange
var mocker = new AutoMocker();
ServerIdentifier = new ServerIdentifier();
mocker.Use(ServerIdentifier);
mocker.Setup<ISubject<AppendEntryMessage>>(p => p.Subscribe(It.IsAny<IObserver<AppendEntryMessage>>()))
.Callback<IObserver<AppendEntryMessage>>((o) =>
{
AppendEntryCallback = o;
});
AppendEntryCallback = mocker.Get<ISubject<AppendEntryMessage>>();
AppendEntryResult = new Subject<AppendEntryResultMessage>();
Election = new Election();
LogReplication = new LogReplication();
AppendEntry = new Rafting.AppendEntry(AppendEntryResult,
mocker.Get<ISubject<AppendEntryMessage>>(),
mocker.Get<IHartbeatTimer>(),
LogReplication,
Election,
mocker.Get<ILoggerFactory>(),
new RaftOptions(),
mocker.Get<ServerIdentifier>(),
null);
}
public void Attach(IObserver observerMe)
{
if (!_observers.Contains(observerMe))
{
_observers.Add(observerMe);
}
}
public void RemoveObserver(IObserver observer)
{
if (observer != null && m_ObserverList.Contains(observer))
{
m_ObserverList.Remove(observer);
}
}
public void Detach(IObserver observerMe)
{
if (_observers.Contains(observerMe))
{
_observers.Remove(observerMe);
}
}
public void RegisterObserver(IObserver observer)
{
observable.RegisterObserver(observer);
}
public IObservable<List<string>> ExecuteInstall(string currentAssemblyDir, IPackage bundledPackageMetadata, IObserver<int> progress = null)
{
progress = progress ?? new Subject<int>();
// NB: This bit of code is a bit clever. The binaries that WiX
// has installed *itself* meets the qualifications for being a
// Squirrel update directory (a RELEASES file and the corresponding
// NuGet packages).
//
// So, in order to reuse some code and not write the same things
// twice we're going to "Eigenupdate" from our own directory;
// UpdateManager will operate in bootstrap mode and create a
// local directory for us.
//
// Then, we create a *new* UpdateManager whose target is the normal
// update URL - we can then apply delta updates against the bundled
// NuGet package to get up to vCurrent. The reason we go through
// this rigamarole is so that developers don't have to rebuild the
// installer as often (never, technically).
var updateUsingDeltas =
executeInstall(currentAssemblyDir, bundledPackageMetadata, progress: progress)
.ToObservable()
.ObserveOn(RxApp.DeferredScheduler)
.Catch<List<string>, Exception>(ex => {
log.WarnException("Updating using deltas has failed", ex);
return executeInstall(currentAssemblyDir, bundledPackageMetadata, true, progress)
.ToObservable();
});
return updateUsingDeltas;
}
public void AddObserver(IObserver observer)
{
if (observer != null && !m_ObserverList.Contains(observer))
{
m_ObserverList.Add(observer);
}
}
public virtual void Notify(IObserver observer)
{
if (observer != null && m_Observers.Contains(observer))
{
observer.Update(this);
}
}
public void UnRegister(IObserver anObserver)
{
try {
this.observerContainer.Remove(anObserver);
} catch {
}
}
/// <summary>
/// ��ӹ۲���
/// </summary>
/// <param name="observer"></param>
public void Add(IObserver observer)
{
lock (this)
{
root.Add(observer);
}
}
public void Unsubscribe(IObserver observer)
{
if (_observers.Contains(observer))
{
_observers.Remove(observer);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SinkSettings" /> class.
/// </summary>
/// <param name="name">The event listener name.</param>
/// <param name="sink">The sink instance.</param>
/// <param name="eventSources">The event sources.</param>
/// <exception cref="ConfigurationException">Validation exceptions.</exception>
public SinkSettings(string name, IObserver<EventEntry> sink, IEnumerable<EventSourceSettings> eventSources)
: this(name, eventSources)
{
Guard.ArgumentNotNull(sink, "sink");
this.Sink = sink;
}
public BrightnessPowerAdapter(DigitalOutput2 device)
{
this.inputBrightness = Observer.Create<DoubleZeroToOne>(x =>
{
device.SetValue(x.Value > 0.1);
});
}
bool Accept(IObserver<Interactor> observer)
{
Log.Info("Accept new connection");
try
{
var newSocket = _listener.Accept();
var interactor = new Interactor(newSocket, _nextInteractorId++, _bufferManager);
_interactors.Add(newSocket, interactor);
Log.DebugFormat("Accepted {0}", interactor);
observer.OnNext(interactor);
return true;
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.Interrupted)
observer.OnCompleted();
else
observer.OnError(ex);
}
catch (Exception ex)
{
observer.OnError(ex);
}
return false;
}
public void UnSubscribe(ISubject<IObserver> topic, IObserver follower)
{
if (pushsubMapping.ContainsKey(topic.ToString()))
{
pushsubMapping[topic.ToString()].Remove(follower);
}
}
/// <summary>Constructs a Rx timer stage</summary>
/// <param name="observer">the observer</param>
/// <param name="initialDelay">the initial delay in milli-seconds</param>
/// <param name="period">the period in milli-seconds</param>
public RxTimerStage(IObserver<PeriodicEvent> observer, long initialDelay, long period)
{
_observer = observer;
_timer = new Timer(period);
_timer.Elapsed += (sender, e) => OnTimedEvent(sender, e, _observer, _value);
_timer.Enabled = true;
}
public void Register(IObserver anObserver)
{
try {
this.observerContainer.Add(anObserver, anObserver);
} catch {
}
}
public void RegisterObserver(IObserver o)
{
observers.Add(o);
}
public async Task RunAsync(IObserver<string> observer)
{
var urls = new[]
{
"http://yahoo.co.jp",
"http://google.co.jp",
"http://bing.co.jp",
"http://awsedrftgyhujikol.jp/",
};
foreach (var url in urls)
{
await Observable.Timer(TimeSpan.FromSeconds(1));
try
{
var res = await GetAsStringAsync(url);
observer.OnNext(res);
}
catch(Exception ex)
{
observer.OnError(ex);
}
}
}
public void Detach(IObserver observer)
{
if (_people.Contains(observer))
{
_people.Add(observer);
}
}
public Task<long> ReadSegments(
IObserver<RecordSegment> observer,
Stream stream,
CancellationToken cancellationToken)
{
return Task.Factory.StartNew(() => {
var scanner = (IScanner) Activator.CreateInstance(this.SegmentsScannerType);
var initialOffset = stream.Position;
var lastOffset = initialOffset;
scanner.OffsetCallback = (offset, length) => {
if (length > 0 && offset >= 0) {
var segment = new RecordSegment(initialOffset + offset, length);
lastOffset = initialOffset + offset + length;
observer.OnNext(segment);
}
};
scanner.Diagnostics = this.Diagnostics ?? TextWriter.Null;
scanner.SetSourceWithEncoding(
new InternalStreamWrapper(stream, stream.Position),
Encoding.UTF8.CodePage);
scanner.Parse(cancellationToken);
return lastOffset;
}, cancellationToken,
TaskCreationOptions.LongRunning,
this.TaskScheduler);
}
private static IDisposable ScheduledMethod(IObserver<int> o)
{
var cancel = new CancellationDisposable();
// internally creates a new CancellationTokenSource
NewThreadScheduler.Default.Schedule(() =>
{
int i = 0;
for (;;)
{
Thread.Sleep(200);
// here we do the long lasting background operation
if (!cancel.Token.IsCancellationRequested)
// check cancel token periodically
o.OnNext(i++);
else
{
Console.WriteLine(
"Aborting because cancel event was signaled!");
o.OnCompleted();
return;
}
}
}
);
return cancel;
}
/// <summary>
/// This will test if the exception has an error code that is not 0 (0 is success), if it does then it sends the observer an OnError.
/// </summary>
/// <param name="observer">
/// The observer.
/// </param>
public void SuccessTest(IObserver<IUsbDeviceNotification> observer)
{
if (!Win32Error.IsSuccess)
{
observer.OnError(Win32Error.Exception);
}
}
public virtual void AddObserver( IObserver newObserver )
{
if ( listOfObservers.Contains( newObserver ) ) {
return;
}
listOfObservers.Add( newObserver );
}
static IEnumerator FetchBytes(WWW www, IObserver<byte[]> observer, IProgress<float> reportProgress, CancellationToken cancel)
{
using (www)
{
while (!www.isDone && !cancel.IsCancellationRequested)
{
if (reportProgress != null)
{
try
{
reportProgress.Report(www.progress);
}
catch (Exception ex)
{
observer.OnError(ex);
yield break;
}
}
yield return null;
}
if (cancel.IsCancellationRequested) yield break;
if (!string.IsNullOrEmpty(www.error))
{
observer.OnError(new Exception(www.error));
}
else
{
observer.OnNext(www.bytes);
observer.OnCompleted();
}
}
}
public IDisposable Subscribe(IObserver<IQuack> observer)
{
foreach (IQuack child in children)
child.Subscribe(observer);
return null; // why a return value here?
}
public override void addObserver(IObserver o)
{
if (!_observer_list.Contains(o))
{
_observer_list.Add(o);
}
}
public void Register(IObserver o)
{
_observers.Add(o);
//When new observers registers, tell the observer what we currently got
LoadAllWindows();
}
public void addObserver(IObserver observer)
{
this._observerlist.Add(observer);
}
protected override ISubscription SubscribeCore(IObserver <TSource> observer)
{
return(new _(this, observer));
}
public IDisposable Subscribe(IObserver <TableUpdate> observer)
{
return(UpdateSubject.Subscribe(observer));
}
public Throttle(ThrottleObservable <T> parent, IObserver <T> observer, IDisposable cancel) : base(observer, cancel)
{
this.parent = parent;
}
public _(IObserver <TSource> observer)
: base(observer)
{
}
public _(TakeWhile <TSource> parent, IObserver <TSource> observer)
: base(parent, observer)
{
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
return(new Throttle(this, observer, cancel).Run());
}
public Leader(IElection election,
IHartbeatTimer hartbeat,
IObservable<AppendEntryResultMessage> reply,
IObserver<AppendEntryMessage> append,
IObserver<ClientResultMessage> clientReply,
IObservable<ClientMessage> client,
ILogReplication logReplication,
Nodes nodes,
ILoggerFactory loggerFactory,
RaftOptions options,
ServerIdentifier serverIdentifier)
{
_isDispose = false;
_hartbeat = hartbeat;
_append = append;
_clientReply = clientReply;
_client = client;
_logReplication = logReplication;
_nodes = nodes;
_options = options;
_serverIdentifier = serverIdentifier;
_election = election;
_logger = loggerFactory.CreateLogger(nameof(Leader) + " " + serverIdentifier);
if (_options.UseLogging)
_logger.LogInformation($"{nameof(ServerStateType.Leader)}");
// Reinitialized after election
NextIndex = new ConcurrentDictionary<ServerIdentifier, int>();
MatchIndex = new ConcurrentDictionary<ServerIdentifier, int>();
_hartbeat.Leader(SendHartbeat);
_replyDispose = reply.Subscribe(EntryReplyMessageRecived);
_clientReplyDispose = client.Subscribe(ClientMessageRecived);
}