Java Code Examples for com.alibaba.csp.sentinel.slots.block.BlockException#printStackTrace()

private void directlyAsync() {
    try {
        final AsyncEntry entry = SphU.asyncEntry("test-async-not-nested");

        this.invoke("abc", result -> {
            // If no nested entry later, we don't have to wrap in `ContextUtil.runOnContext()`.
            try {
                // Here to handle the async result (without other entry).
            } finally {
                // Exit the async entry.
                entry.exit();
            }
        });
    } catch (BlockException e) {
        // Request blocked, handle the exception.
        e.printStackTrace();
    }
}
 

private void directlyAsync() {
    try {
        final AsyncEntry entry = SphU.asyncEntry("test-async-not-nested");

        this.invoke("abc", result -> {
            // If no nested entry later, we don't have to wrap in `ContextUtil.runOnContext()`.
            try {
                // Here to handle the async result (without other entry).
            } finally {
                // Exit the async entry.
                entry.exit();
            }
        });
    } catch (BlockException e) {
        // Request blocked, handle the exception.
        e.printStackTrace();
    }
}
 

@Test
public void testFlowRule_other() {

    FlowRule flowRule = new FlowRule();
    flowRule.setResource("testOther");
    flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    flowRule.setCount(0);
    flowRule.setLimitApp("other");
    FlowRuleManager.loadRules(Arrays.asList(flowRule));

    Entry e = null;
    try {
        e = SphU.entry("testOther");
    } catch (BlockException e1) {
        e1.printStackTrace();fail("Should had failed");
    }

    if (e != null) {
        e.exit();
    } else {
        fail("Should had failed");
    }
}
 

private void anotherAsync() {
    try {
        final AsyncEntry entry = SphU.asyncEntry("test-another-async");

        CompletableFuture.runAsync(() -> {
            ContextUtil.runOnContext(entry.getAsyncContext(), () -> {
                try {
                    TimeUnit.SECONDS.sleep(2);
                    // Normal entry nested in asynchronous entry.
                    anotherSyncInAsync();

                    System.out.println("Async result: 666");
                } catch (InterruptedException e) {
                    // Ignore.
                } finally {
                    entry.exit();
                }
            });
        });
    } catch (BlockException ex) {
        ex.printStackTrace();
    }
}
 

private void fetchSync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-sync");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

private void anotherSyncInAsync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-another-sync-in-async");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

@Test
public void testAsyncEntryUnderSyncEntry() throws Exception {
    // Expected invocation chain:
    // EntranceNode: machine-root
    // -EntranceNode: async-context
    // --test-top
    // ---test-async
    // ----test-sync-in-async
    // ----test-another-async
    // -----test-another-in-async
    // ---test-sync
    ContextUtil.enter(contextName, origin);
    Entry entry = null;
    try {
        entry = SphU.entry("test-top");
        doAsyncThenSync();
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
        ContextUtil.exit();
    }

    // we keep the original timeout of 15 seconds although the test should
    // complete in less than 3 seconds
    await().timeout(15, TimeUnit.SECONDS)
        .until(new Callable<DefaultNode>() {
            @Override
            public DefaultNode call() throws Exception {
                return queryInvocationTree(false);
            }
        }, CoreMatchers.notNullValue());

    queryInvocationTree(true);
}
 

private void anotherAsync() {
    try {
        final AsyncEntry entry = SphU.asyncEntry("test-another-async");

        runAsync(new Runnable() {
            @Override
            public void run() {
                ContextUtil.runOnContext(entry.getAsyncContext(), new Runnable() {
                    @Override
                    public void run() {
                        try {
                            TimeUnit.MILLISECONDS.sleep(500);
                            anotherSyncInAsync();
                            System.out.println("Async result: 666");
                        } catch (InterruptedException e) {
                            // Ignore.
                        } finally {
                            entry.exit();
                        }
                    }
                });
            }
        });
    } catch (BlockException ex) {
        ex.printStackTrace();
    }
}
 

@Test
public void testAsyncEntryUnderSyncEntry() throws Exception {
    // Expected invocation chain:
    // EntranceNode: machine-root
    // -EntranceNode: async-context
    // --test-top
    // ---test-async
    // ----test-sync-in-async
    // ----test-another-async
    // -----test-another-in-async
    // ---test-sync
    ContextUtil.enter(contextName, origin);
    Entry entry = null;
    try {
        entry = SphU.entry("test-top");
        doAsyncThenSync();
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
        ContextUtil.exit();
    }

    // we keep the original timeout of 15 seconds although the test should
    // complete in less than 3 seconds
    await().timeout(15, TimeUnit.SECONDS)
        .until(new Callable<DefaultNode>() {
            @Override
            public DefaultNode call() throws Exception {
                return queryInvocationTree(false);
            }
        }, CoreMatchers.notNullValue());

    queryInvocationTree(true);
}
 

public void anotherSyncInAsync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-another-in-async");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

private void fetchSyncInAsync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-sync-in-async");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

public static void main(String[] args) {
    // You will see this in record.log, indicating that the custom slot chain builder is activated:
    // [SlotChainProvider] Global slot chain builder resolved: com.alibaba.csp.sentinel.demo.slot.DemoSlotChainBuilder
    Entry entry = null;
    try {
        entry = SphU.entry("abc");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

public static void main(String[] args) throws Exception {
    initFlowRule();

    AsyncEntryDemo service = new AsyncEntryDemo();

    // Expected invocation chain:
    //
    // EntranceNode: machine-root
    // -EntranceNode: async-context
    // --test-top
    // ---test-sync
    // ---test-async
    // ----test-another-async
    // -----test-another-sync-in-async
    // ----test-sync-in-async
    ContextUtil.enter("async-context", "originA");
    Entry entry = null;
    try {
        entry = SphU.entry("test-top");
        System.out.println("Do something...");
        service.doAsyncThenSync();
    } catch (BlockException ex) {
        // Request blocked, handle the exception.
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
        ContextUtil.exit();
    }

    TimeUnit.SECONDS.sleep(20);
}
 

public void anotherSyncInAsync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-another-in-async");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

private void doAsyncThenSync() {
    try {
        // First we call an asynchronous resource.
        final AsyncEntry entry = SphU.asyncEntry("test-async");
        this.invoke("abc", resp -> {
            // The thread is different from original caller thread for async entry.
            // So we need to wrap in the async context so that nested invocation entry
            // can be linked to the parent asynchronous entry.
            ContextUtil.runOnContext(entry.getAsyncContext(), () -> {
                try {
                    // In the callback, we do another async invocation several times under the async context.
                    for (int i = 0; i < 7; i++) {
                        anotherAsync();
                    }

                    System.out.println(resp);

                    // Then we do a sync (normal) entry under current async context.
                    fetchSyncInAsync();
                } finally {
                    // Exit the async entry.
                    entry.exit();
                }
            });
        });
        // Then we call a sync resource.
        fetchSync();
    } catch (BlockException ex) {
        // Request blocked, handle the exception.
        ex.printStackTrace();
    }
}
 

private void fetchSyncInAsync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-sync-in-async");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

private void fetchSync() {
    Entry entry = null;
    try {
        entry = SphU.entry("test-sync");
    } catch (BlockException ex) {
        ex.printStackTrace();
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}
 

public String sayHelloBlockHandler(String name, BlockException ex) {
    // This is the block handler.
    ex.printStackTrace();
    return String.format("Oops, <%s> blocked by Sentinel", name);
}
 

public String sayHelloBlockHandler(String name, BlockException ex) {
    // This is the block handler.
    ex.printStackTrace();
    return String.format("Oops, <%s> blocked by Sentinel", name);
}
 

public String exceptionHandler(long s, BlockException ex) {
    // Do some log here.
    ex.printStackTrace();
    return "Oops, error occurred at " + s;
}