Beispiel #1
0
 public void Break(BreakType type)
 {
     if (result != null && !result.IsCompleted)
     {
         result.Cancel();
     }
 }
Beispiel #2
0
        public void ScanTableCancelAsync()
        {
            if (!HasAsyncTableScanner) {
                return;
            }

            for (var r = 0; r < 5; ++r) {
                var c = 0;
                using (var asyncResult = new AsyncResult(
                    (ctx, cells) =>
                        {
                            foreach (var cell in cells) {
                                if (c == CountA) {
                                    return AsyncCallbackResult.Abort;
                                }

                                ++c;
                            }

                            return AsyncCallbackResult.Continue;
                        })) {
                    table.BeginScan(asyncResult);
                    asyncResult.Join();
                    Assert.IsNull(asyncResult.Error, asyncResult.Error != null ? asyncResult.Error.ToString() : string.Empty);
                    Assert.IsTrue(asyncResult.IsCompleted);
                    Assert.IsTrue(asyncResult.IsCancelled);
                    Assert.AreEqual(CountA, c);

                    // The official Hypertable version does not support re-using of the future object using the thrift API
                    if (!IsThrift) {
                        c = 0;
                        table.BeginScan(
                            asyncResult,
                            (ctx, cells) =>
                                {
                                    c += cells.Count;
                                    return AsyncCallbackResult.Continue;
                                });
                        Assert.IsFalse(asyncResult.IsCompleted);
                        Assert.IsFalse(asyncResult.IsCancelled);
                        asyncResult.Join();
                        Assert.IsNull(asyncResult.Error, asyncResult.Error != null ? asyncResult.Error.ToString() : string.Empty);
                        Assert.IsTrue(asyncResult.IsCompleted);
                        Assert.IsFalse(asyncResult.IsCancelled);
                        Assert.AreEqual(CountA + CountB + CountC, c);
                    }
                }

                using (var asyncResult = new AsyncResult(delegate { return AsyncCallbackResult.Continue; })) {
                    table.BeginScan(asyncResult);
                    Thread.Sleep(500);
                    asyncResult.Cancel();
                    Assert.IsTrue(asyncResult.IsCancelled);

                    // The official Hypertable version does not support re-using of the future object using the thrift API
                    if (!IsThrift) {
                        c = 0;
                        table.BeginScan(
                            asyncResult,
                            (ctx, cells) =>
                                {
                                    c += cells.Count;
                                    return AsyncCallbackResult.Continue;
                                });
                        Assert.IsFalse(asyncResult.IsCancelled);
                        asyncResult.Join();
                        Assert.IsNull(asyncResult.Error, asyncResult.Error != null ? asyncResult.Error.ToString() : string.Empty);
                        Assert.IsTrue(asyncResult.IsCompleted);
                        Assert.IsFalse(asyncResult.IsCancelled);
                        Assert.AreEqual(CountA + CountB + CountC, c);
                    }
                }
            }
        }
        public void ScanTableCancelAsync()
        {
            if (!HasAsyncTableScanner)
            {
                return;
            }

            for (var r = 0; r < 5; ++r)
            {
                var c = 0;
                using (var asyncResult = new AsyncResult(
                           (ctx, cells) =>
                {
                    foreach (var cell in cells)
                    {
                        if (c == CountA)
                        {
                            return(AsyncCallbackResult.Abort);
                        }

                        ++c;
                    }

                    return(AsyncCallbackResult.Continue);
                })) {
                    table.BeginScan(asyncResult);
                    asyncResult.Join();
                    Assert.IsNull(asyncResult.Error, asyncResult.Error != null ? asyncResult.Error.ToString() : string.Empty);
                    Assert.IsTrue(asyncResult.IsCompleted);
                    Assert.IsTrue(asyncResult.IsCancelled);
                    Assert.AreEqual(CountA, c);

                    // The official Hypertable version does not support re-using of the future object using the thrift API
                    if (!IsThrift)
                    {
                        c = 0;
                        table.BeginScan(
                            asyncResult,
                            (ctx, cells) =>
                        {
                            c += cells.Count;
                            return(AsyncCallbackResult.Continue);
                        });
                        Assert.IsFalse(asyncResult.IsCompleted);
                        Assert.IsFalse(asyncResult.IsCancelled);
                        asyncResult.Join();
                        Assert.IsNull(asyncResult.Error, asyncResult.Error != null ? asyncResult.Error.ToString() : string.Empty);
                        Assert.IsTrue(asyncResult.IsCompleted);
                        Assert.IsFalse(asyncResult.IsCancelled);
                        Assert.AreEqual(CountA + CountB + CountC, c);
                    }
                }

                using (var asyncResult = new AsyncResult(delegate { return(AsyncCallbackResult.Continue); })) {
                    table.BeginScan(asyncResult);
                    Thread.Sleep(500);
                    asyncResult.Cancel();
                    Assert.IsTrue(asyncResult.IsCancelled);

                    // The official Hypertable version does not support re-using of the future object using the thrift API
                    if (!IsThrift)
                    {
                        c = 0;
                        table.BeginScan(
                            asyncResult,
                            (ctx, cells) =>
                        {
                            c += cells.Count;
                            return(AsyncCallbackResult.Continue);
                        });
                        Assert.IsFalse(asyncResult.IsCancelled);
                        asyncResult.Join();
                        Assert.IsNull(asyncResult.Error, asyncResult.Error != null ? asyncResult.Error.ToString() : string.Empty);
                        Assert.IsTrue(asyncResult.IsCompleted);
                        Assert.IsFalse(asyncResult.IsCancelled);
                        Assert.AreEqual(CountA + CountB + CountC, c);
                    }
                }
            }
        }