//=========================================================
        // Peer eventing
        public Task PeerVentAsync(TransactionContext tcontext, CancellationToken token = default(CancellationToken))
        {
            try
            {
                SeekPosition start = new SeekPosition();
                if (peerOptions.Newest != null)
                {
                    start.Newest = new SeekNewest();
                }
                else if (peerOptions.StartEventsBlock != null)
                {
                    start.Specified = new SeekSpecified {
                        Number = (ulong)peerOptions.StartEventsBlock.Value
                    };
                }
                else
                {
                    start.Newest = new SeekNewest();
                }

                //   properties.

                Envelope envelope = ProtoUtils.CreateSeekInfoEnvelope(tcontext, start, new SeekPosition {
                    Specified = new SeekSpecified {
                        Number = (ulong)peerOptions.StopEventsBlock
                    }
                }, SeekInfo.Types.SeekBehavior.BlockUntilReady, clientTLSCertificateDigest);
                return(ConnectEnvelopeAsync(envelope, token));
            }
            catch (CryptoException e)
            {
                throw new TransactionException($"{ToString()} error message {e.Message}", e);
            }
        }
Example #2
0
 public static Envelope CreateSeekInfoEnvelope(TransactionContext transactionContext, SeekPosition startPosition,
                                               SeekPosition stopPosition, SeekInfo.Types.SeekBehavior seekBehavior, byte[] tlsCertHash)
 {
     return(CreateSeekInfoEnvelope(transactionContext, new SeekInfo {
         Start = startPosition, Behavior = seekBehavior, Stop = stopPosition
     }, tlsCertHash));
 }
Example #3
0
 // read
 public void Seek(int Pos, SeekPosition origin)
 {
     if (origin == SeekPosition.Begin)
     {
         stream.Seek(Pos, SeekOrigin.Begin);
     }
     else if (origin == SeekPosition.Current)
     {
         stream.Seek(Pos, SeekOrigin.Current);
     }
     else
     {
         stream.Seek(Pos, SeekOrigin.End);
     }
 }
        private static IObservable <ConsumeResult <TKey, TValue> > CreateObservable <TKey, TValue>(
            IConsumer <TKey, TValue> consumer,
            TopicPartition tp,
            SeekPosition startingPosition,
            CancellationToken cancellationToken)
        {
            return(Observable.Create <ConsumeResult <TKey, TValue> >(o =>
            {
                var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                var innerCancellationToken = cts.Token;

                _ = Task.Run(
                    () =>
                {
                    ConfluentKafkaOffset confluentKafkaOffset = startingPosition switch
                    {
                        SeekPosition.FromWatermark o => new ConfluentKafkaOffset(o.Watermark.Item),
                        _ => ConfluentKafkaOffset.End,
                    };
                    var tpo = new TopicPartitionOffset(tp, confluentKafkaOffset);

                    if (tpo.Partition.Value == -1 && tpo.Offset.Value == -1)
                    {
                        consumer.Subscribe(topic: tp.Topic);
                    }
                    else
                    {
                        Console.Out.WriteLine($"consumerAssign(topic={tpo.Topic} partition={tpo.Partition.Value} offset={tpo.Offset.Value})");
                        consumer.Assign(tpo);
                    }

                    while (!innerCancellationToken.IsCancellationRequested)
                    {
                        var msg = consumer.Consume(innerCancellationToken);

                        Console.WriteLine($"Received {msg.Topic}#{msg.Partition.Value}#{msg.Offset.Value}: {msg.Message.Value}");
                        o.OnNext(msg);
                        innerCancellationToken.ThrowIfCancellationRequested();
                    }

                    o.OnCompleted();
                },
                    innerCancellationToken);

                return new CancellationDisposable(cts);
            }));
        }
Example #5
0
        public override long Seek(long offset, SeekOrigin origin)
        {
            if (!CanSeek)
            {
                throw new NotSupportedException("The stream does not support seeking");
            }
            if (IsAsync && origin == SeekOrigin.Current)
            {
                throw new NotSupportedException("Cannot tell what the offset is in async mode");
            }

            SeekPosition seekPos   = SeekPosition.Start;
            long         newOffset = -1;

            switch (origin)
            {
            case SeekOrigin.Begin:
                seekPos   = SeekPosition.Start;
                newOffset = offset;
                break;

            case SeekOrigin.Current:
                seekPos = SeekPosition.Current;
                break;

            case SeekOrigin.End:
                seekPos   = SeekPosition.End;
                newOffset = Length + offset;
                break;
            }

            Result result;

            if (async)
            {
                Async.Seek(handle, seekPos, offset, callback);
                Wait();
                result = asyncResult;
            }
            else
            {
                result = Sync.Seek(handle, seekPos, offset);
            }
            Vfs.ThrowException(Uri, result);
            return(newOffset);
        }
        public async Task <IObservable <BusinessData <TBusinessData> > > CreateObservable(CancellationToken cancellationToken = default)
        {
            this.cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

            this.deletetionTask = Task.Run(() => this.DeleteOldSnapshots(
                                               maxAge: TimeSpan.FromDays(1),
                                               sleepTime: TimeSpan.FromMinutes(1),
                                               cancellationToken: this.cts.Token));

            var updateFunc = this.applyUpdate.ToFSharpFunc();

            FSharpResult <BusinessData <TBusinessData>, BusinessDataUpdateError> snapshotResult = await this.FetchBusinessDataSnapshot(this.cts.Token);

            if (snapshotResult.IsError)
            {
                return(Observable.Throw <BusinessData <TBusinessData> >(((BusinessDataUpdateError.SnapshotDownloadError)snapshotResult.ErrorValue).Item));
            }

            var snapshot = snapshotResult.ResultValue;

            IConnectableObservable <BusinessData <TBusinessData> > connectableObservable =
                this.updateMessagingClient
                .CreateWatermarkObervable(
                    startingPosition: SeekPosition.NewFromWatermark(
                        snapshot.Watermark.Add(1)),
                    cancellationToken: this.cts.Token)
                .Scan(
                    seed: snapshotResult,
                    accumulator: (businessData, updateMessage)
                    => updateBusinessData(updateFunc, businessData, updateMessage))         // .Where(d => d.IsOk)
                .Select(d => d.ResultValue)
                .StartWith(snapshot)
                .Publish(initialValue: snapshot);

            _ = connectableObservable.Connect();

            return(connectableObservable.AsObservable());
        }
Example #7
0
 public static Result Seek(Handle handle, SeekPosition whence, long offset)
 {
     return(gnome_vfs_seek(handle.Handle, whence, offset));
 }
Example #8
0
 private static extern void gnome_vfs_async_seek(IntPtr handle, SeekPosition whence, long offset, AsyncCallbackNative callback, IntPtr data);
Example #9
0
 /// <summary>
 /// シークする
 /// </summary>
 public void Seek(SeekPosition seekPosition)
 {
     manager.Seek(seekPosition == SeekPosition.Start ? manager.StartFrame : manager.StartFrame + manager.FrameLength);
 }
Example #10
0
		public static Result Seek (Handle handle, SeekPosition whence, long offset)
		{
			return gnome_vfs_seek (handle.Handle, whence, offset);
		}
Example #11
0
		private static extern Result gnome_vfs_seek (IntPtr handle, SeekPosition whence, long offset);
Example #12
0
 public static extern int gpgme_data_seek(IntPtr dh, int offset, SeekPosition whence);
Example #13
0
		public static void Seek (Handle handle, SeekPosition whence, long offset, AsyncCallback callback)
		{
			AsyncCallbackWrapper wrapper = new AsyncCallbackWrapper (callback, null);
			gnome_vfs_async_seek (handle.Handle, whence, offset, wrapper.NativeDelegate, IntPtr.Zero);
		}
Example #14
0
		private static extern void gnome_vfs_async_seek (IntPtr handle, SeekPosition whence, long offset, AsyncCallbackNative callback, IntPtr data);
 IObservable <WatermarkMessage <TMessagePayload> > IWatermarkMessageClient <TMessagePayload> .CreateWatermarkObervable(SeekPosition startingPosition, CancellationToken cancellationToken)
 {
     return(CreateObservable(
                consumer: this.consumer,
                tp: this.topicPartition.Value,
                startingPosition: startingPosition,
                cancellationToken: cancellationToken)
            .Select(consumeResult => new WatermarkMessage <TMessagePayload>(
                        watermark: Watermark.NewWatermark(consumeResult.Offset.Value),
                        payload: consumeResult.Message.Value.DeserializeJSON <TMessagePayload>())));
 }
Example #16
0
 private static extern Result gnome_vfs_seek(IntPtr handle, SeekPosition whence, long offset);
Example #17
0
        public static void Seek(Handle handle, SeekPosition whence, long offset, AsyncCallback callback)
        {
            AsyncCallbackWrapper wrapper = new AsyncCallbackWrapper(callback, null);

            gnome_vfs_async_seek(handle.Handle, whence, offset, wrapper.NativeDelegate, IntPtr.Zero);
        }