Java TkForward类代码示例

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * PsBasic can request authentication.
 * @throws Exception If some problem inside
 */
@Test
public void requestAuthentication() throws Exception {
    final Take take = new TkForward(
        new TkAuth(
            new TkSecure(
                new TkText("secured area...")
            ),
            new PsBasic(
                "the realm 5",
                new PsBasic.Default("bob pwd88 urn:users:bob")
            )
        )
    );
    MatcherAssert.assertThat(
        new RsPrint(
            take.act(new RqFake())
        ).print(),
        Matchers.containsString("HTTP/1.1 401 Unauthorized\r\n")
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * TkCommand can add new domain.
 * @throws Exception If something goes wrong.
 */
@Test
public void addsNewDomain() throws Exception {
    final String name = "foo";
    final String urn = "urn:test:19";
    final Request req = new RqWithAuth(
        urn,
        new RqFake(
            "GET",
            String.format(
                "/d/%s?command=domain+add+test.thindeck.com", name
            )
        )
    );
    final Base base = new FkBase();
    final Decks decks = base.user(urn).decks();
    decks.add(name);
    new FkDeck("", new TkForward(new TkCommand(base))).route(req).get();
    MatcherAssert.assertThat(
        new Deck.Smart(decks.get(name)).xml(),
        XhtmlMatchers.hasXPaths(
            "/deck/domains[count(domain)=1]",
            "/deck/domains[domain='test.thindeck.com']"
        )
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
private static Take make(Base base) {
    return new TkAppFallback(
            new TkSlf4j(
                    new TkForward(
                            new TkFork(
                                    new FkRegex("/", "try /categories"),
                                    new FkRegex("/categories", new TkFork(
                                            new FkMethods("GET", new TkCategories(base)),
                                            new FkMethods("POST,PUT", new TkCategoryAdd(base))
                                    )),
                                    new FkRegex("/categories/(?<number>[^/]+)", new TkFork(
                                            new FkMethods("GET", new TkCategory(base)),
                                            new FkMethods("POST,PUT", new TkCategoryUpdate(base)),
                                            new FkMethods("DELETE", new TkCategoryDelete(base))
                                    )),
                                    new FkRegex("/products", new TkFork(
                                            new FkMethods("GET", new TkProducts(base)),
                                            new FkMethods("POST,PUT", new TkProductAdd(base))
                                    )),
                                    new FkRegex("/products/(?<number>[^/]+)", new TkFork(
                                            new FkMethods("GET", new TkProduct(base)),
                                            new FkMethods("POST,PUT", new TkProductUpdate(base)),
                                            new FkMethods("DELETE", new TkProductDelete(base))
                                    )),
                                    new FkRegex("/categories/(?<number>[^/]+)/products", new TkFork(
                                            new FkMethods("GET", new TkCategoryProducts(base)),
                                            new FkMethods("POST,PUT", new TkCategoryProductsAdd(base))
                                    )),
                                    new FkRegex("/categories/(?<ctgId>[^/]+)/products/(?<prdId>[^/]+)", new TkFork(
                                            new FkMethods("POST,PUT", new TkCategoryProductAdd(base)),
                                            new FkMethods("DELETE", new TkCategoryProductDelete(base))
                                    ))
                            )
                    )
            )
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * Ctor.
 * @param base Base
 * @return Takes
 * @throws IOException If fails
 */
private static Take make(final Base base) throws IOException {
    if (!"UTF-8".equals(Charset.defaultCharset().name())) {
        throw new IllegalStateException(
            String.format(
                "default encoding is %s", Charset.defaultCharset()
            )
        );
    }
    return new TkWithHeaders(
        new TkVersioned(
            new TkMeasured(
                new TkGzip(
                    new TkFlash(
                        new TkAppFallback(
                            new TkAppAuth(
                                new TkForward(
                                    TkApp.regex(base)
                                )
                            )
                        )
                    )
                )
            )
        ),
        String.format("X-Wring-Revision: %s", TkApp.REV),
        "Vary: Cookie"
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * Ctor.
 * @param base Base
 * @return Take
 * @throws IOException If fails
 */
private static Take make(final Base base) throws IOException {
    if (!"UTF-8".equals(Charset.defaultCharset().name())) {
        throw new IllegalStateException(
            String.format(
                "default encoding is %s", Charset.defaultCharset()
            )
        );
    }
    return new TkWithHeaders(
        new TkVersioned(
            new TkMeasured(
                new TkFlash(
                    new TkAppFallback(
                        new TkForward(
                            new TkAppAuth(
                                TkApp.regex(base)
                            )
                        )
                    )
                )
            )
        ),
        String.format("X-Thindeck-Version: %s", TkApp.VERSION),
        "Vary: Cookie"
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * TkCommand can forward to the right URL.
 * @throws Exception If something goes wrong.
 */
@Test
public void forwardsCorrectly() throws Exception {
    final String name = "orchard";
    final String urn = "urn:test:554";
    final Request req = new RqWithAuth(
        urn,
        new RqFake(
            "X",
            String.format(
                "/d/%s?command=domain+remove+x.com", name
            )
        )
    );
    final Base base = new FkBase();
    final Decks decks = base.user(urn).decks();
    decks.add(name);
    MatcherAssert.assertThat(
        new RsPrint(
            new TkForward(
                new TkFork(
                    new FkDeck("", new TkCommand(base))
                )
            ).act(req)
        ).printHead(),
        Matchers.containsString(
            String.format("Location: http://www.example.com/d/%s", name)
        )
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * TkCommand can add new repo.
 * @throws Exception If something goes wrong.
 */
@Test
public void addsNewRepo() throws Exception {
    final String name = "lion";
    final String urn = "urn:test:443";
    final Request req = new RqWithAuth(
        urn,
        new RqFake(
            "PUT",
            String.format(
                "/d/%s?command=repo+put+https://github.com/yegor256/x.git",
                name
            )
        )
    );
    final Base base = new FkBase();
    final Decks decks = base.user(urn).decks();
    decks.add(name);
    new FkDeck("", new TkForward(new TkCommand(base))).route(req).get();
    MatcherAssert.assertThat(
        new Deck.Smart(decks.get(name)).xml(),
        XhtmlMatchers.hasXPaths(
            "/deck/repo",
            "/deck/repo/uri"
        )
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * TkCommand can waste a container.
 * @throws Exception If something goes wrong.
 */
@Test
public void wastesSelectedContainer() throws Exception {
    final String name = "tiger";
    final String urn = "urn:test:909";
    final Request req = new RqWithAuth(
        urn,
        new RqFake(
            "POST",
            String.format("/d/%s?command=container+waste+a1b2c3e4", name)
        )
    );
    final Base base = new FkBase();
    final Decks decks = base.user(urn).decks();
    decks.add(name);
    new Deck.Smart(decks.get(name)).update(
        Joiner.on(' ').join(
            "<deck><containers><container",
            " type='blue' state='alive'><name>a1b2c3e4</name>",
            "<host>127.0.0.1</host><image>foo/foo-aaaabbbb</image>",
            "</container></containers></deck>"
        )
    );
    new FkDeck("", new TkForward(new TkCommand(base))).route(req).get();
    MatcherAssert.assertThat(
        new Deck.Smart(decks.get(name)).xml(),
        XhtmlMatchers.hasXPaths(
            "/deck/containers/container[name='a1b2c3e4' and @waste]"
        )
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * TkCommand can waste an image.
 * @throws Exception If something goes wrong.
 */
@Test
public void wastesSelectedImage() throws Exception {
    final String name = "panda";
    final String urn = "urn:test:4333";
    final Request req = new RqWithAuth(
        urn,
        new RqFake(
            "INFO",
            String.format(
                "/d/%s?command=image+waste+test/test-a1b2c3e4", name
            )
        )
    );
    final Base base = new FkBase();
    final Decks decks = base.user(urn).decks();
    decks.add(name);
    new Deck.Smart(decks.get(name)).update(
        Joiner.on(' ').join(
            "<deck><images><image",
            " type='blue'><name>test/test-a1b2c3e4</name>",
            "<repo>abcd0099</repo><uri>#</uri>",
            "</image></images></deck>"
        )
    );
    new FkDeck("", new TkForward(new TkCommand(base))).route(req).get();
    MatcherAssert.assertThat(
        new Deck.Smart(decks.get(name)).xml(),
        XhtmlMatchers.hasXPaths(
            "/deck/images/image[name='test/test-a1b2c3e4' and @waste]"
        )
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * Ctor.
 * @param base Base
 * @return App
 * @throws IOException If fails
 */
private static Take app(final Base base) throws IOException {
    return new TkWithHeaders(
        new TkVersioned(
            new TkMeasured(
                new TkFlash(
                    TkApp.auth(
                        TkApp.safe(
                            new TkForward(
                                new TkGzip(
                                    new TkFork(
                                        new FkRegex("/robots.txt", ""),
                                        new FkRegex(
                                            "/org/takes/.+\\.xsl",
                                            new TkClasspath()
                                        ),
                                        new FkRegex(
                                            "/xsl/[a-z\\-]+\\.xsl",
                                            new TkWithType(
                                                TkApp.refresh("./src/main/xsl"),
                                                "text/xsl"
                                            )
                                        ),
                                        new FkRegex(
                                            "/css/[a-z]+\\.css",
                                            new TkWithType(
                                                TkApp.refresh("./src/main/scss"),
                                                "text/css"
                                            )
                                        ),
                                        new FkRegex(
                                            "/images/[a-z]+\\.svg",
                                            new TkWithType(
                                                TkApp.refresh("./src/main/resources"),
                                                "image/svg+xml"
                                            )
                                        ),
                                        new FkRegex(
                                            "/images/[a-z]+\\.png",
                                            new TkWithType(
                                                TkApp.refresh("./src/main/resources"),
                                                "image/png"
                                            )
                                        ),
                                        new FkRegex("/", new TkIndex()),
                                        new FkRegex("/scripts", new TkScripts(base)),
                                        new FkRegex("/script", new TkScript(base)),
                                        new FkRegex("/save", new TkSave(base)),
                                        new FkRegex("/delete", new TkDelete(base)),
                                        new FkRegex("/flush", new TkFlush(base)),
                                        new FkRegex("/pay", new TkPay(base)),
                                        new FkRegex("/delete-log", new TkDeleteLog(base)),
                                        new FkRegex("/logs", new TkLogs(base)),
                                        new FkRegex("/log", new TkLog()),
                                        new FkRegex("/log-link", new TkLogLink(base))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ),
        new Sprintf("X-ThreeCopies-Revision: %s", TkApp.REV).toString(),
        "Vary: Cookie"
    );
}
 

import org.takes.facets.forward.TkForward; //导入依赖的package包/类
/**
 * Ctor.
 * @param home Home directory
 * @return The take
 * @throws IOException If fails
 */
private static Take make(final Path home) throws IOException {
    final Futures futures = new Futures(new Reports(home));
    return new TkFallback(
        new TkForward(
            new TkFork(
                new FkRegex("/", new TkIndex()),
                new FkRegex("/robots.txt", new TkText("")),
                new FkRegex("/mistakes", new TkMistakes()),
                new FkRegex(
                    "/flush",
                    (Take) req -> new RsText(
                        String.format("%d flushed", new Results().flush())
                    )
                ),
                new FkRegex("/all", new TkAll()),
                new FkRegex("/queue", new TkQueue(futures)),
                new FkRegex(
                    ".+\\.xsl",
                    new TkWithType(
                        new TkClasspath(),
                        "text/xsl"
                    )
                ),
                new FkRegex(
                    "/jpeek\\.css",
                    new TkWithType(
                        new TkText(
                            new TextOf(
                                new ResourceOf("org/jpeek/jpeek.css")
                            ).asString()
                        ),
                        "text/css"
                    )
                ),
                new FkRegex(
                    "/([^/]+)/([^/]+)(.*)",
                    new TkReport(
                        new AsyncReports(
                            // @checkstyle MagicNumber (1 line)
                            new SolidBiFunc<>(futures, 100)
                        )
                    )
                )
            )
        ),
        new FbChain(
            new FbStatus(
                HttpURLConnection.HTTP_NOT_FOUND,
                (Fallback) req -> new Opt.Single<>(
                    new RsWithStatus(
                        new RsText(req.throwable().getMessage()),
                        req.code()
                    )
                )
            ),
            req -> {
                Sentry.capture(req.throwable());
                return new Opt.Single<>(
                    new RsWithStatus(
                        new RsText(
                            new TextOf(req.throwable()).asString()
                        ),
                        HttpURLConnection.HTTP_INTERNAL_ERROR
                    )
                );
            }
        )
    );
}