import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    // Instantiate the container
    Swarm swarm = new Swarm(args);

    // Create one or more deployments
    WARArchive deployment = ShrinkWrap.create(WARArchive.class);

    // Add resource to deployment
    deployment.addPackage(Main.class.getPackage());
    deployment.addAllDependencies();

    // Add Web resources
    deployment.addAsWebResource(
            new ClassLoaderAsset("src/main/webapp/index.html", Main.class.getClassLoader()), "src/main/webapp/index.html");
    deployment.addAsWebInfResource(
            new ClassLoaderAsset("src/main/webapp/WEB-INF/beans.xml", Main.class.getClassLoader()), "beans.xml");


    swarm.start().deploy(deployment);

}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
	Swarm container = new Swarm();

    System.out.println("\tBuilding kie server deployable...");
    JAXRSArchive deployment = createDeployment(container);

    container.fraction(
        new LoggingFraction()
            .consoleHandler("CONSOLE", c -> {
                c.level(Level.INFO);
                c.formatter("%d{HH:mm:ss,SSS} %-5p [%c] (%t) %s%e%n");
            })
            .rootLogger(Level.INFO, "CONSOLE")
    );
    
    System.out.println("\tStaring Wildfly Swarm....");
    container.start();    
    
    System.out.println("\tConfiguring kjars to be auto deployed to server " + Arrays.toString(args));
    installKJars(args);
    
    System.out.println("\tDeploying kie server ....");
    container.deploy(deployment);
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
protected static JAXRSArchive createDeployment(Swarm container) throws Exception {
    System.out.println("\tConfiguration folder is " + configFolder);
    
    LoginModule<?> loginModule = new LoginModule<>("UsersRoles");
    loginModule.flag(Flag.REQUIRED)
    .code("UsersRoles")
    .moduleOption("usersProperties", configFolder + "/security/application-users.properties")
    .moduleOption("rolesProperties", configFolder + "/security/application-roles.properties");
    
    SecurityDomain<?> security = new SecurityDomain<>("other")
            .classicAuthentication(new ClassicAuthentication<>()
                    .loginModule(loginModule)); 
    container.fraction(new SecurityFraction().securityDomain(security));

    JAXRSArchive deployment = ShrinkWrap.create(JAXRSArchive.class, "kie-server.war");
    deployment.staticContent();
    deployment.addAllDependencies();
    deployment.addAsWebInfResource(new File(configFolder + "/web/web.xml"), "web.xml");
    deployment.addAsWebInfResource(new File(configFolder + "/web/jboss-web.xml"), "jboss-web.xml");
    
            
    return deployment;
    
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm newContainer() throws Exception {
    return new Swarm()
            .outboundSocketBinding("standard-sockets",
                    new OutboundSocketBinding("remote-activemq")
                            .remoteHost("localhost")
                            .remotePort(61616))
            .fraction(new MessagingFraction()
                    .server("default", server -> {
                        server.remoteConnector("remote-activemq", connector -> {
                            connector.socketBinding("remote-activemq");
                        });
                        server.pooledConnectionFactory("remote", factory -> {
                            factory.connectors("remote-activemq");
                            factory.entry("java:/jms/remoteCF");
                        });
                    })
            );
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@Test
public void testDeploymentFailure() throws Exception {
    Swarm swarm = new Swarm();
    swarm.start();
    JARArchive a = ShrinkWrap.create(JARArchive.class, "bad-deployment.jar");
    a.addModule("com.i.do.no.exist");
    try {
        swarm.deploy(a);
        fail("should have throw a DeploymentException");
    } catch (DeploymentException e) {
        // expected and correct
        assertThat(e.getArchive()).isSameAs(a);
        assertThat(e.getMessage()).contains("org.jboss.modules.ModuleNotFoundException: com.i.do.no.exist");
    } finally {
        swarm.stop();
    }
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm getContainer() throws Exception {
    Swarm container = new Swarm();
    container.fraction(new JAXRSFraction());
    container.fraction(new MonitorFraction().securityRealm("TestRealm"));
    container.fraction(
            new ManagementFraction()
                    .securityRealm("TestRealm", (realm) -> {
                        realm.inMemoryAuthentication((authn) -> {
                            authn.add(new Properties() {{
                                put("admin", "password");
                            }}, true);
                        });
                        realm.inMemoryAuthorization();
                    })
    );

    return container;
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm newContainer() throws Exception {
    System.out.println("Log file: " + LOG_FILE);

    return new Swarm()
            .fraction(
                    new LoggingFraction()
                            .defaultColorFormatter()
                            .consoleHandler(Level.INFO, "COLOR_PATTERN")
                            .fileHandler("FILE", f -> {

                                Map<String, String> fileProps = new HashMap<>();
                                fileProps.put("path", LOG_FILE);
                                f.file(fileProps);
                                f.level(Level.INFO);
                                f.formatter("%d{HH:mm:ss,SSS} %-5p [%c] (%t) %s%e%n");

                            })
                            .rootLogger(Level.INFO, "CONSOLE", "FILE")
            )
            .fraction(new ZipkinFraction("wildfly-swarm-service"));
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm newContainer() throws Exception {
    return new Swarm()
            .fraction(
                    ManagementFraction.createDefaultFraction()
                            .httpInterfaceManagementInterface((iface) -> {
                                iface.securityRealm("ManagementRealm");
                            })
                            .securityRealm("ManagementRealm", (realm) -> {
                                realm.inMemoryAuthentication((authn) -> {
                                    authn.add(new Properties() {{
                                        put("bob", "9b511b00aa7f2265621e38d2cf665f2f");
                                    }});
                                });
                                realm.inMemoryAuthorization();
                            })
            );
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm newContainer() throws Exception {
    return new Swarm()
            .fraction(
                    ManagementFraction.createDefaultFraction()
                            .httpInterfaceManagementInterface((iface) -> {
                                iface.securityRealm("TestRealm");
                            })
                            .securityRealm("TestRealm", (realm) -> {
                                realm.inMemoryAuthentication((authn) -> {
                                    authn.add("bob", "tacos!", true);
                                });
                                realm.inMemoryAuthorization((authz) -> {
                                    authz.add("bob", "admin");
                                });
                            })
            );
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm newContainer() throws Exception {
    return new Swarm()
            .fraction(
                    ManagementFraction.createDefaultFraction()
                            .httpInterfaceManagementInterface((iface) -> {
                                iface.securityRealm("ManagementRealm");
                            })
                            .securityRealm("ManagementRealm", (realm) -> {
                                realm.inMemoryAuthentication((authn) -> {
                                    authn.add(new Properties() {{
                                        put("bob", "tacos!");
                                    }}, true);
                                });
                                realm.inMemoryAuthorization();
                            })
            );
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String... args) throws Exception {
    swarm = new Swarm(args);

    swarm.fraction(
            new DatasourcesFraction()
                    .jdbcDriver("h2", (d) -> {
                        d.driverClassName("org.h2.Driver");
                        d.xaDatasourceClass("org.h2.jdbcx.JdbcDataSource");
                        d.driverModuleName("com.h2database.h2");
                    })
                    .dataSource("ExampleDS", (ds) -> {
                        ds.driverName("h2");
                        ds.connectionUrl("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
                        ds.userName("sa");
                        ds.password("sa");
                    })
    );

    swarm.start().deploy();
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String... args) throws Exception {
    swarm = new Swarm(args);
    swarm.start();
    Archive<?> deployment = swarm.createDefaultDeployment();
    if (deployment == null) {
        throw new Error("Couldn't create default deployment");
    }

    Node persistenceXml = deployment.get("WEB-INF/classes/META-INF/persistence.xml");

    if (persistenceXml == null) {
        throw new Error("persistence.xml is not found");
    }

    if (persistenceXml.getAsset() == null) {
        throw new Error("persistence.xml is not found");
    }

    swarm.deploy(deployment);
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@CreateSwarm
public static Swarm newContainer() throws Exception {
    return new Swarm()
            .fraction(
                    new LoggingFraction().periodicSizeRotatingFileHandler("FILE", (h) -> {
                        h.level(Level.INFO)
                                .append(true)
                                .suffix(".yyyy-MM-dd")
                                .rotateSize("30m")
                                .enabled(true)
                                .encoding("UTF-8")
                                .maxBackupIndex(2);
                        Map<String, String> fileSpec = new HashMap<>();
                        fileSpec.put("path", logFile);
                        h.file(fileSpec);
                    }).logger("br.org.sistemafieg.cliente", (l) -> {
                        l.level(Level.INFO)
                                .handler("FILE");
                    }));
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String... args) throws Exception {
    if (System.getProperty("boot.module.loader") == null) {
        System.setProperty("boot.module.loader", "org.wildfly.swarm.bootstrap.modules.BootModuleLoader");
    }

    String clsName = System.getProperty(ANNOTATED_CLASS_NAME);

    Class<?> cls = Class.forName(clsName);

    Method[] methods = cls.getMethods();

    for (Method method : methods) {
        if (!Modifier.isStatic(method.getModifiers())) {
            continue;
        }

        CreateSwarm anno = method.getAnnotation(CreateSwarm.class);
        if (anno == null) {
            continue;
        }

        boolean startEagerly = anno.startEagerly();
        ((Swarm) method.invoke(null)).start().deploy();
    }
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public void deploy() throws Exception {
    List<SimpleKey> subkeys = configView.simpleSubkeys(ConfigKey.of("swarm", "deployment"));

    for (SimpleKey subkey : subkeys) {
        String spec = subkey.name();
        if (spec.contains(":")) {
            String[] parts = spec.split(":");
            String groupId = parts[0];
            parts = parts[1].split("\\.");
            String artifactId = parts[0];
            String packaging = parts[1];

            JavaArchive artifact = Swarm.artifact(groupId + ":" + artifactId + ":" + packaging + ":*", artifactId + "." + packaging);
            deployer.get().deploy(artifact, spec);
        }
    }

}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
/**
 * Apply configuration to the container.
 *
 * <p>Applies configuration from <code>Key.SERVER_CONFIG</code> and <code>Key.STAGE_CONFIG</code>.</p>
 *
 * @param swarm Swarm instance to configure.
 * @throws MalformedURLException If a URL is attempted to be read and fails.
 */
public void applyConfigurations(Swarm swarm) throws IOException {
    if (get(SERVER_CONFIG) != null) {
        swarm.withXmlConfig(get(SERVER_CONFIG));
    }
    if (get(CONFIG) != null) {
        List<URL> configs = get(CONFIG);
        for (URL config : configs) {
            swarm.withConfig(config);
        }
    }
    if (get(PROFILES) != null) {
        List<String> profiles = get(PROFILES);
        for (String profile : profiles) {
            swarm.withProfile(profile);
        }
    }
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
/**
 * Apply properties and configuration from the parsed commandline to a container.
 *
 * @param swarm The Swarm instance to apply configuration to.
 * @throws IOException If an error occurs resolving any URL.
 */
public void apply(Swarm swarm) throws IOException, ModuleLoadException {
    applyProperties(swarm);
    applyConfigurations(swarm);

    if (get(HELP)) {
        displayVersion(System.err);
        System.err.println();
        displayHelp(System.err);
        System.exit(0);
    }

    if (get(CONFIG_HELP) != null) {
        displayConfigHelp(System.err, get(CONFIG_HELP));
        System.exit(0);
    }

    if (get(YAML_HELP) != null) {
        dumpYaml(System.err, get(YAML_HELP));
        System.exit(0);
    }

    if (get(VERSION)) {
        displayVersion(System.err);
    }
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
@Override
public List<Archive> getImplicitDeployments(SwaggerWebAppFraction fraction) throws Exception {
    List<Archive> list = new ArrayList<>();
    try {
        // Get the swagger-ui bits as an Archive
        WARArchive war = Swarm.artifact("org.wildfly.swarm:swagger-webapp-ui:war:" + Container.VERSION,
                "swagger-webapp-ui.war")
                .as(WARArchive.class)
                .setContextRoot(fraction.getContext());

        // If any user content has been provided, merge that with the swagger-ui bits
        Archive<?> userContent = fraction.getWebContent();
        if (userContent != null) {
            war.merge(userContent);
        }
        //war.as(ZipExporter.class).exportTo(new File("swagger-webapp-ui.war"), true);
        list.add(war);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return list;
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    Swarm swarm = new Swarm();

    swarm.fraction(new MicroProfileConfigFraction()
            .configSource("numbers-dir-config-source", (cs) -> {
                cs.ordinal(600)
                        .dir("/etc/config/numbers-app/");
            }));

    swarm.start().deploy();
}
 

import org.wildfly.swarm.Swarm; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    Swarm swarm = new Swarm();

    swarm.fraction(new MicroProfileConfigFraction()
            .configSource("my-config-source", (cs) -> {
                cs.ordinal(500)
                .property("my.prop", "Hello, World");
            }));
    // Start the swarm
    swarm.start().deploy();
}