首次提交

.gitignore

@@ -9,6 +9,12 @@
*.war
*.ear
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

pom.xml

@@ -0,0 +1,176 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.yihu.ehr</groupId>
        <artifactId>ehr-cloud-parent</artifactId>
        <version>1.13.1</version>
    </parent>
    <artifactId>svr-eip-broker</artifactId>
    <version>1.3.0</version>
    <packaging>war</packaging>
    <name>svr-eip-broker</name>
    <description>EIP服务运行模块</description>
    <dependencies>
        <!--<dependency>-->
            <!--<groupId>org.springframework.cloud</groupId>-->
            <!--<artifactId>spring-cloud-netflix</artifactId>-->
            <!--&lt;!&ndash;<version>${spring-cloud-version}</version>&ndash;&gt;-->
            <!--<type>pom</type>-->
            <!--<scope>import</scope>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!-- spring-boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.ow2.asm</groupId>
                    <artifactId>asm</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.yihu.hos</groupId>
            <artifactId>hos-web-framework</artifactId>
            <version>${hos-version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
        <!-- sigar -->
        <dependency>
            <groupId>org.fusesource</groupId>
            <artifactId>sigar</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
        </dependency>
        <!-- camel -->
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>spi-annotations</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-http4</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-jms</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-cxf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http-jetty</artifactId>
            <version>3.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-xmljson</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-restlet</artifactId>
        </dependency>
        <!-- camel end -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot-version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <mainClass>com.yihu.hos.broker.HosBrokerApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

src/main/java/camel/Empty.java

@@ -0,0 +1,9 @@
package camel;
/**
 * Do nothing only hold the package to escape error tip
 * @author Airhead
 * @created 2018-01-31
 */
public interface Empty {
}

src/main/java/com/yihu/hos/broker/HosBrokerApplication.java

@@ -0,0 +1,56 @@
package com.yihu.hos.broker;
import com.yihu.hos.broker.services.camel.CamelStartBoot;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.mongodb.gridfs.GridFsOperations;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@EnableScheduling
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
@EnableAsync
@ComponentScan(value = {"com.yihu.hos.broker", "camel"})
@EnableEurekaClient
public class HosBrokerApplication extends SpringBootServletInitializer implements CommandLineRunner {
    @Autowired
    private GridFsOperations operations;
    @Autowired
    private CamelStartBoot camelStartBoot;
    private ExecutorService executorService = Executors.newFixedThreadPool(2);//java.util.concurrent.RejectedExecutionException   https://blog.csdn.net/wzy_1988/article/details/38922449
    public static void main(String[] args) {
        SpringApplication.run(HosBrokerApplication.class, args);
    }
    @Override
    public void run(String... strings) throws Exception {
        camelStartBoot.start();
        executorService.execute(() -> camelStartBoot.serveProcessor());
        executorService.execute(() -> camelStartBoot.serveRouter());
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                camelStartBoot.shutdown();
                executorService.shutdown();
            } catch (Exception ignored) {
                ignored.printStackTrace();
            }
        }));
    }
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(HosBrokerApplication.class);
    }
}

src/main/java/com/yihu/hos/broker/common/camelrouter/BrokerServerRouter.java

@@ -0,0 +1,23 @@
package com.yihu.hos.broker.common.camelrouter;
import com.yihu.hos.broker.configurations.ArbiterConfiguration;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
 * @created Airhead 2016/8/1.
 */
@Component
public class BrokerServerRouter extends RouteBuilder {
    @Autowired
    private ArbiterConfiguration arbiterConfiguration;
    @Override
    public void configure() throws Exception {
        if (arbiterConfiguration.getEnable()) {
            from("timer:heartbeat?period={{hos.timer.period}}")
                    .to("bean:brokerServerService?method=heartbeat");
        }
    }
}

src/main/java/com/yihu/hos/broker/common/camelrouter/MonitorRouterBulider.java

@@ -0,0 +1,24 @@
package com.yihu.hos.broker.common.camelrouter;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;
/**
 * Created by l4qiang on 2017-06-16.
 */
@Component
public class MonitorRouterBulider extends RouteBuilder {
    @Override
    public void configure() throws Exception {
        // 服务器硬件数据采集
        from("quartz://monitor/serverMonitor?cron=0 0/1 * * * ?")
                .to("bean:serverMonitorService?method=collectEnvHealth");
        // 服务器ip列表检查，用于检查服务器列表是否注册到数据库中，没注册则添加
        // @Scheduled(cron = "0 0 12 * * ?") //每天中午12点触发
        from("quartz://monitor/checkHost?cron=0 0 12 * * ?")
                .to("bean:serverMonitorService?method=checkHost");
    }
}

src/main/java/com/yihu/hos/broker/common/constants/BrokerConstant.java

@@ -0,0 +1,13 @@
package com.yihu.hos.broker.common.constants;
/**
 * Created by Administrator on 2016/4/13.
 */
public class BrokerConstant {
    public static String CLASS_SUFFIX = ".class";
    public static String JAVA_SUFFIX = ".java";
    public static String CLASS = "class";
    public static String ROUTE = "route";
    public static String PROCESSOR = "processor";
}

src/main/java/com/yihu/hos/broker/common/constants/MonitorConstant.java

@@ -0,0 +1,17 @@
package com.yihu.hos.broker.common.constants;
/**
 * @author HZY
 * @vsrsion 1.0
 * Created at 2016/11/3.
 */
public interface MonitorConstant {
    String DATABASE = "log";
    String SERVER = "server";
    String HOST = "host";     //这个是否需要，可以在runtime库中使用brokerServer？
    String CPU = "cpu";
    String FILES = "files";
    String MEMORY = "memory";
    String NET = "net";
}

src/main/java/com/yihu/hos/broker/common/log/JmsAppender.java

@@ -0,0 +1,25 @@
package com.yihu.hos.broker.common.log;
import ch.qos.logback.classic.net.JMSQueueAppender;
import ch.qos.logback.classic.net.JMSTopicAppender;
import ch.qos.logback.classic.spi.ILoggingEvent;
import java.util.Map;
/**
 * Logback JMSQueueAppender
 * <p>
 * Created by l4qiang on 2017-04-12.
 */
public class JmsAppender extends JMSTopicAppender {
    @Override
    public void append(ILoggingEvent event) {
        Map<String, String> mdcPropertyMap = event.getMDCPropertyMap();
        if (mdcPropertyMap.size() == 0) {
            return;
        }
        super.append(event);
    }
}

src/main/java/com/yihu/hos/broker/common/log/TracerFormatter.java

@@ -0,0 +1,68 @@
package com.yihu.hos.broker.common.log;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.model.ProcessorDefinition;
import org.apache.camel.processor.interceptor.DefaultTraceFormatter;
import org.apache.camel.processor.interceptor.TraceInterceptor;
import java.util.Map;
/**
 * 处理日志格式
 * Created by l4qiang on 2017-04-14.
 */
public class TracerFormatter extends DefaultTraceFormatter {
    @Override
    public Object format(TraceInterceptor interceptor, ProcessorDefinition<?> node, Exchange exchange) {
        System.out.println(exchange.getIn().getBody());
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            ObjectNode rootNode = objectMapper.createObjectNode();
            {
                Message in = exchange.getIn();
                ObjectNode inNode = rootNode.with("in");
                Map<String, Object> headers = in.getHeaders();
                headers.forEach((key, value) -> {
                    if (value == null) {
                        return;
                    }
                    inNode.put(key, value.toString());
                });
                if (in.getBody() != null) {
                    inNode.put("body", in.getBody(String.class));
                }
            }
            {
                ObjectNode outNode = rootNode.with("out");
                Message out = exchange.getOut();
                Map<String, Object> headers = out.getHeaders();
                headers.forEach((key, value) -> {
                    if (value == null) {
                        return;
                    }
                    outNode.put(key, value.toString());
                });
                if (out.getBody() != null) {
                    outNode.put("body", out.getBody(String.class));
                }
            }
            return objectMapper.writeValueAsString(rootNode);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return exchange.getIn().getBody();
    }
}

src/main/java/com/yihu/hos/broker/common/shell/SSHLinuxTool.java

@@ -0,0 +1,186 @@
package com.yihu.hos.broker.common.shell;
import com.jcraft.jsch.*;
import com.yihu.hos.core.file.FileUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Vector;
/**
 * ssh 链接操作测试类
 *
 * @author HZY
 * @vsrsion 1.0
 * Created at 2017/1/3.
 */
@RefreshScope
@Service("SSHLinuxTool")
public class SSHLinuxTool {
    public static final String BEAN_ID = "SSHLinuxTool";
    @Value("${hos.jcraft.host}")
    private String host;
    @Value("${hos.jcraft.port}")
    private String port;
    @Value("${hos.jcraft.user}")
    private String user;
    @Value("${hos.jcraft.password}")
    private String password;
    public static Channel channel = null;
    /**
     * //TODO 密钥密码等验证
     * 建立一个shell连接会话
     *
     * @return
     * @throws JSchException
     */
    public Session getsessionConn() throws JSchException {
        JSch jsch = new JSch();
        Session session = jsch.getSession(user, host, Integer.parseInt(port));
        session.setConfig("StrictHostKeyChecking", "no");
        //    java.util.Properties config = new java.util.Properties();
        //   config.put("StrictHostKeyChecking", "no");
        session.setTimeout(600000); // 设置timeout时间
        session.setPassword(password);
        session.connect();
        return session;
    }
//    public String exeCommand(Session session, String command, boolean exit) throws JSchException, IOException {
//
//        if (!session.isConnected()) {
//            session = getsessionConn();
//        }
//
//        ChannelExec channelExec = (ChannelExec) session.openChannel("exec");
//        InputStream in = channelExec.getInputStream();
//        channelExec.setCommand(command);
//        channelExec.setErrStream(System.err);
//        channelExec.connect();
//        String out = IOUtils.toString(in, "UTF-8");
//        if (exit) {
//            channelExec.disconnect();
//        }
//        return out;
//    }
    /**
     * 利用JSch实现远程主机SHELL命令执行
     */
    public  String sshShell(Session session, String command, boolean exit) throws Exception {
        //如果服务器连接不上，则抛出异常
        if (session == null) {
            throw new Exception("session is null");
        }
        try {
            //创建sftp通信通道
            if (channel == null) {
                channel = session.openChannel("shell");
                channel.connect(3000);
            }
            //获取输入流和输出流
            InputStream instream = channel.getInputStream();
            OutputStream outstream = channel.getOutputStream();
            //发送需要执行的SHELL命令，需要用\n结尾，表示回车
            String shellCommand = command;
            outstream.write(shellCommand.getBytes());
            outstream.flush();
            while (instream.available()<1){
                //获取命令执行的结果
                Thread.sleep(1000);
            }
            if (instream.available() > 0) {
                byte[] data = new byte[instream.available()];
                int nLen = instream.read(data);
                if (nLen < 0) {
                    throw new Exception("network error.");
                }
                String result = FileUtil.readFileText(data);
                System.out.println("FileUtil獲取内容："+result);
                //转换输出结果并打印出来
                String temp = new String(data, 0, nLen, "utf-8");
                System.out.println(temp);
                return temp;
            }
            outstream.close();
            instream.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (exit) {
                channel.disconnect();
                session.disconnect();
            }
        }
        return null;
    }
    /**
     *
     * @param session       ssh会话
     * @param inputStream   文件流
     * @param targetDir     上传的目标文件夹
     * @param targetFileName    上传的目标文件名
     * @throws Exception
     */
    public  void sshSftp(Session session,InputStream inputStream, String targetDir,String targetFileName) throws Exception{
        Channel channel = null;
        //如果服务器连接不上，则抛出异常
        if (session == null) {
            throw new Exception("session is null");
        }
        try {
            //创建sftp通信通道
            channel = (Channel) session.openChannel("sftp");
            channel.connect(1000);
            ChannelSftp sftp = (ChannelSftp) channel;
            //进入服务器指定的文件夹
            sftp.cd(targetDir);
            //列出服务器指定的文件列表
            Vector v = sftp.ls("*.txt");
            for(int i=0;i<v.size();i++){
                System.out.println(v.get(i));
            }
            //以下代码实现从本地上传一个文件到服务器，如果要实现下载，对换以下流就可以了
            OutputStream outstream = sftp.put(targetFileName);
            byte b[] = new byte[1024];
            int n;
            while ((n = inputStream.read(b)) != -1) {
                outstream.write(b, 0, n);
            }
            outstream.flush();
            outstream.close();
            inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            channel.disconnect();
        }
    }
}

src/main/java/com/yihu/hos/broker/configurations/ActivemqConfiguration.java

@@ -0,0 +1,31 @@
package com.yihu.hos.broker.configurations;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
/**
 * @created Airhead 2016/8/4.
 */
@RefreshScope
@Configuration
public class ActivemqConfiguration {
    @Value("${spring.activemq.broker-url}")
    private String brokerURL;
    @Value("${spring.activemq.user}")
    private String user;
    @Value("${spring.activemq.password}")
    private String password;
    public String getBrokerURL() {
        return brokerURL;
    }
    public String getUser() {
        return user;
    }
    public String getPassword() {
        return password;
    }
}

src/main/java/com/yihu/hos/broker/configurations/ApplicationConfiguration.java

@@ -0,0 +1,23 @@
package com.yihu.hos.broker.configurations;
import org.springframework.boot.context.embedded.EmbeddedServletContainerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
/**
 * @created Airhead 2016/8/1.
 */
@Configuration
public class ApplicationConfiguration implements ApplicationListener<EmbeddedServletContainerInitializedEvent> {
    private int port;
    @Override
    public void onApplicationEvent(EmbeddedServletContainerInitializedEvent event) {
        port = event.getEmbeddedServletContainer().getPort();
    }
    public int getPort() {
        return port;
    }
}

src/main/java/com/yihu/hos/broker/configurations/ArbiterConfiguration.java

@@ -0,0 +1,33 @@
package com.yihu.hos.broker.configurations;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;
/**
 * @created Airhead 2016/8/1.
 */
@RefreshScope
@Component
public class ArbiterConfiguration {
    @Value("${hos.arbiter.enable}")
    private boolean enable;
    @Value("${hos.arbiter.url}")
    private String server;
    @Value("${hos.tenant.name}")
    private String tenant;
    public String getServer() {
        return server;
    }
    public boolean getEnable() {
        return enable;
    }
    public String getTenant() {
        return tenant;
    }
}

src/main/java/com/yihu/hos/broker/configurations/MongoConfiguration.java

@@ -0,0 +1,53 @@
package com.yihu.hos.broker.configurations;
import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import static java.util.Collections.singletonList;
/**
 * @created Airhead 2016/7/27.
 */
@RefreshScope
@Configuration
public class MongoConfiguration extends AbstractMongoConfiguration {
//    @Value("${spring.data.mongodb.uri}")
//    private String uri;
    @Value("${spring.data.mongodb.host}")
    private String host;
    @Value("${spring.data.mongodb.port}")
    private int port;
    @Value("${spring.data.mongodb.username}")
    private String username;
    @Value("${spring.data.mongodb.password}")
    private String password;
    @Value("${spring.data.mongodb.authenticationDatabase}")
    private String authenticationDatabase;
    @Value("${spring.data.mongodb.database}")
    private String database;
    @Override
    public String getDatabaseName() {
        return database;
    }
    @Bean
    public Mongo mongo() throws Exception {
        return new MongoClient(singletonList(new ServerAddress(host, port)),
                singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
    }
    @Bean
    public MongoClient mongoClient() throws Exception {
        return new MongoClient(singletonList(new ServerAddress(host, port)),
                singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
    }
}

src/main/java/com/yihu/hos/broker/configurations/SwaggerConfig.java

@@ -0,0 +1,45 @@
package com.yihu.hos.broker.configurations;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.async.DeferredResult;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig  {
    private static final String PUBLIC_API = "Default";
    @Bean
    public Docket publicAPI() {
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName(PUBLIC_API)
                .genericModelSubstitutes(DeferredResult.class)
                .useDefaultResponseMessages(false)
                .forCodeGeneration(true)
                .pathMapping("/")
                .select()
                .paths(PathSelectors.regex("/.*"))
                .build()
                .apiInfo(publicApiInfo());
    }
    private ApiInfo publicApiInfo() {
        ApiInfo apiInfo = new ApiInfo("ESB平台API",
                "向其他服务提供的接口。",
                "1.0",
                "No terms of service",
                new Contact("admin@jkzl.com", "", ""),
                "The Apache License, Version 2.0",
                "http://www.apache.org/licenses/LICENSE-2.0.html"
        );
        return apiInfo;
    }
}

src/main/java/com/yihu/hos/broker/controllers/ESBCamelController.java

@@ -0,0 +1,113 @@
package com.yihu.hos.broker.controllers;
import com.yihu.hos.broker.services.camel.ESBCamelService;
import com.yihu.hos.broker.services.camel.SystemCamelContext;
import com.yihu.hos.web.framework.model.Result;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.camel.Route;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 流程管理
 * Created by lingfeng on 2016/8/4.
 */
@RestController
@RequestMapping("/esb")
@RefreshScope
public class ESBCamelController {
    @Autowired
    private ESBCamelService esbCamelService;
    private ExecutorService executorService = Executors.newWorkStealingPool();
    @RequestMapping(value = "/heartbeat", method = RequestMethod.GET)
    @ApiOperation(value = "测试服务器可以正常连接", notes = "测试服务器可以正常连接")
    public String heartbeat() {
        return "test";
    }
    @RequestMapping(value = "/serviceFlow", produces = "application/json;charset=UTF-8", method = RequestMethod.POST)
    @ApiOperation(value = "新增流程", produces = "application/json", notes = "当Arbiter通知一个的流程被创建时，该事件被触发")
    public Result onServiceFlowAdd(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        executorService.execute(() -> esbCamelService.onServiceFlowAdd(msg));
        return Result.success("ok");
    }
    @RequestMapping(value = "/serviceFlow/add", produces = "application/json;charset=UTF-8", method = RequestMethod.POST)
    @ApiOperation(value = "修改流程", produces = "application/json", notes = "当Arbiter通知一个的流程被修改（Router，Process被修改或增加）时，该事件被触发")
    public Result onServiceFlowModifyAdd(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        executorService.execute(() -> esbCamelService.onServiceFlowModifyAdd(msg));
        return Result.success("ok");
    }
    @RequestMapping(value = "/serviceFlow/reduce", produces = "application/json;charset=UTF-8", method = RequestMethod.PUT)
    @ApiOperation(value = "修改流程", produces = "application/json", notes = "当Arbiter通知一个的流程被修改（Router，Process被删除）时，该事件被触发")
    public Result onServiceFlowModifyReduce(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        executorService.execute(() -> esbCamelService.onServiceFlowModifyReduce(msg));
        return Result.success("ok");
    }
    @RequestMapping(value = "/serviceFlow", produces = "application/json;charset=UTF-8", method = RequestMethod.DELETE)
    @ApiOperation(value = "删除流程", produces = "application/json", notes = "当Arbiter通知一个的流程被删除时，该事件被触发")
    public Result onServiceFlowDelete(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        executorService.execute(() -> esbCamelService.onServiceFlowDelete(msg));
        return Result.success("ok");
    }
    @RequestMapping(value = "/serviceFlow/start", produces = "application/json;charset=UTF-8", method = RequestMethod.POST)
    @ApiOperation(value = "启动服务流程", produces = "application/json", notes = "启动服务流程时，该事件被触发")
    public Result onServiceFlowStart(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        executorService.execute(() -> esbCamelService.onServiceFlowStart(msg));
        return Result.success("ok");
    }
    @RequestMapping(value = "/serviceFlow/stop", produces = "application/json;charset=UTF-8", method = RequestMethod.POST)
    @ApiOperation(value = "停止服务流程", produces = "application/json", notes = "停止服务流程时，该事件被触发")
    public Result onServiceFlowStop(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        executorService.execute(() -> esbCamelService.onServiceFlowStop(msg));
        return Result.success("ok");
    }
    @RequestMapping(value = "/serviceFlow/status", produces = "application/json;charset=UTF-8", method = RequestMethod.GET)
    @ApiOperation(value = "服务流程运行状态", produces = "application/json", notes = "查看服务流程的运行状态，运行中/停止")
    public String serviceFlowStatus(
            @ApiParam(name = "routeId", value = "routeId", required = true)
            @RequestParam String routeId) {
        return esbCamelService.getRouteStatus(routeId);
    }
    @RequestMapping(value = "/allFlow/status", produces = "application/json;charset=UTF-8", method = RequestMethod.GET)
    @ApiOperation(value = "所有服务流程运行状态", produces = "application/json", notes = "查看所有服务流程的运行状态，运行中/停止")
    public Map<String, String> allFlowStatus() {
        List<Route> routes = SystemCamelContext.getContext().getRoutes();
        Map<String, String> map = new HashMap<>();
        for (Route route : routes) {
            System.out.println("routId: " + route.getId() + " : " + SystemCamelContext.getContext().getRouteStatus(route.getId()));
            map.put(route.getId(), SystemCamelContext.getContext().getRouteStatus(route.getId()).name());
        }
        return map;
    }
}

src/main/java/com/yihu/hos/broker/controllers/ESBMycatController.java

@@ -0,0 +1,31 @@
package com.yihu.hos.broker.controllers;
import com.yihu.hos.broker.services.MycatConfigService;
import com.yihu.hos.web.framework.model.Result;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/**
 * MyCat管理
 * Created by lingfeng on 2016/8/4.
 */
@RestController
@RequestMapping("/esb")
public class ESBMycatController {
    @Autowired
    private MycatConfigService mycatService;
    @RequestMapping(value = "/serviceMycat/update", produces = "application/json;charset=UTF-8", method = RequestMethod.POST)
    @ApiOperation(value = "修改mycat", produces = "application/json", notes = "修改mycat的配置文件，并重新加载配置")
    public Result updateMycat(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        return mycatService.addeMycat(msg);
    }
}

src/main/java/com/yihu/hos/broker/controllers/ESBShellController.java

@@ -0,0 +1,36 @@
package com.yihu.hos.broker.controllers;
import com.yihu.hos.broker.services.ServerShellService;
import com.yihu.hos.web.framework.model.Result;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
 * @author HZY
 * @vsrsion 1.0
 * SSH命令控制
 * Created at 2017/1/6.
 */
@RestController
@RequestMapping("/esb")
public class ESBShellController {
    @Resource(name = ServerShellService.BEAN_ID)
    private ServerShellService serverShellService;
    @RequestMapping(value = "/serviceShell/send", produces = "application/json;charset=UTF-8", method = RequestMethod.POST)
    @ApiOperation(value = "shell命令执行", produces = "application/json", notes = "执行shell命令并返回结果")
    public Result onServiceFlowModifyAdd(
            @ApiParam(name = "msg", value = "消息", required = true)
            @RequestBody() String msg) {
        return serverShellService.executeShell(msg);
    }
}

src/main/java/com/yihu/hos/broker/daos/BrokerDao.java

@@ -0,0 +1,27 @@
package com.yihu.hos.broker.daos;
import com.yihu.hos.web.framework.model.bo.Endpoint;
import com.yihu.hos.web.framework.model.bo.ServiceFlow;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class BrokerDao {
    private MongoOperations mongoOperations;
    @Autowired
    public void setMongoOperations(MongoOperations mongoOperations) {
        this.mongoOperations = mongoOperations;
    }
    public List<ServiceFlow> getServiceFlowList() {
        return mongoOperations.findAll(ServiceFlow.class);
    }
    public List<Endpoint> getEndPointList() {
        return mongoOperations.findAll(Endpoint.class);
    }
}

src/main/java/com/yihu/hos/broker/services/BrokerServerService.java

@@ -0,0 +1,126 @@
package com.yihu.hos.broker.services;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.hos.broker.configurations.ArbiterConfiguration;
import com.yihu.hos.core.http.HTTPResponse;
import com.yihu.hos.core.http.HttpClientKit;
import com.yihu.hos.core.net.IPChoiceUtils;
import org.apache.camel.util.HostUtils;
import org.apache.camel.util.InetAddressUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
/**
 * @created Airhead 2016/8/1.
 */
@Component("brokerServerService")
public class BrokerServerService {
    private final static Logger logger = LoggerFactory.getLogger(BrokerServerService.class);
    @Autowired
    private ArbiterConfiguration arbiterConfiguration;
    private String hostName;
    private String hostAddress;
    private int port;
    public void login() {
        try {
            hostName = InetAddressUtil.getLocalHostName();
            String host = System.getenv("host");
            if (host == null) {
                hostAddress = HostUtils.getLocalIp();
            } else {    //使用Docker方式时按固定的方式配置
                hostAddress = host;
            }
            port = 8099;    //目前先固定下来
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectNode objectNode = objectMapper.createObjectNode();
            objectNode.put("tenant", arbiterConfiguration.getTenant());
            objectNode.put("hostName", hostName);
            objectNode.put("hostAddress", hostAddress);
            objectNode.put("port", port);
            objectNode.put("enable", true);
            String brokerServer = objectMapper.writeValueAsString(objectNode);
            Map<String, String> params = new HashMap<>();
            params.put("brokerServer", brokerServer);
            String url = arbiterConfiguration.getServer() + "/brokerServer/login";
            HTTPResponse response = HttpClientKit.post(url, params);
            if (response.getStatusCode() != 200) {
                logger.error("register broker server error, url:" + url + ",params:" + brokerServer + ",status code:" + response.getStatusCode());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void heartbeat() {
        try {
            hostName = InetAddressUtil.getLocalHostName();
            String host = System.getenv("host");
            if (host == null) {
                hostAddress = IPChoiceUtils.getSourceIP();
            } else {    //使用Docker方式时按固定的方式配置
                hostAddress = host;
            }
            port = 8099;    //目前先固定下来
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectNode objectNode = objectMapper.createObjectNode();
            objectNode.put("tenant", arbiterConfiguration.getTenant());
            objectNode.put("hostName", hostName);
            objectNode.put("hostAddress", hostAddress);
            objectNode.put("port", port);
            objectNode.put("enable", true);
            String brokerServer = objectMapper.writeValueAsString(objectNode);
            Map<String, String> params = new HashMap<>();
            params.put("brokerServer", brokerServer);
            String url = arbiterConfiguration.getServer() + "/brokerServer/heartbeat";
            HTTPResponse response = HttpClientKit.post(url, params);
            if (response.getStatusCode() != 200) {
                logger.error("heartbeat broker server error, url:" + url + ",params:" + brokerServer + ",status code:" + response.getStatusCode());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * brokerServer下线时通知
     */
    public void logout() {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            ObjectNode objectNode = objectMapper.createObjectNode();
            objectNode.put("hostName", hostName);
            objectNode.put("hostAddress", hostAddress);
            objectNode.put("port", port);
            objectNode.put("enable", false);
            String brokerServer = objectMapper.writeValueAsString(objectNode);
            Map<String, String> params = new HashMap<>();
            params.put("brokerServer", brokerServer);
            String url = arbiterConfiguration.getServer() + "/brokerServer/logout";
            HTTPResponse response = HttpClientKit.delete(url, params);
            if (response.getStatusCode() != 200) {
                logger.error("logout broker server error, url:" + url + ",params:" + brokerServer + ",status code:" + response.getStatusCode());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

src/main/java/com/yihu/hos/broker/services/MycatConfigService.java

@@ -0,0 +1,240 @@
package com.yihu.hos.broker.services;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.hos.broker.common.shell.SSHLinuxTool;
import com.yihu.hos.broker.util.XMLUtil;
import com.yihu.hos.web.framework.constant.MycatConstant;
import com.yihu.hos.web.framework.model.Result;
import com.yihu.hos.web.framework.model.bo.ServiceMycat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.annotation.Resource;
import java.util.Map;
/**
 * @author HZY
 * @vsrsion 1.0
 * Created at 2017/1/24.
 */
@RefreshScope
@Service("MycatConfigService")
public class MycatConfigService {
    public static final String BEAN_ID = "MycatConfigService";
    @Resource(name = SSHLinuxTool.BEAN_ID)
    private SSHLinuxTool sshLinuxTool;
    @Autowired
    private ObjectMapper objectMapper;
    @Value("${hos.mycat.path}")
    private String mycatPath;
    @Resource(name = ServerShellService.BEAN_ID)
    private ServerShellService serverShellService;
    //新增 mycat
    public Result addeMycat(String msg) {
        String result = "";
        try {
            ServiceMycat serviceMycat = objectMapper.readValue(msg, ServiceMycat.class);
            //mycat 修改操作
            System.out.println("修改mycat配置，并重载==================");
            //schema.xml修改
//            String schemaXmlPath =  "e:/conf/schema.xml";
            String schemaXmlPath = mycatPath + "/conf/schema.xml";
            Document schemaXML = XMLUtil.parseXml2Doc(schemaXmlPath);
            schemaXML = addMycatSchema(schemaXML, serviceMycat);
            boolean b1 = XMLUtil.writeToXml(schemaXML, schemaXmlPath);
            //server.mxl修改
//            String serverPath =  "e:/conf/server.xml";
            String serverPath = mycatPath + "/conf/server.xml";
            Document serverXML = XMLUtil.parseXml2Doc(serverPath);
            serverXML = addMycatServer(serverXML, serviceMycat);
            boolean b2 = XMLUtil.writeToXml(serverXML, serverPath);
            //TODO 修改完配置文件后，重启mycat
            mycatRestart(mycatPath + "/bin/");
            if (b1 && b2){
                //TODO  需要做灾难抢救处理
                return Result.success("mycat 修改，重启完成！");
            }else {
                return Result.error("mycat 修改配置失败！！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.error("mycat 修改异常，请处理！！");
    }
    public void mycatRestart( String mycatBinPath) throws Exception {
        StringBuffer command = new StringBuffer();
        command.append("cd ").append(mycatBinPath).append("\r\n");
        command.append("./mycat restart").append("\r\n");
        serverShellService.executeShell(command.toString(), false);
    }
    /***************************************   修改mycat 的schema.xml配置  ****************************************************/
    /**
     * 添加mycat schema.xml 配置
     * @param doc   mycat xml的dom对象
     * @param obj   租户信息
     * @return
     */
    public  Document addMycatSchema(Document doc, ServiceMycat obj) {
        Node stNode = doc.getElementsByTagName("mycat:schema").item(0);
        //获取数据库实例名，当前写死获取第一个
        Element dnElem = (Element)  doc.getElementsByTagName("dataHost").item(0);
        String dataHost = dnElem.getAttribute("name");//数据库实例名
        //添加schema节点
        Element firstSchema = (Element)  doc.getElementsByTagName("schema").item(0);// 第一个schema节点；用于新节点的插入
        Element schemaElem = doc.createElement("schema");
        schemaElem.setAttribute("name", obj.getSchema());
        schemaElem.setAttribute("dataNode",  MycatConstant.DATA_NODE + obj.getSchema());
        schemaElem.setAttribute("checkSQLschema", "false");
        schemaElem.setAttribute("sqlMaxLimit", "100");
        stNode.insertBefore(schemaElem,firstSchema);
//        stNode.appendChild(schemaElem);
        //添加dataNode节点
        Element firstDataNode = (Element)  doc.getElementsByTagName("dataNode").item(0);//  第一个dataNode节点；用于新节点的插入
        Element dataNodeElem = doc.createElement("dataNode");
        dataNodeElem.setAttribute("dataHost", dataHost);
        dataNodeElem.setAttribute("name",  MycatConstant.DATA_NODE + obj.getSchema());
        dataNodeElem.setAttribute("database",  MycatConstant.DATA_BASE + obj.getSchema());
        stNode.insertBefore(dataNodeElem,firstDataNode);
//        stNode.appendChild(dataNodeElem);
        return doc;
    }
    /**
     * 删除schema相关的mycat配置
     * @param doc   mycat xml的dom对象
     * @param obj   租户信息
     * @return
     */
    public  Document delMycatSchema(Document doc, ServiceMycat obj) {
        Node stNode = doc.getElementsByTagName("mycat:schema").item(0);
        //删除schema节点
        Element schemaNode = doc.createElement("schema");
        schemaNode.setAttribute("name",obj.getSchema());
        stNode.removeChild(schemaNode);
        //删除dataNode节点
        Element dataNodeNode = doc.createElement("schema");
        dataNodeNode.setAttribute("name",MycatConstant.DATA_NODE + obj.getSchema());
        stNode.removeChild(dataNodeNode);
        return doc;
    }
    /***************************************   修改mycat server.xml配置  ****************************************************/
    /**
     * 添加mycat  server.xml配置
     * @param doc   mycat xml的dom对象
     * @param obj   租户信息
     * @return
     */
    public  Document addMycatServer(Document doc, ServiceMycat obj) {
        //获取数据库实例名，当前写死获取第一个
        Element stNode = (Element)  doc.getElementsByTagName("mycat:server").item(0);
        //添加user节点
        Element schemaElem = doc.createElement("user");
        schemaElem.setAttribute("name", obj.getLoginName());
        //添加user的属性子节点
        Element password = doc.createElement("property");
        password.setAttribute("name","password");
        password.setTextContent(obj.getPassword());
        Element schemas = doc.createElement("property");
        schemas.setAttribute("name","schemas");
        schemas.setTextContent(obj.getSchema());
        schemaElem.appendChild(password);
        schemaElem.appendChild(schemas);
        stNode.appendChild(schemaElem);
        //TODO 修改管理员节点，添加新的schema，使管理员可以看到所有的schema；
        Element firstUser = (Element)  doc.getElementsByTagName("user").item(0);// 第一个user节点；用于新节点的插入
        NodeList childNodes = firstUser.getElementsByTagName("property");
        for (int i=0;i<childNodes.getLength();i++){
            Element item = (Element)  childNodes.item(i);
            String name = item.getAttribute("name");
            if ("schemas".equals(name)){
                item.setTextContent(item.getTextContent() + "," + obj.getSchema());
            }
        }
        return doc;
    }
    /* **********************************  以下为具体操作方法;暂无用 *********************************************/
    /**
     *  添加schema节点
     * @param doc      xml DOM对象
     * @param childMap   schema节点
     * @return
     */
    public  Document addSchemaElement(Document doc, Map<String ,String> childMap) {
        Node stNode = doc.getElementsByTagName("mycat:schema").item(0);
        Element element = doc.createElement("schema");
        for (Map.Entry<String, String> entry : childMap.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            element.setAttribute(key,value);
        }
        stNode.appendChild(element);
        return doc;
    }
    /**
     * 删除Schema子节点
     * @param doc         xml DOM对象
     * @param schemaName  要删除的子节点名称
     */
    public  void deleteElement(Document doc, String schemaName) {
        Node stNode = doc.getElementsByTagName("mycat:schema").item(0);
        Element schemaNode = doc.createElement("schema");
        schemaNode.setAttribute("name", schemaName);
        stNode.removeChild(schemaNode);
    }
    /**
     * 修改节点属性
     * @param doc          mycat xmldom对象
     * @param schemaName   要修改的节点名称
     * @param childMap 修改的节点属性
     */
    public  Document updateAttributeValue(Document doc,String schemaName ,Map<String,String> childMap) {
        NodeList nodeList = doc.getElementsByTagName("schema");
        if (nodeList != null) {
            //所有schema节点
            for (int i = 0; i < nodeList.getLength(); i++) {
                Element elem = (Element) nodeList.item(i);
                String name = elem.getAttribute("name");
                if (schemaName.equals(name)){
                    //schema节点的所有属性
                    for (Map.Entry<String, String> entry : childMap.entrySet()) {
                        String key = entry.getKey();
                        String value = entry.getValue();
                        elem.setAttribute(key,value);
                    }
                }
            }
        }
        return doc;
    }
}

src/main/java/com/yihu/hos/broker/services/ServerMonitorService.java

@@ -0,0 +1,93 @@
package com.yihu.hos.broker.services;
import com.mongodb.*;
import com.yihu.hos.broker.common.constants.MonitorConstant;
import com.yihu.hos.broker.util.SigarUtil;
import com.yihu.hos.core.datatype.DateUtil;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;
import java.util.List;
//@RefreshScope
//@Service("serverMonitorService")
public class ServerMonitorService {
    @Value("${hos.tenant.name}")
    private String tenant;
    private static String host = SigarUtil.getHost();
    @Autowired
    private Mongo mongo;
    /**
     * 服务器健康指标采集
     *
     * @return
     */
    public void collectEnvHealth() {
        try {
            BasicDBObject result = new BasicDBObject();
            DBCollection terminal = mongo.getDB(MonitorConstant.DATABASE).getCollection(MonitorConstant.SERVER);
            result.put("tenant", tenant);
            result.put("create_date", DateUtil.getCurrentString(DateUtil.DEFAULT_YMDHMSDATE_FORMAT));
            result.put("create_time", DateUtil.getSysDateTime());
            result.put("host", host);
            //cpu
            net.sf.json.JSONObject cpu = net.sf.json.JSONObject.fromObject(SigarUtil.cpu());
            result.put("data", cpu);
            result.put("type", MonitorConstant.CPU);
            terminal.insert(result);
            //内存
            net.sf.json.JSONObject memory = net.sf.json.JSONObject.fromObject(SigarUtil.memory());
            result.put("data", memory);
            result.put("type", MonitorConstant.MEMORY);
            result.remove("_id");
            terminal.insert(result);
            //硬盘
            List<net.sf.json.JSONObject> files = JSONArray.fromObject(SigarUtil.file());
            result.put("data", files);
            result.put("type", MonitorConstant.FILES);
            result.remove("_id");
            terminal.insert(result);
            //网络
            JSONObject net = JSONObject.fromObject(SigarUtil.net());
            result.put("data", net);
            result.put("type", MonitorConstant.NET);
            result.remove("_id");
            terminal.insert(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void checkHost() {
        DBCollection terminal = mongo.getDB(MonitorConstant.DATABASE).getCollection(MonitorConstant.HOST);
        BasicDBObject queryObject = new BasicDBObject().append(QueryOperators.AND,
                new BasicDBObject[]{
                        new BasicDBObject().append("host", host),
                        new BasicDBObject().append("tenant", tenant)});
        DBCursor cursor = terminal.find(queryObject);
        if (cursor.size() < 1) {
            try {
                BasicDBObject result = new BasicDBObject();
                String host = SigarUtil.getHost();
                String hostName = SigarUtil.getHostName();
                result.put("tenant", tenant);
                result.put("name", hostName);
                result.put("host", host);
                terminal.insert(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

src/main/java/com/yihu/hos/broker/services/ServerShellService.java

@@ -0,0 +1,89 @@
package com.yihu.hos.broker.services;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jcraft.jsch.Session;
import com.yihu.hos.broker.common.shell.SSHLinuxTool;
import com.yihu.hos.web.framework.model.Result;
import com.yihu.hos.web.framework.model.bo.ServiceShell;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
 * @author HZY
 * @vsrsion 1.0
 * Created at 2017/1/6.
 */
@Service("ServerShellService")
public class ServerShellService {
    public static final String BEAN_ID = "ServerShellService";
    @Resource(name = SSHLinuxTool.BEAN_ID)
    private SSHLinuxTool sshLinuxTool;
    @Autowired
    private ObjectMapper objectMapper;
    public static Session session ;
    public Result executeShell(String msg) {
        String result="";
        try {
            ServiceShell serviceShell = objectMapper.readValue(msg , ServiceShell.class);
            if (session==null){
                session = sshLinuxTool.getsessionConn();
            }
            if (!serviceShell.isDisconnect()) {
                //保持通道连接
                System.out.println("执行命令，并保持当前会话==================");
                result = sshLinuxTool.sshShell(session, serviceShell.getCommand(), false);
                System.out.println("结果:"+result);
                return Result.success(result);
            } else {
                //断开通道连接，会话
                System.out.println("执行命令，并结束当前会话==================");
                result = sshLinuxTool.sshShell(session, serviceShell.getCommand(), true);
                session = null;
                System.out.println("结果:"+result);
                return Result.success(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.error("shell命令执行失败！");
    }
    public String executeShell(String command,boolean iskeep) {
        String result="";
        try {
            if (session==null){
                session = sshLinuxTool.getsessionConn();
            }
            if (!iskeep) {
                //保持通道连接
                System.out.println("执行命令，并保持当前会话==================");
                result = sshLinuxTool.sshShell(session, command, false);
                System.out.println("结果:"+result);
            } else {
                //断开通道连接，会话
                System.out.println("执行命令，并结束当前会话==================");
                result = sshLinuxTool.sshShell(session, command, true);
                session = null;
                System.out.println("结果:"+result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

src/main/java/com/yihu/hos/broker/services/camel/CamelCompiler.java

@@ -0,0 +1,58 @@
package com.yihu.hos.broker.services.camel;
import com.yihu.hos.core.log.Logger;
import com.yihu.hos.core.log.LoggerFactory;
import javax.tools.*;
import java.io.File;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;
/**
 * java编译工具类
 *
 * @author HZY
 * @vsrsion 1.0
 * Created at 2016/11/17.
 */
public class CamelCompiler {
    private static final Logger logger = LoggerFactory.getLogger(CamelCompiler.class);
    public static boolean compile(String sourcePath, String targetPath) {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        boolean success = false;
        try {
            // 建立DiagnosticCollector对象
            DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
            StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, Charset.forName("UTF-8"));
            // 建立源文件对象，根据java模板文件生成要加载的java类
            Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(sourcePath);
            String classPath = CamelCompiler.class.getResource("/").getPath();
            String libPath = new File(classPath).getParent() + File.separator + "lib";//指定需要导入的包路径
            Iterable<String> options = Arrays.asList("-d", targetPath, "-sourcepath", targetPath, "-extdirs", libPath);// 指定的路径一定要存在，javac不会自己创建文件夹
            JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, options, null, compilationUnits);
            // 编译源程序
            success = task.call();
            fileManager.close();
            if (!success) {
                //错误信息打印
                List diagnosticList = diagnostics.getDiagnostics();
                System.out.println("编译失败：lib包路径："+libPath);
                for (Object aDiagnosticList : diagnosticList) {
                    logger.error(aDiagnosticList.toString());
                }
            } else {
                System.out.println("编译成功" + sourcePath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return success;
    }
}

src/main/java/com/yihu/hos/broker/services/camel/CamelStartBoot.java

@@ -0,0 +1,132 @@
package com.yihu.hos.broker.services.camel;
import com.yihu.hos.broker.common.log.TracerFormatter;
import com.yihu.hos.broker.services.BrokerServerService;
import com.yihu.hos.broker.util.lang.DynamicClassLoader;
import com.yihu.hos.core.log.Logger;
import com.yihu.hos.core.log.LoggerFactory;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.processor.interceptor.DefaultTraceFormatter;
import org.apache.camel.processor.interceptor.Tracer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.stereotype.Component;
import java.util.concurrent.SynchronousQueue;
/**
 * @author Airhead
 * @since 2016/12/9.
 */
@Component
public class CamelStartBoot {
    private static Logger logger = LoggerFactory.getLogger(CamelStartBoot.class);
    private BrokerServerService brokerServerService;
    private CamelContext context = SystemCamelContext.getContext();
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    @Autowired
    public void setBrokerServerService(BrokerServerService brokerServerService) {
        this.brokerServerService = brokerServerService;
    }
    public void start() {
        logger.info("Apache Camel Context 启动...");
        try {
            context.setStreamCaching(true); //确保outBody可以消费多次。参考链接：http://camel.apache.org/why-is-my-message-body-empty.html
            context.setUseMDCLogging(true);
            Tracer tracer = new Tracer();
            tracer.setTraceOutExchanges(true);
            DefaultTraceFormatter formatter = new TracerFormatter();
            formatter.setShowHeaders(true);
            formatter.setShowBody(true);
            formatter.setShowBodyType(true);
            formatter.setShowOutHeaders(true);
            formatter.setShowOutBody(true);
            formatter.setShowOutBodyType(true);
            tracer.setFormatter(formatter);
            context.addInterceptStrategy(tracer);
            context.setTracing(true);
            context.getGlobalOptions().put(Exchange.LOG_DEBUG_BODY_STREAMS, "true");
            context.start();
            logger.info("Apache Camel Context 启动完成...");
            brokerServerService.login();
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("Apache Camel Context 启动失败。");
        }
    }
    /**
     * serveProcessor 创建Processor实例
     */
    public void serveProcessor() {
        try {
            SynchronousQueue<String> processorQueue = SystemCamelContext.getProcessorQueue();
            String className;
            while ((className = processorQueue.take()) != null) {
                try {
                    DynamicClassLoader dynamicClassLoader = new DynamicClassLoader(SystemCamelContext.getResource(this).getPath());
                    Class<?> processorClass = dynamicClassLoader.loadClass(className);
                    if (processorClass != null) {
                        Object o = processorClass.newInstance();
                        capableBeanFactory.autowireBean(o);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    logger.error("serveProcessor----加载数据Class异常11。。");
                }
                logger.info(className);
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("serveProcessor----加载数据Class异常11。。");
        }
    }
    /**
     * serveRouter 创建Router实例
     */
    public void serveRouter() {
        try {
            SynchronousQueue<String> routerQueue = SystemCamelContext.getRouterQueue();
            String className;
            while ((className = routerQueue.take()) != null) {
                try {
                    DynamicClassLoader dynamicClassLoader = new DynamicClassLoader(SystemCamelContext.getResource(this).getPath());
                    Class<RouteBuilder> routeBuilderClass = (Class<RouteBuilder>) dynamicClassLoader.loadClass(className);
                    if (routeBuilderClass != null) {
                        RouteBuilder routeBuilder = routeBuilderClass.newInstance();
                        capableBeanFactory.autowireBean(routeBuilder);
                        context.addRoutes(routeBuilder);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    logger.error("serveRouter----加载数据Class异常11。");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("serveRouter----加载数据Class异常22。");
        }
    }
    public void shutdown() {
        brokerServerService.logout();
    }
}

src/main/java/com/yihu/hos/broker/services/camel/ESBCamelService.java

@@ -0,0 +1,485 @@
package com.yihu.hos.broker.services.camel;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.yihu.hos.core.constants.CoreConstant;
import com.yihu.hos.core.datatype.ClassFileUtil;
import com.yihu.hos.core.datatype.StringUtil;
import com.yihu.hos.web.framework.constant.ServiceFlowConstant;
import com.yihu.hos.web.framework.model.Result;
import com.yihu.hos.web.framework.model.bo.ServiceFlow;
import org.apache.camel.Route;
import org.apache.camel.ServiceStatus;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.bson.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
/**
 * 对于Broker来说，Camel路由的加载只有这样的几个过程。
 * 文件相关
 * 1.Java， Class文件下载
 * 2.Java文件编译
 * 3.Class文件上传（有java编译生成的class的文件更新）
 * 4.Java，Class删除文件
 * Camel相关
 * 1.增加服务流程
 * 2.删除服务流程
 * 3.修改服务流程
 * 3.1增加Router，Processor
 * 3.2减少Router，Processor
 * 4.启动服务流程
 * 5.停止服务流程
 * <p>
 * Created by lingfeng on 2016/8/4.
 */
@RefreshScope
@Service
public class ESBCamelService {
    private static Logger logger = LogManager.getLogger(ESBCamelService.class);
    @Autowired
    private MongoClient mongoClient;
    private String serviceFlow = "serviceFlow";
    private String configuration = "runtime";
    @Autowired
    private ObjectMapper objectMapper;
    @Value("${hos.filesystem.url}")
    private String fsUrl;
    @Value("${spring.data.mongodb.gridFsDatabase}")
    private String dbName;
    public Result onServiceFlowAdd(String msg) {
        try {
            System.out.println("hos-broker 流程添加开始，onServiceFlowModifyAdd");
            ServiceFlowValid serviceFlowValid = new ServiceFlowValid(msg).invoke();
            if (serviceFlowValid.is()) return Result.error("必要的入参数据不正确，请检查！");
            ServiceFlow serviceFlow = serviceFlowValid.getServiceFlow();
            ArrayList<ServiceFlow.HandleFile> handleFiles = serviceFlowValid.getHandleFiles();
            if ("java".equals(serviceFlowValid.getServiceFlow().getFlowType())) {
                final boolean[] created = new boolean[1];
                //先生成和编译 processor
                handleFiles.stream().filter(handleFile -> ServiceFlowConstant.FLOW_TYPE_PROCESSOR.equals(handleFile.getUsage())).forEach(handleFile -> {
                    try {
                        if (this.generateClassFile(handleFile)){
                            created[0] = true;
                        } else {
                            created[0] = false;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                if (!created[0]) {
                    System.out.println("onServiceFlowAdd ,生成processor文件失败，");
                    return Result.error("服务流程启动失败！");
                }
                handleFiles.stream().filter(handleFile -> ServiceFlowConstant.FLOW_TYPE_ROUTE.equals(handleFile.getUsage())).forEach(handleFile -> {
                    try {
                        if (this.generateClassFile(handleFile)) created[0] = true;
                        else created[0] = false;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                if (!created[0]) {
                    System.out.println("onServiceFlowAdd ,生成route文件失败，");
                    return Result.error("服务流程启动失败！");
                }
            } else {
                for (ServiceFlow.HandleFile handleFile : handleFiles) {
                    boolean created = this.createClassFile(handleFile);
                    if (!created) {
                        return Result.error("服务流程启动失败！");
                    }
                }
            }
            logger.debug("add camel router" + serviceFlow.getRouteCode());
            this.addRouter(serviceFlow.getHandleFiles());
            logger.debug("start camel router," + serviceFlow.getRouteCode());
            SystemCamelContext.startRouter(serviceFlow.getRouteCode());
            logger.debug("start camel router success," + serviceFlow.getRouteCode());
            return Result.error("服务流程增加成功！");
        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e);
            return Result.error("服务流程增加失败！");
        }
    }
    /**
     * 当外界组件通知一个新的processor处理器被定义时，该事件被触发。
     */
    public Result onServiceFlowModifyAdd(String msg) {
        try {
            System.out.println("hos-broker 流程修改开始，onServiceFlowModifyAdd");
            ServiceFlowValid serviceFlowValid = new ServiceFlowValid(msg).invoke();
            if (serviceFlowValid.is()) return Result.error("必要的入参数据不正确，请检查！");
            List<Route> routes = SystemCamelContext.getContext().getRoutes();
            ServiceFlow serviceFlow = serviceFlowValid.getServiceFlow();
            SystemCamelContext.stopRouter(serviceFlow.getRouteCode());
            boolean b = SystemCamelContext.removeRouter(serviceFlow.getRouteCode());
            ArrayList<ServiceFlow.HandleFile> handleFiles = serviceFlowValid.getHandleFiles();
            if ("java".equals(serviceFlowValid.getServiceFlow().getFlowType())) {
                final boolean[] created = new boolean[1];
                //先生成和编译 processor
                handleFiles.stream().filter(handleFile -> ServiceFlowConstant.FLOW_TYPE_PROCESSOR.equals(handleFile.getUsage())).forEach(handleFile -> {
                    try {
                        if (this.generateClassFile(handleFile)) created[0] = true;
                        else created[0] = false;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                if (!created[0]) {
                    return Result.error("服务流程启动失败！");
                }
                handleFiles.stream().filter(handleFile -> ServiceFlowConstant.FLOW_TYPE_ROUTE.equals(handleFile.getUsage())).forEach(handleFile -> {
                    try {
                        if (this.generateClassFile(handleFile)) created[0] = true;
                        else created[0] = false;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                if (!created[0]) {
                    return Result.error("服务流程启动失败！");
                }
            } else {
                for (ServiceFlow.HandleFile handleFile : handleFiles) {
                    boolean created = this.createClassFile(handleFile);
                    if (!created) {
                        return Result.error("服务流程启动失败！");
                    }
                }
            }
            this.addRouter(serviceFlowValid.getHandleFiles());
            SystemCamelContext.startRouter(serviceFlow.getRouteCode());
            System.out.println("hos-broker 流程修改结束，onServiceFlowModifyAdd");
            return Result.error("服务流程变更增加成功！");
        } catch (Exception e) {
            e.printStackTrace();
//            logger.error(e);
            return Result.error("服务流程变更增加失败！");
        }
    }
    /**
     * 当外界组件通知一个已有的RouteDefine路由定义被删除时，该事件被触发。
     */
    public Result onServiceFlowModifyReduce(String msg) {
        try {
            ServiceFlowValid serviceFlowValid = new ServiceFlowValid(msg).invoke();
            if (serviceFlowValid.is()) return Result.error("必要的入参数据不正确，请检查！");
            ServiceFlow serviceFlow = serviceFlowValid.getServiceFlow();
            ServiceFlow.HandleFile handleFile = serviceFlowValid.getHandleFile();
            String routeCode = serviceFlow.getRouteCode();
            SystemCamelContext.getContext().stopRoute(routeCode);
            SystemCamelContext.getContext().removeRoute(routeCode);
            this.deleteClassFile(handleFile);
            this.addRouter(serviceFlowValid.getHandleFiles());
            SystemCamelContext.startRouter(serviceFlow.getRouteCode());
            return Result.success("服务流程变更减少成功！");
        } catch (Exception e) {
            return Result.error("服务流程变更减少失败！");
        }
    }
    public Result onServiceFlowDelete(String msg) {
        try {
            ServiceFlowValid serviceFlowValid = new ServiceFlowValid(msg).invoke();
            if (serviceFlowValid.is()) return Result.error("必要的入参数据不正确，请检查！");
            ServiceFlow serviceFlow = serviceFlowValid.getServiceFlow();
            String routeCode = serviceFlow.getRouteCode();
            SystemCamelContext.getContext().stopRoute(routeCode);
            boolean b = SystemCamelContext.getContext().removeRoute(routeCode);
            ArrayList<ServiceFlow.HandleFile> handleFiles = serviceFlowValid.getHandleFiles();
            if (handleFiles != null) {
                for (ServiceFlow.HandleFile handleFile : handleFiles) {
                    this.deleteClassFile(handleFile);
                    this.deleteServiceFlow(handleFile.getRouteCode());//删除mongo中serviceFlow信息
                }
            }
            return Result.success("服务流程删除成功！");
        } catch (Exception e) {
            return Result.error("服务流程删除失败！");
        }
    }
    /**
     * 启动路由时，该事件被触发。
     */
    public Result onServiceFlowStart(String msg) {
        try {
            ServiceFlowValid serviceFlowValid = new ServiceFlowValid(msg).invoke();
            if (serviceFlowValid.is()) return Result.error("必要的入参数据不正确，请检查！");
            ServiceFlow serviceFlow = serviceFlowValid.getServiceFlow();
            ArrayList<ServiceFlow.HandleFile> handleFiles = serviceFlowValid.getHandleFiles();
            if ("java".equals(serviceFlowValid.getServiceFlow().getFlowType())) {
                final boolean[] created = new boolean[1];
                //先生成和编译 processor
                handleFiles.stream().filter(handleFile -> ServiceFlowConstant.FLOW_TYPE_PROCESSOR.equals(handleFile.getUsage())).forEach(handleFile -> {
                    try {
                        if (this.generateClassFile(handleFile)) created[0] = true;
                        else created[0] = false;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                if (!created[0]) {
                    System.out.println("processor 生成失败！");
                    return Result.error("服务流程启动失败！");
                } else {
                    System.out.println("processor 生成成功！");
                }
                handleFiles.stream().filter(handleFile -> ServiceFlowConstant.FLOW_TYPE_ROUTE.equals(handleFile.getUsage())).forEach(handleFile -> {
                    try {
                        if (this.generateClassFile(handleFile)) created[0] = true;
                        else created[0] = false;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                if (!created[0]) {
                    System.out.println("route文件 生成失败！");
                    return Result.error("服务流程启动失败！");
                } else {
                    System.out.println("route文件 生成成功！");
                }
            } else {
                for (ServiceFlow.HandleFile handleFile : handleFiles) {
                    boolean created = this.createClassFile(handleFile);
                    if (!created) {
                        return Result.error("服务流程启动失败！");
                    }
                }
            }
            this.addRouter(handleFiles);
            SystemCamelContext.startRouter(serviceFlow.getRouteCode());
            List<Route> routes = SystemCamelContext.getContext().getRoutes();
            return Result.success("服务流程启动成功！");
        } catch (Exception e) {
            logger.error(e.getMessage());
            return Result.error("服务流程启动失败！");
        }
    }
    /**
     * 停止路由时，该事件被触发。
     */
    public Result onServiceFlowStop(String msg) {
        try {
            ServiceFlowValid serviceFlowValid = new ServiceFlowValid(msg).invoke();
            if (serviceFlowValid.is()) return Result.error("必要的入参数据不正确，请检查！");
            ServiceFlow serviceFlow = serviceFlowValid.getServiceFlow();
            String routeCode = serviceFlow.getRouteCode();
            SystemCamelContext.getContext().stopRoute(routeCode);
            return Result.success("停止路由成功！");
        } catch (Exception e) {
            return Result.error("停止路由失败！");
        }
    }
    private boolean createClassFile(ServiceFlow.HandleFile handleFile) throws Exception {
        if (handleFile == null) {
            return false;
        }
        SystemCamelContext.putClassMapping(handleFile.getRouteCode(), handleFile.getPackageName(), handleFile.getUsage(), handleFile.getClassName());
        URL resource = SystemCamelContext.getResource(this);
        FileOutputStream outputStream = ClassFileUtil.createFile(resource, handleFile.getPackageName(), handleFile.getClassName(), ClassFileUtil.CLASS_FILE);
        String fileName = handleFile.getClassName() + ClassFileUtil.CLASS_FILE;
        //从中心下载
        String downUrl = fsUrl + "/" + handleFile.getFilePath();
        String sourcePath = ClassFileUtil.downFile(downUrl, resource, handleFile.getPackageName(), handleFile.getClassName(), ClassFileUtil.CLASS_FILE);
        if (sourcePath == null) {
            logger.error("not mongo file, fileName:" + fileName);
            return false;
        }
        return true;
    }
    private boolean generateClassFile(ServiceFlow.HandleFile handleFile) throws Exception {
        if (handleFile == null) {
            System.out.println("=====handleFile is null...");
            return false;
        }
        SystemCamelContext.putClassMapping(handleFile.getRouteCode(), handleFile.getPackageName(), handleFile.getUsage(), handleFile.getClassName());
        URL resource = SystemCamelContext.getResource(this);
        //从中心下载java文件
        String downUrl = fsUrl + "/" + handleFile.getFilePath();
        String sourcePath = ClassFileUtil.downFile(downUrl, resource, handleFile.getPackageName(), handleFile.getClassName(), ClassFileUtil.JAVA_FILE);
        if (sourcePath == null) {
            System.out.println("下载java文件失败，downUrl：" + downUrl);
            return false;
        }
        logger.info(sourcePath);
        boolean succ = CamelCompiler.compile(sourcePath, resource.getPath());
        if (succ) {
            //编译成功后将class文件上传至mongodb；文件名为类名+ routeCode
//            String packagePath = StringUtil.replaceStrAll(handleFile.getPackageName(), ".", "/");
//            String classPath = this.getClass().getResource("/").getPath() + packagePath + "/" + handleFile.getClassName() + ClassFileUtil.CLASS_FILE;
//
//            //上传文件
//            String fileName = handleFile.getClassName() + ClassFileUtil.CLASS_FILE;
//            ClassFileUtil.upload(fsUrl, classPath);
        } else {
            System.out.println("编译失败，sourcePath：" + sourcePath);
        }
        return succ;
    }
    private void deleteClassFile(ServiceFlow.HandleFile handleFile) {
        try {
            String packagePath = StringUtil.replaceStrAll(handleFile.getPackageName(), ".", "/");
            String classPath = this.getClass().getResource("/").getPath() + "/" + packagePath + "/" + handleFile.getClassName() + ".class";
            String javaPath = this.getClass().getResource("/").getPath() + "/" + packagePath + "/" + handleFile.getClassName() + ".java";
            Boolean aBoolean = ClassFileUtil.deleteClassfile(javaPath);
            Boolean bBoolean = ClassFileUtil.deleteClassfile(classPath);
            //删除mongodb中文件
            String delJavaUrl = fsUrl + "/" + handleFile.getFilePath();
            ClassFileUtil.deleteFile(delJavaUrl);
            // 完成
            logger.info("===================" + handleFile.getPackageName() + CoreConstant.DOT + handleFile.getClassName() + ".class 删除过程结束");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 删除 serviceFlow记录
     *
     * @param routeCode
     */
    private void deleteServiceFlow(String routeCode) {
        try {
            MongoDatabase db = mongoClient.getDatabase(configuration);
            MongoCollection<Document> collection = db.getCollection(serviceFlow);
            collection.deleteMany(Filters.eq("routeCode", routeCode));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void addRouter(ArrayList<ServiceFlow.HandleFile> handleFiles) throws Exception {
        ArrayList<ServiceFlow.HandleFile> routerFiles = new ArrayList<>();
        handleFiles.forEach(handleFile -> {
            try {
                if (handleFile.getUsage().equals(ServiceFlowConstant.FLOW_TYPE_ROUTE)){
                    String className = SystemCamelContext.getClassMapping(handleFile.getRouteCode(), handleFile.getClassName(), handleFile.getUsage());
                    SystemCamelContext.getRouterQueue().put(className);
                } else {
                    String className = SystemCamelContext.getClassMapping(handleFile.getRouteCode(), handleFile.getClassName(), handleFile.getUsage());
                    SystemCamelContext.getProcessorQueue().put(className);
                }
            } catch (Exception e) {
                logger.error(e.getMessage());
                e.printStackTrace();
            }
        });
    }
    public String getRouteStatus(String routeId){
        ServiceStatus routeStatus = SystemCamelContext.getContext().getRouteStatus(routeId);
        if (routeStatus!=null){
            return routeStatus.name();
        }else {
            return null;
        }
    }
    private class ServiceFlowValid {
        private boolean myResult;
        private String msg;
        private ServiceFlow serviceFlow;
        private ServiceFlow.HandleFile handleFile;
        private ArrayList<ServiceFlow.HandleFile> handleFiles;
        public ServiceFlowValid(String msg) {
            this.msg = msg;
        }
        public ArrayList<ServiceFlow.HandleFile> getHandleFiles() {
            return handleFiles;
        }
        public ServiceFlow getServiceFlow() {
            return serviceFlow;
        }
        public ServiceFlow.HandleFile getHandleFile() {
            return handleFile;
        }
        public ServiceFlowValid invoke() throws IOException {
            serviceFlow = objectMapper.readValue(msg, ServiceFlow.class);
            handleFiles = serviceFlow.getHandleFiles();
            if (handleFiles == null || handleFiles.size() == 0) {
                logger.error("必要的入参数据不正确，请检查！");
                myResult = true;
                return this;
            }
            handleFile = handleFiles.get(0);
            if (handleFile == null || StringUtil.isEmpty(serviceFlow.getRouteCode()) || StringUtil.isEmpty(handleFile.getPackageName())
                    || StringUtil.isEmpty(handleFile.getPackageName()) || StringUtil.isEmpty(handleFile.getFilePath())) {
                logger.error("必要的入参数据不正确，请检查！");
                myResult = true;
                return this;
            }
            myResult = false;
            return this;
        }
        boolean is() {
            return myResult;
        }
    }
}

src/main/java/com/yihu/hos/broker/services/camel/SystemCamelContext.java

@@ -0,0 +1,63 @@
package com.yihu.hos.broker.services.camel;
import com.yihu.hos.core.constants.CoreConstant;
import org.apache.camel.CamelContext;
import org.apache.camel.impl.DefaultCamelContext;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.SynchronousQueue;
/**
 * Created by lingfeng on 2016/8/9.
 */
public class SystemCamelContext {
    private static CamelContext context;
    private static SynchronousQueue<String> routerQueue = new SynchronousQueue<>();
    private static SynchronousQueue<String> processorQueue = new SynchronousQueue<>();
    private static Map<String, String> mapping = new HashMap<>();
    public static Map<String, String> getMapping() {
        return mapping;
    }
    public static void putClassMapping(String routeCode, String packageName, String type, String className) {
        mapping.put(routeCode + "|" + type + "|" + className, packageName + CoreConstant.DOT + className);
    }
    public static String getClassMapping(String routeCode, String className, String type) {
        return mapping.get(routeCode + "|" + type + "|" + className);
    }
    public static URL getResource(Object o) {
        return o.getClass().getProtectionDomain().getClassLoader().getResource("");
    }
    public static CamelContext getContext() {
        if (context == null) {
            context = new DefaultCamelContext();
        }
        return context;
    }
    public static SynchronousQueue<String> getRouterQueue() {
        return routerQueue;
    }
    public static SynchronousQueue<String> getProcessorQueue() {
        return processorQueue;
    }
    public static void startRouter(String routeCode) throws Exception {
        getContext().startRoute(routeCode);
    }
    public static void stopRouter(String routeCode) throws Exception {
        getContext().stopRoute(routeCode);
    }
    public static boolean removeRouter(String routeCode) throws Exception {
        return getContext().removeRoute(routeCode);
    }
}

src/main/java/com/yihu/hos/broker/util/Cols.java

@@ -0,0 +1,133 @@
package com.yihu.hos.broker.util;
import com.yihu.hos.broker.util.funct.F0;
import com.yihu.hos.broker.util.funct.F1;
import java.util.*;
/**
 * Created by QuanLA
 * Date: Mar 2, 2006
 * Time: 9:10:49 AM
 */
@SuppressWarnings({"rawtypes","unchecked"})
public class Cols {
	/**
	 * If a collection is empty
	 * @param objs
	 * @return
	 */
	public static boolean isEmpty(Collection<?> objs) {
		return objs == null || objs.isEmpty();
	}
	/**
	 * If a collection is not empty
	 * @param col
	 * @return
	 */
    public static boolean isNotEmpty(Collection<?> col) {
        return !isEmpty(col);
    }
	
    /**
     * Get single element, or null if Col is empty
     * @param collection
     * @return
     */
    public static <A> A getSingle(
            Collection<A> collection) {
    	if (collection == null) {
    		return null;
    	}
        for (A a : collection) {
            return a;
        }
        return null;
    }
	
    public static <A> List<A> createList(int size, F0<A> f) {
        ArrayList<A> list = new ArrayList<A>(size);
        for (int i = 0; i < size; i++) {
            list.add(f.e());
        }
        return list;
    }
	
    /**
     * Create a string connecting all values in collection, separated with delimiter
     * @param objs
     * @param delimiter
     * @return
     */
	public static <A> String join(Iterable<A> objs, String delimiter) {
        if (objs == null) {
            return "";
        }
		StringBuilder sb = new StringBuilder();
		for (A a : objs) {
			sb.append(a).append(delimiter);
		}
		if (sb.length() > 0) {
			sb.setLength(sb.length() - delimiter.length());
		}
		return sb.toString();
	}
	
	
	public static <A,T> List<T> yield(List<A> col, F1<A, T> f1) {
        if (col!=null) {
            return yield(col, new ArrayList<T>(col.size()), f1);
        } else {
            return null;
        }
    }
	
	/**
	 * Apply function on every elements to get new collection of returned value
	 * @param <A>
	 * @param <T>
	 * @param <C>
	 * @param inputs
	 * @param col
	 * @param f1
	 * @return
	 */
	public static <A,T,C extends Collection<T>> C yield(Iterable<A> inputs, C col, F1<A, T> f1) {
//		ArrayList<T> list = new ArrayList<T>();
		if (inputs!=null) {
            for (A a : inputs) {
                T e = f1.e(a);
				if (e != null) {
					col.add(e);
				}
            }
		}
		return col;
	}
	/**
     * Create a map based on the Object... param. Each 2 values is an entry
     * which is a pair of key then value
     * @param objects The params that will be converted to map.
     * 					Format: [key1, value1, key2, value2]
     * @return The map after converted from param objects
     */
//    @SuppressWarnings({"unchecked"})
    public static <A, B> Map<A, B> map(Object... objects) {
    	if (objects==null) {
    		return null;
    	}
        Map<A, B> map = new LinkedHashMap<A, B>(objects.length / 2);
        for (int i = 0; i < objects.length; i+=2) {
            map.put((A)objects[i], (B)objects[i + 1]);
        }
        return map;
    }
}

src/main/java/com/yihu/hos/broker/util/FileUtil.java

@@ -0,0 +1,89 @@
package com.yihu.hos.broker.util;
import com.yihu.hos.broker.util.funct.F1;
import com.yihu.hos.broker.util.funct.F2;
import com.yihu.hos.broker.util.funct.Fs;
import com.yihu.hos.broker.util.funct.P2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
@SuppressWarnings("UnusedDeclaration")
public class FileUtil {
	/**
	 * 
	 * @param fileToRead
	 * @return
	 * @throws IOException
	 */
	public static byte[] readFileToBytes(File fileToRead) {
		try {
			return IOUtil.readData(new FileInputStream(fileToRead));
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
    public static FileInputStream fileInputStream(File file) {
        try {
            return new FileInputStream(file);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
    public static FileInputStream fileInputStream(String file) {
        try {
            return new FileInputStream(file);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
	
    public static void eachFile(File path, P2<File, String> f) {
        eachFile(path, f, null);
    }
	
    public static void eachFile(File path, P2<File, String> f, F1<File, Boolean> exclude) {
    	eachFile(path, Fs.f2(f, true), exclude);
    }
	
    public static void eachFile(File path, F2<File, String,Boolean> f, F1<File, Boolean> exclude) {
        ArrayList<String> relPath = new ArrayList<>();
        if (path.isFile()) {
            f.e(path, Cols.join(relPath, File.separator));
        } else {
            if (!eachFileInDir(path, f, relPath, exclude)) return;
        }
    }
	
    private static boolean eachFileInDir(File path, F2<File, String,Boolean> f, ArrayList<String> relPath, F1<File, Boolean> exclude) {
        if (!path.exists() || !path.isDirectory()) {
            throw new RuntimeException("Invalid path: " + path);
        }
        for (File child : path.listFiles()) {
            if (exclude != null && exclude.e(child)) {
//            	System.out.println("Excluded " + child);
                continue;
            }
//        	System.out.println("Accepted " + child);
            if (child.isFile()) {
                if (!f.e(child, Cols.join(relPath, File.separator))) return false;
            } else {
                relPath.add(child.getName());
                if (!eachFileInDir(child, f, relPath, exclude)) return false;
                relPath.remove(relPath.size() - 1);
            }
        }
        return true;
    }
}

src/main/java/com/yihu/hos/broker/util/IOUtil.java

@@ -0,0 +1,188 @@
package com.yihu.hos.broker.util;
import java.io.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * Created by Quan on 22/12/2014.
 */
public class IOUtil {
	
	/**
	 * Read the stream into byte array
	 * @param inputStream
	 * @return
	 * @throws IOException
	 */
    public static byte[] readData(InputStream inputStream) {
        try {
			return readDataNice(inputStream);
		} finally {
        	close(inputStream);
		}
    }
    public static byte[] readDataNice(InputStream inputStream) {
		ByteArrayOutputStream boTemp = null;
        byte[] buffer = null;
        try {
            int read;
			buffer = new byte[8192];
            boTemp = new ByteArrayOutputStream();
            while ((read=inputStream.read(buffer, 0, 8192)) > -1) {
                boTemp.write(buffer, 0, read);
            }
            return boTemp.toByteArray();
        } catch (IOException e) {
			throw new RuntimeException(e);
        }
	}
	
	
    /**
     * Close streams (in or out)
     * @param stream
     */
    public static void close(Closeable stream) {
        if (stream != null) {
            try {
                if (stream instanceof Flushable) {
                    ((Flushable)stream).flush();
                }
                stream.close();
            } catch (IOException e) {
                // When the stream is closed or interupted, can ignore this exception
            }
        }
    }
	public static void close(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                // When the conn is closed or interupted, can ignore this exception
			}
        }
		
	}
    public static void close(ResultSet rs) {
    	if (rs != null) {
    		try {
    			rs.close();
    		} catch (SQLException e) {
    			// When the file is closed already, can ignore this exception
    		}
    	}
    }
    public static void close(PreparedStatement ps) {
    	if (ps != null) {
    		try {
    			ps.close();
    		} catch (SQLException e) {
    			// When the file is closed already, can ignore this exception
    		}
    	}
    }
	
	/**
	 * Will close stream
	 * @param in
	 * @param charSet
	 * @return
	 */
	public static String toString(InputStream in, String charSet) {
		return inputStreamToString_force(in, charSet);
	}
	
	/**
	 * Will close stream
	 * @param in
	 * @param charSet
	 * @return
	 */
	public static String inputStreamToString_force(InputStream in, String charSet) {
		try {
			return inputStreamToString(in, charSet);
		} catch (IOException e) {
			return null;
		}
	}
    /**
     * Reads in whole input stream and returns as a string<br>
     * Will close stream
     * @param in The input stream to read in, will be closed 
     * 				by this method at finish
     * @param charSet charset to convert the input bytes into string
     * @return the result string
     * @throws IOException
     */
	public static String inputStreamToString(InputStream in, String charSet) throws IOException {
		InputStreamReader inputStreamReader = null;
		try {
			inputStreamReader = charSet == null? new InputStreamReader(in) : new InputStreamReader(in, charSet);
			return toString(inputStreamReader);
		} catch (UnsupportedEncodingException e1) {
			throw new RuntimeException(e1);
		} finally {
			close(in);
		}
	}
	
    /**
     * Reads in whole input stream and returns as a string
     * @param reader The input reader to read in, will be closed 
     * 				by this method at finish
     * @return the result string
     * @throws IOException
     */
	public static String toString(Reader reader) {
		try {
			StringBuilder sb = new StringBuilder();
			char[] buffer = new char[4096];
			for (int read; (read = reader.read(buffer)) > -1;) {
				sb.append(buffer, 0, read);
			}
			return sb.toString();
		} catch (IOException e) {
			throw new RuntimeException(e);
		} finally {
			close(reader);
		}
	}
	/**
	 * Read the input stream and write to output stream
	 * @param inputStream
	 * @param out
	 * @return
	 * @throws IOException
	 */
    public static long connect(InputStream inputStream, OutputStream out) throws IOException {
        try {
            return dump(inputStream, out);
        } finally {
            close(inputStream);
        }
    }
    
    private static long dump(InputStream inputStream, OutputStream out) throws IOException {
        long total = 0;
        int read;
        int bufferSize = 8192;
        byte[] buffer = new byte[bufferSize];
        while ((read=inputStream.read(buffer, 0, bufferSize)) > -1) {
            out.write(buffer, 0, read);
            total+=read;
        }
        out.flush();
        return total;
    }
}

src/main/java/com/yihu/hos/broker/util/SigarUtil.java

@@ -0,0 +1,407 @@
    package com.yihu.hos.broker.util;
    import com.yihu.hos.core.log.Logger;
    import com.yihu.hos.core.log.LoggerFactory;
    import org.hyperic.sigar.*;
    import java.net.InetAddress;
    import java.net.URL;
    import java.net.UnknownHostException;
    import java.util.*;
    /**
     * sigar 服务器硬件指标 工具类
     *
     * @author HZY
     * @vsrsion 1.0
     * Created at 2016/10/10.
     */
    public class SigarUtil {
        static private final Logger logger = LoggerFactory.getLogger(SigarUtil.class);
        public final static Sigar sigar = initSigar();
        private static Sigar initSigar() {
            try {
                //此处只为得到依赖库文件的目录，可根据实际项目自定义
                String sigarLibPath = SigarUtil.class.getProtectionDomain().getCodeSource().getLocation().getPath() ;
                String path = System.getProperty("java.library.path");
                //为防止java.library.path重复加，此处判断了一下
                if (!path.contains(sigarLibPath)) {
                    if (isOSWin()) {
                        path += ";" + sigarLibPath;
                    } else {
                        path += ":" + sigarLibPath;
                    }
                    System.setProperty("java.library.path", path);
                }
                return new Sigar();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        public URL getUrl() {
            return this.getClass().getResource("/");
        }
    //    public static void main(String[] args) {
    //        DecimalFormat df = new DecimalFormat("#0.00");
    //        double d = 0;
    //        String f = df.format(d);
    //        double e = Double.parseDouble(String.format("%.2f", d));
    //        logger.info(e);
    //    }
        /**
         * 是否是windows系统
         *
         * @return
         */
        public static boolean isOSWin() {//OS 版本判断
            String OS = System.getProperty("os.name").toLowerCase();
            if (OS.indexOf("win") >= 0) {
                return true;
            } else return false;
        }
        /* ==================================================   以下是打印测试   ========================================================================== */
        /**
         * 系统信息  jvm等
         *
         * @throws UnknownHostException
         */
        public static String getHostName(){
            try {
                NetInfo netInfo = sigar.getNetInfo();
                String hostName = netInfo.getHostName();
                return hostName;
            } catch (SigarException e) {
                e.printStackTrace();
            }
            return "";
        }
        public static String getHost(){
            try {
                NetInterfaceConfig netInterfaceConfig = sigar.getNetInterfaceConfig(null);
                String ip = netInterfaceConfig.getAddress();
                return ip;
            } catch (SigarException e) {
                e.printStackTrace();
            }
            return "unknowHost";
        }
        private static void property() throws UnknownHostException {
            Runtime r = Runtime.getRuntime();
            Properties props = System.getProperties();
            InetAddress addr;
            addr = InetAddress.getLocalHost();
            String ip = addr.getHostAddress();
            Map<String, String> map = System.getenv();
            String userName = map.get("USERNAME");// 获取用户名
            String computerName = map.get("COMPUTERNAME");// 获取计算机名
            String userDomain = map.get("USERDOMAIN");// 获取计算机域名
            logger.info("用户名:    " + userName);
            logger.info("计算机名:    " + computerName);
            logger.info("计算机域名:    " + userDomain);
            logger.info("本地ip地址:    " + ip);
            logger.info("本地主机名:    " + addr.getHostName());
            logger.info("JVM可以使用的总内存:    " + r.totalMemory());
            logger.info("JVM可以使用的剩余内存:    " + r.freeMemory());
            logger.info("JVM可以使用的处理器个数:    " + r.availableProcessors());
            logger.info("Java的运行环境版本：    " + props.getProperty("java.version"));
            logger.info("Java的运行环境供应商：    " + props.getProperty("java.vendor"));
            logger.info("Java供应商的URL：    " + props.getProperty("java.vendor.url"));
            logger.info("Java的安装路径：    " + props.getProperty("java.home"));
            logger.info("Java的虚拟机规范版本：    " + props.getProperty("java.vm.specification.version"));
            logger.info("Java的虚拟机规范供应商：    " + props.getProperty("java.vm.specification.vendor"));
            logger.info("Java的虚拟机规范名称：    " + props.getProperty("java.vm.specification.name"));
            logger.info("Java的虚拟机实现版本：    " + props.getProperty("java.vm.version"));
            logger.info("Java的虚拟机实现供应商：    " + props.getProperty("java.vm.vendor"));
            logger.info("Java的虚拟机实现名称：    " + props.getProperty("java.vm.name"));
            logger.info("Java运行时环境规范版本：    " + props.getProperty("java.specification.version"));
            logger.info("Java运行时环境规范供应商：    " + props.getProperty("java.specification.vender"));
            logger.info("Java运行时环境规范名称：    " + props.getProperty("java.specification.name"));
            logger.info("Java的类格式版本号：    " + props.getProperty("java.class.version"));
            logger.info("Java的类路径：    " + props.getProperty("java.class.path"));
            logger.info("加载库时搜索的路径列表：    " + props.getProperty("java.library.path"));
            logger.info("默认的临时文件路径：    " + props.getProperty("java.io.tmpdir"));
            logger.info("一个或多个扩展目录的路径：    " + props.getProperty("java.ext.dirs"));
            logger.info("操作系统的名称：    " + props.getProperty("os.name"));
            logger.info("操作系统的构架：    " + props.getProperty("os.arch"));
            logger.info("操作系统的版本：    " + props.getProperty("os.version"));
            logger.info("文件分隔符：    " + props.getProperty("file.separator"));
            logger.info("路径分隔符：    " + props.getProperty("path.separator"));
            logger.info("行分隔符：    " + props.getProperty("line.separator"));
            logger.info("用户的账户名称：    " + props.getProperty("user.name"));
            logger.info("用户的主目录：    " + props.getProperty("user.home"));
            logger.info("用户的当前工作目录：    " + props.getProperty("user.dir"));
        }
        /**
         * 内存信息
         *
         * @return 返回单位 ：G
         * @throws SigarException
         */
        public static Map<String, Object> memory() throws SigarException {
            Mem mem = sigar.getMem();
            Swap swap = sigar.getSwap();
            Map<String, Object> memory = new HashMap<>();
            memory.put("total", getDouble((double)mem.getTotal() / 1024L / 1024L / 1024L));
            memory.put("used",  getDouble((double)mem.getUsed() / 1024L / 1024L / 1024L));
            memory.put("free",  getDouble((double)mem.getFree() / 1024L / 1024L / 1024L));
            memory.put("freePerc", getDouble(mem.getFreePercent()));
            memory.put("usedPerc", getDouble(mem.getUsedPercent()));
            //交换区
            memory.put("swapTotal", getDouble((double)swap.getTotal() / 1024L / 1024L / 1024L));
            memory.put("swapUsed",  getDouble((double)swap.getUsed() / 1024L / 1024L / 1024L));
            memory.put("swapFree", getDouble((double) swap.getFree() / 1024L / 1024L / 1024L));
            return memory;
        }
        /**
         * cpu使用情况
         *
         * @return
         * @throws SigarException
         */
        public static Map<String, Object> cpu()  {
            Map<String, Object> cpuMap = new HashMap<>();
            try {
                Cpu timer = sigar.getCpu();
                CpuInfo infos[] = sigar.getCpuInfoList();
                Cpu cpu = sigar.getCpu();
                ThreadCpu threadCpu = sigar.getThreadCpu();
                CpuInfo[] cpuInfoList = sigar.getCpuInfoList();
                CpuPerc cpuPerc = sigar.getCpuPerc();
                CpuInfo info1 = infos[0];
                //cpu信息
                cpuMap.put("quantity", infos.length);
                cpuMap.put("model", info1.getModel());// CPU型号
                cpuMap.put("totalCores", info1.getTotalCores());// CPU逻辑个数
                cpuMap.put("totalSockets", info1.getTotalSockets());// CPU物理个数
                cpuMap.put("Mhz", info1.getMhz());
                cpuMap.put("cores",info1.getCoresPerSocket());//核数
                long cacheSize = info1.getCacheSize();
                if (cacheSize != Sigar.FIELD_NOTIMPL) {
                    cpuMap.put("cache",info1.getCacheSize());//核数
                }
                //cpu使用率
                cpuMap.put("timer",timer.getUser());//核数
                cpuMap.put("totalPerc", getDouble(cpuPerc.getCombined() * 100));
                cpuMap.put("userPerc", getDouble(cpuPerc.getUser() * 100));
                cpuMap.put("sysPerc", getDouble(cpuPerc.getSys() * 100));
                cpuMap.put("wait", getDouble(cpuPerc.getWait() * 100));
                cpuMap.put("nice", getDouble(cpuPerc.getNice() * 100));
                cpuMap.put("freePerc", getDouble(cpuPerc.getIdle() * 100));
            } catch (SigarException e){
                e.printStackTrace();
            }
            return cpuMap;
        }
        /**
         * 操作系统信息
         */
        private static void os() {
            OperatingSystem OS = OperatingSystem.getInstance();
            // 操作系统内核类型如： 386、486、586等x86
            logger.info("操作系统:    " + OS.getArch());
            logger.info("操作系统CpuEndian():    " + OS.getCpuEndian());//
            logger.info("操作系统DataModel():    " + OS.getDataModel());//
            // 系统描述
            logger.info("操作系统的描述:    " + OS.getDescription());
            // 操作系统类型
            // logger.info("OS.getName():    " + OS.getName());
            // logger.info("OS.getPatchLevel():    " + OS.getPatchLevel());//
            // 操作系统的卖主
            logger.info("操作系统的卖主:    " + OS.getVendor());
            // 卖主名称
            logger.info("操作系统的卖主名:    " + OS.getVendorCodeName());
            // 操作系统名称
            logger.info("操作系统名称:    " + OS.getVendorName());
            // 操作系统卖主类型
            logger.info("操作系统卖主类型:    " + OS.getVendorVersion());
            // 操作系统的版本号
            logger.info("操作系统的版本号:    " + OS.getVersion());
        }
        private static void who() throws SigarException {
            Who who[] = sigar.getWhoList();
            if (who != null && who.length > 0) {
                for (int i = 0; i < who.length; i++) {
                    // logger.info("当前系统进程表中的用户名" + String.valueOf(i));
                    Who _who = who[i];
                    logger.info("用户控制台:    " + _who.getDevice());
                    logger.info("用户host:    " + _who.getHost());
                    // logger.info("getTime():    " + _who.getTime());
                    // 当前系统进程表中的用户名
                    logger.info("当前系统进程表中的用户名:    " + _who.getUser());
                }
            }
        }
        /**
         * 硬盘信息
         */
        public static List<Map<String, Object>> file() {
            List<Map<String, Object>> files = new ArrayList<>();
            Map<String, Object> fileMap = null;
            FileSystem fslist[] = new FileSystem[0];
            try {
                fslist = sigar.getFileSystemList();
                for (int i = 0; i < fslist.length; i++) {
                    FileSystem fs = fslist[i];
                    fileMap = new HashMap<>();
                    switch (fs.getType()) {
                        case 0: // TYPE_UNKNOWN ：未知
                            break;
                        case 1: // TYPE_NONE
                            break;
                        case 2: // TYPE_LOCAL_DISK : 本地硬盘
                            FileSystemUsage usage = sigar.getFileSystemUsage(fs.getDirName());
                            fileMap.put("devName", fs.getDevName());
                            fileMap.put("dirName", fs.getDirName());
                            fileMap.put("flags", fs.getFlags());
                            fileMap.put("sysTypeName", fs.getSysTypeName());
                            fileMap.put("typeName", fs.getTypeName());
                            fileMap.put("type", fs.getType());
                            fileMap.put("total", usage.getTotal() / 1024L / 1024L);
                            fileMap.put("free", usage.getFree() / 1024L / 1024L);
                            fileMap.put("aVall", usage.getAvail() / 1024L / 1024L);//可用大小
                            fileMap.put("used", usage.getUsed() / 1024L / 1024L);
                            fileMap.put("usePercent", usage.getUsePercent() * 100D);
                            fileMap.put("diskRead", usage.getDiskReads());
                            fileMap.put("diskWrite", usage.getDiskWrites());
                            files.add(fileMap);
                            break;
                        case 3:// TYPE_NETWORK ：网络
                            break;
                        case 4:// TYPE_RAM_DISK ：闪存
                            break;
                        case 5:// TYPE_CDROM ：光驱
                            break;
                        case 6:// TYPE_SWAP ：页面交换
                            break;
                    }
                }
            } catch (SigarException e) {
                e.printStackTrace();
            }
            return files;
        }
        /**
         * 网络信息
         *
         * @throws Exception
         */
        public static Map<String, Object> net() {
            Map<String, Object> netMap = new HashMap<>();
            NetInterfaceConfig netConfig = null;
            try {
                netConfig = sigar.getNetInterfaceConfig(null);
                NetInterfaceStat netIfStat = sigar.getNetInterfaceStat(netConfig.getName());
                Map<String, Object> bps = populate(netConfig.getName());//bps
                netMap.put("name", netConfig.getName());
                netMap.put("address", netConfig.getAddress());
                netMap.put("mac", netConfig.getHwaddr());
                netMap.put("type", netConfig.getType());
                netMap.put("broadcast", netConfig.getBroadcast());
                netMap.put("netmask", netConfig.getNetmask());
                netMap.put("rxPackets", netIfStat.getRxPackets());
                netMap.put("txPackets", netIfStat.getTxPackets());
                netMap.put("rxBytes", netIfStat.getRxBytes());
                netMap.put("txBytes", netIfStat.getTxBytes());
                netMap.put("txPackets", netIfStat.getTxPackets());
                netMap.put("txbps", bps.get("txbps"));
                netMap.put("rxbps", bps.get("rxbps"));
            } catch (SigarException e) {
                e.printStackTrace();
            }
            return netMap;
        }
        private static void ethernet() throws SigarException {
            String[] ifaces = sigar.getNetInterfaceList();
            for (int i = 0; i < ifaces.length; i++) {
                NetInterfaceConfig cfg = sigar.getNetInterfaceConfig(ifaces[i]);
                if (NetFlags.LOOPBACK_ADDRESS.equals(cfg.getAddress()) || (cfg.getFlags() & NetFlags.IFF_LOOPBACK) != 0
                        || NetFlags.NULL_HWADDR.equals(cfg.getHwaddr())
                        || NetFlags.ANY_ADDR.equals(cfg.getAddress())) {
                    continue;
                }
                if ((cfg.getFlags() & 1L) <= 0L) {
                    System.out.println("!IFF_UP...skipping getNetInterfaceStat");
                    continue;
                }
                logger.info(cfg.getName() + "IP地址:" + cfg.getAddress());// IP地址
                logger.info(cfg.getName() + "网关广播地址:" + cfg.getBroadcast());// 网关广播地址
                logger.info(cfg.getName() + "网卡MAC地址:" + cfg.getHwaddr());// 网卡MAC地址
                logger.info(cfg.getName() + "子网掩码:" + cfg.getNetmask());// 子网掩码
                logger.info(cfg.getName() + "网卡描述信息:" + cfg.getDescription());// 网卡描述信息
                logger.info(cfg.getName() + "网卡类型" + cfg.getType());//
            }
        }
        /**
         * 網絡傳輸速率 bps
         *
         * @param name
         * @throws SigarException
         */
        public static Map<String, Object> populate(String name)
                throws SigarException {
            Map<String, Object> bps = new HashMap<>();
            try {
                long start = System.currentTimeMillis();
                NetInterfaceStat statStart = sigar.getNetInterfaceStat(name);
                long rxBytesStart = statStart.getRxBytes();
                long txBytesStart = statStart.getTxBytes();
                Thread.sleep(1000);
                long end = System.currentTimeMillis();
                NetInterfaceStat statEnd = sigar.getNetInterfaceStat(name);
                long rxBytesEnd = statEnd.getRxBytes();
                long txBytesEnd = statEnd.getTxBytes();
                long rxbps = ((rxBytesEnd - rxBytesStart) * 8 / 1024) / ((end - start) / 1000);
                long txbps = ((txBytesEnd - txBytesStart) * 8 / 1024) / ((end - start) / 1000);
                bps.put("rxbps", rxbps);
                bps.put("txbps", txbps);
                logger.info("#######rxbps: " + rxbps + " txbps: " + txbps);
            } catch (SigarException e) {
            } catch (Exception e) {
            }
            return bps;
        }
        /**
         * 获取两位小数的double值
         * @param value
         * @return
         */
        public static double getDouble(double value){
            String total = String.format("%.2f", value );
            return Double.parseDouble(total);
        }
    }

src/main/java/com/yihu/hos/broker/util/XMLUtil.java

@@ -0,0 +1,167 @@
package com.yihu.hos.broker.util;
import org.w3c.dom.*;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.util.Map;
public class XMLUtil {
//    public static void main(String[] args) {
//        String filePath = "e://test.xml";
//        XMLUtil xmlUtil = new XMLUtil();
//        xmlUtil.parseXml(filePath);
//    }
    public static void parseXml(String filePath) {
        File xmlFile = new File(filePath);
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        try {
            dBuilder = dbFactory.newDocumentBuilder();
            dBuilder.setEntityResolver(new IgnoreDTDEntityResolver());
            Document doc = dBuilder.parse(xmlFile);
            Element eltName = doc.createElement("schema");
            Attr attr = doc.createAttribute("name");
            attr.setValue("22222");
            Attr attr2 = doc.createAttribute("checkSQLschema");
            attr2.setValue("true");
            Attr attr3 = doc.createAttribute("sqlMaxLimit");
            attr3.setValue("10");
            Attr attr4 = doc.createAttribute("dataNode");
            attr4.setValue("T2222");
            eltName.setAttributeNode(attr);
            eltName.setAttributeNode(attr2);
            eltName.setAttributeNode(attr3);
            eltName.setAttributeNode(attr4);
            Node stNode = doc.getElementsByTagName("mycat:schema").item(0);
            stNode = addElement(stNode, eltName);
            writeToXml(doc, filePath);
            Element rootElement = doc.getDocumentElement();
            NodeList nodeList = rootElement.getElementsByTagName("schema");
            if (nodeList != null) {
                for (int i = 0; i < nodeList.getLength(); i++) {
                    Element element = (Element) nodeList.item(i);
                    String name = element.getAttribute("name");
                    System.out.println(name);
                }
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
    public static Document parseXml2Doc(String filePath) {
        Document doc = null;
        File xmlFile = new File(filePath);
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        try {
            dBuilder = dbFactory.newDocumentBuilder();
            dBuilder.setEntityResolver(new IgnoreDTDEntityResolver());
            doc = dBuilder.parse(xmlFile);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return doc;
    }
    /**
     *  添加节点
     * @param stNode      基节点
     * @param childNode   要新增的子节点
     * @return
     */
    public static Node addElement(Node stNode, Element childNode) {
        stNode.appendChild(childNode);
        return stNode;
    }
    /**
     * 删除子节点
     * @param node        父节点
     * @param childNode  要删除的子节点
     */
    public static void deleteElement(Node node, Element childNode) {
        node.removeChild(childNode);
    }
    /**
     * //TODO 不需要
     * 修改子节点
     * @param doc
     */
    public static void updateElementValue(Document doc) {
        NodeList mycatNode = doc.getElementsByTagName("mycat:schema");
        Element emp = null;
        //loop for each employee
        for (int i = 0; i < mycatNode.getLength(); i++) {
            emp = (Element) mycatNode.item(i);
            Node name = emp.getElementsByTagName("name").item(0).getFirstChild();
            name.setNodeValue(name.getNodeValue().toUpperCase());
        }
    }
    /**
     * 修改节点属性
     * @param element   要修改的节点
     * @param updateMap 修改的节点属性
     */
    public static Element updateAttributeValue(Element element ,Map<String,String> updateMap) {
        for (Map.Entry<String, String> entry : updateMap.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            element.setAttribute(key,value);
        }
        return element;
    }
    /**
     * 将修改完的xml保存
     *
     * @param doc       修改后的xml
     * @param rptdesign xml的保存路径
     */
    public static boolean writeToXml(Document doc, String rptdesign) {
        boolean succ = false;
        try {
            OutputStream fileoutputStream = new FileOutputStream(rptdesign);
            TransformerFactory tFactory = TransformerFactory.newInstance();
            Transformer transformer = tFactory.newTransformer();
            transformer.setOutputProperty("indent" ,  "yes" );
            System.out.println(doc.getDoctype().getPublicId());
            DOMSource source = new DOMSource(doc);
            //添加解析时忽略的dtd引用
            transformer.setOutputProperty(javax.xml.transform.OutputKeys.DOCTYPE_SYSTEM, doc.getDoctype().getSystemId());
            StreamResult result = new StreamResult(fileoutputStream);
            transformer.transform(source, result);
            succ = true;
        } catch (Exception e) {
            System.out.println("Can't write to file: " + rptdesign);
            e.printStackTrace();
        }
        return succ;
    }
   static class IgnoreDTDEntityResolver implements EntityResolver {
        @Override
        public InputSource resolveEntity(String arg0, String arg1) throws SAXException, IOException {
            return new InputSource(new ByteArrayInputStream("<?xml version='1.0' encoding='UTF-8'?>".getBytes()));
        }
    }
}

src/main/java/com/yihu/hos/broker/util/funct/F0.java

@@ -0,0 +1,14 @@
package com.yihu.hos.broker.util.funct;
/**
 * Represent a function that accept no parameter and return value
 * @param <T> The return value
 */
public interface F0<T> {
    /**
     * Evaluate or execute the function
     * @return Result of execution
     */
    T e();
}

src/main/java/com/yihu/hos/broker/util/funct/F1.java

@@ -0,0 +1,15 @@
package com.yihu.hos.broker.util.funct;
/**
 * Represent a function that accept one parameter and return value
 * @param <A> The only parameter
 * @param <T> The return value
 */
public interface F1<A, T> {
    /**
     * Evaluate or execute the function
     * @param obj The parameter
     * @return Result of execution
     */
	T e(A obj);
}

src/main/java/com/yihu/hos/broker/util/funct/F2.java

@@ -0,0 +1,5 @@
package com.yihu.hos.broker.util.funct;
public interface F2<A, B, T>{
	T e(A a, B b);
}

src/main/java/com/yihu/hos/broker/util/funct/Fs.java

@@ -0,0 +1,45 @@
package com.yihu.hos.broker.util.funct;
import java.util.Collection;
import java.util.concurrent.atomic.AtomicReference;
/**
 * The utility that employ idea of functional programming
 *
 */
@SuppressWarnings({"unchecked", "rawtypes"})
public class Fs extends FsGenerated {
	
    public static Runnable runnable(final P0 action) {
        return new Runnable() {
            public void run() {
                action.e();
            }
        };
    }
	
	/**
	 * Just store the object to collection
	 * @param col
	 * @return
	 */
    public static <A> P1<A> store(final Collection<A> col) {
        return new P1<A>() {public void e(A a) {
            col.add(a);
        }};
    }
    
	public static <A> P1<A> setter(
			final AtomicReference<A> ref) {
		return new P1<A>() {public void e(A obj) {
			ref.set(obj);
		}};
	}
	
	public static <A> void invokeAll(final Collection<P1<A>> col, A a) {
		for (P1<A> p1 : col) {
			p1.e(a);
		}
	}
}

src/main/java/com/yihu/hos/broker/util/funct/FsGenerated.java

@@ -0,0 +1,40 @@
package com.yihu.hos.broker.util.funct;
public class FsGenerated {
	/**
	 * Convert from a p0 to p1
	 * @return p1
	 */
	public static <A> P1<A> p1(final P0 p0) {
		return new P1<A>(){public void e(final A a) {
			p0.e();
		}};
	}
	
	/**
	 * Call to p and return fixed value
	 * @param p1 the function to call before return value
	 * @param ret the fixed value to return
	 * @return ret
	 */
	public static <A, R> F1<A, R> f1(final P1<A> p1, final R ret) {
		return new F1<A, R>(){public R e(final A a) {
			p1.e(a);
			return ret;
		}};
	}
	
	/**
	 * Call to p and return fixed value
	 * @param p2 the function to call before return value
	 * @param ret the fixed value to return
	 * @return ret
	 */
	public static <A, B, R> F2<A, B, R> f2(final P2<A, B> p2, final R ret) {
		return new F2<A, B, R>(){public R e(final A a, final B b) {
			p2.e(a, b);
			return ret;
		}};
	}
}

src/main/java/com/yihu/hos/broker/util/funct/P0.java

@@ -0,0 +1,5 @@
package com.yihu.hos.broker.util.funct;
public interface P0 {
	void e();
}

src/main/java/com/yihu/hos/broker/util/funct/P1.java

@@ -0,0 +1,11 @@
package com.yihu.hos.broker.util.funct;
/**
 * Function that accept 1 objects and return nothing
 * @author QuanLA
 *
 * @param <A>
 */
public interface P1<A> {
	void e(A obj);
}

src/main/java/com/yihu/hos/broker/util/funct/P2.java

@@ -0,0 +1,12 @@
package com.yihu.hos.broker.util.funct;
/**
 * Function that accept 2 objects and return nothing
 * @author QuanLA
 *
 * @param <A>
 * @param <B>
 */
public interface P2<A, B> {
	void e(A a, B b);
}

src/main/java/com/yihu/hos/broker/util/funct/P3.java

@@ -0,0 +1,5 @@
package com.yihu.hos.broker.util.funct;
public interface P3<A, B, C> {
	void e(A a, B b, C c);
}

src/main/java/com/yihu/hos/broker/util/lang/AggressiveClassLoader.java

@@ -0,0 +1,65 @@
package com.yihu.hos.broker.util.lang;
import java.util.HashSet;
import java.util.Set;
/**
 * Load all classes it can, leave the rest to the Parent ClassLoader
 */
public abstract class AggressiveClassLoader extends ClassLoader {
	Set<String> loadedClasses = new HashSet<>();
	Set<String> unavaiClasses = new HashSet<>();
    private ClassLoader parent = AggressiveClassLoader.class.getClassLoader();
    @Override
	public Class<?> loadClass(String name) throws ClassNotFoundException {
		if (loadedClasses.contains(name) || unavaiClasses.contains(name)) {
			return super.loadClass(name); // Use default CL cache
		}
		byte[] newClassData = loadNewClass(name);
		if (newClassData != null) {
			loadedClasses.add(name);
			return loadClass(newClassData, name);
		} else {
			unavaiClasses.add(name);
			return parent.loadClass(name);
		}
	}
//    public AggressiveClassLoader setParent(ClassLoader parent) {
//        this.parent = parent;
//        return this;
//    }
	
	/**
	 * Handle exception
	 * @param name
	 * @return
	 */
	public Class<?> load(String name) {
		try {
			return loadClass(name);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}
	
	protected abstract byte[] loadNewClass(String name);
	public Class<?> loadClass(byte[] classData, String name) {
		Class<?> clazz = defineClass(name, classData, 0, classData.length);
		if (clazz != null) {
			if (clazz.getPackage() == null) {
				definePackage(name.replaceAll("\\.\\w+$", ""), null, null, null, null, null, null, null);
			}
			resolveClass(clazz);
		}
		return clazz;
	}
	public static String toFilePath(String name) {
		return name.replaceAll("\\.", "/") + ".class";
	}
}

src/main/java/com/yihu/hos/broker/util/lang/DynamicClassLoader.java

@@ -0,0 +1,110 @@
package com.yihu.hos.broker.util.lang;
//import qj.util.FileUtil;
//import qj.util.IOUtil;
//import qj.util.funct.F1;
import com.yihu.hos.broker.util.FileUtil;
import com.yihu.hos.broker.util.IOUtil;
import com.yihu.hos.broker.util.funct.F1;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.LinkedList;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
public class DynamicClassLoader extends AggressiveClassLoader {
    LinkedList<F1<String, byte[]>> loaders = new LinkedList<>();
    public DynamicClassLoader(String... paths) {
        for (String path : paths) {
            File file = new File(path);
            F1<String, byte[]> loader = loader(file);
            if (loader == null) {
                throw new RuntimeException("Path not exists " + path);
            }
            loaders.add(loader);
        }
    }
    @SuppressWarnings("UnusedDeclaration")
    public DynamicClassLoader(Collection<File> paths) {
        for (File file : paths) {
            F1<String, byte[]> loader = loader(file);
            if (loader == null) {
                throw new RuntimeException("Path not exists " + file.getPath());
            }
            loaders.add(loader);
        }
    }
    public static F1<String, byte[]> loader(File file) {
        if (!file.exists()) {
            return null;
        } else if (file.isDirectory()) {
            return dirLoader(file);
        } else {
            try {
                final JarFile jarFile = new JarFile(file);
                return jarLoader(jarFile);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    private static File findFile(String filePath, File classPath) {
        File file = new File(classPath, filePath);
        return file.exists() ? file : null;
    }
    public static F1<String, byte[]> dirLoader(final File dir) {
        return filePath -> {
            File file = findFile(filePath, dir);
            if (file == null) {
                return null;
            }
            return FileUtil.readFileToBytes(file);
        };
    }
    private static F1<String, byte[]> jarLoader(final JarFile jarFile) {
        return new F1<String, byte[]>() {
            public byte[] e(String filePath) {
                ZipEntry entry = jarFile.getJarEntry(filePath);
                if (entry == null) {
                    return null;
                }
                try {
                    return IOUtil.readData(jarFile.getInputStream(entry));
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            @Override
            protected void finalize() throws Throwable {
                IOUtil.close(jarFile);
                super.finalize();
            }
        };
    }
    @Override
    protected byte[] loadNewClass(String name) {
//		System.out.println("Loading class " + name);
        for (F1<String, byte[]> loader : loaders) {
            byte[] data = loader.e(AggressiveClassLoader.toFilePath(name));
            if (data != null) {
                return data;
            }
        }
        return null;
    }
}

src/main/java/com/yihu/hos/broker/util/lang/ExceptingClassLoader.java

@@ -0,0 +1,28 @@
package com.yihu.hos.broker.util.lang;
import com.yihu.hos.broker.util.funct.F1;
/**
 * This class loader will not load certain classes, instead delegate to parent
 * class loader to do the job
 */
@SuppressWarnings("UnusedDeclaration")
public class ExceptingClassLoader extends DynamicClassLoader {
	private F1<String, Boolean> except;
	public ExceptingClassLoader(F1<String, Boolean> except, String... paths) {
		super(paths);
		this.except = except;
	}
	@Override
	protected byte[] loadNewClass(String name) {
		if (except.e(name)) {
            return null;
		}
		return super.loadNewClass(name);
	}
}

src/main/resources/META-INF/additional-spring-configuration-metadata.json

@@ -0,0 +1,19 @@
{
  "properties": [
    {
      "name": "hos.arbiter.enable",
      "type": "java.lang.String",
      "description": "Description for hos.arbiter.enable."
    },
    {
      "name": "hos.arbiter.url",
      "type": "java.lang.String",
      "description": "Description for hos.arbiter.url."
    },
    {
      "name": "hos.timer.period",
      "type": "java.lang.String",
      "description": "Description for hos.timer.period."
    }
  ]
}

src/main/resources/application.yml

@@ -0,0 +1,138 @@
server:
  port: 8099
  contextPath:
  sessionTimeout:  300
# the name of Camel
camel:
  springboot:
    name: hos-broker
---
spring:
  profiles: dev
  activemq:
    broker-url: tcp://172.19.103.42:61616
    user: admin
    password: admin
  data:
    mongodb:
      host: 172.19.103.57
      port: 27017
      username: esb
      password: esb
      authenticationDatabase: admin
      database: log
      gridFsDatabase: dfs
log:
  path: D://logs/logback/dev
  level: info
hos:
  filesystem:
    url: http://172.19.103.57:9010/dfs/file
  arbiter:
    enable: true
    url: http://localhost:10135
  rest:
    url: http://localhost:8088
  timer:
      period: 10000
  tenant:
    name: jkzl
  mycat:
    path: /usr/local/mycat/   ##mycat的安装目录
  #jcraft shell操作
  jcraft:
    host: 172.19.103.57
    port: 22
    user: rootxx
    password: ceshi
hzy:
  hello: hello dev !!!
---
spring:
  profiles: test
  activemq:
      broker-url: tcp://172.19.103.57:61616 # activeMq地址
      user: admin
      password: admin
  data:
    mongodb:
      host: 172.19.103.57 # mongodb 连接信息
      port: 27017
      username: esb
      password: esb
      authenticationDatabase: admin
      database: log
      gridFsDatabase: dfs
log:
  path: /data/logs/hos-broker  #日志输出地址
  level: info
hos:
  filesystem:
    url: http://172.19.103.58:9010/dfs/file #文件服务器地址
  arbiter:
    enable: true
    url: http://172.19.103.58:10135  # arbiter 的连接地址
  rest:
    url: http://172.19.103.58:8088  # 采集上传档案等服务连接地址
  timer:
      period: 10000
  tenant:
    name: yichang
  mycat:
    path: /usr/local/mycat/   ##mycat的安装目录
  #jcraft shell操作，连接终端服务器的后门信息
  jcraft:
    host: 172.19.103.37
    port: 22
    user: root
    password: ceshi
hzy:
  hello: hello test !!!
---
spring:
  profiles: prod
  activemq:
    broker-url: tcp://192.168.200.60:61616
    user: admin
    password: admin
  data:
    mongodb:
      host: 192.168.50.26
      port: 20000
      username: jkzlesb
      password: fgu$^ezl
      authenticationDatabase: admin
      database: log
      gridFsDatabase: dfs
log:
  path: /usr/local/esb/logs/hos-broker
  level: error
hos:
  filesystem:
    url: http://192.168.200.62:9010/dfs/file
  arbiter:
    enable: true
    url: http://192.168.200.62:10135
  rest:
    url: http://192.168.200.62:8088
  timer:
      period: 10000
  tenant:
    name: jkzl
  mycat:
    path: /usr/local/mycat/   ##mycat的安装目录
  #jcraft shell操作
  jcraft:
    host: 192.168.200.62
    port: 22
    user: root
    password: ceshi
  https:
    enable: false

src/main/resources/bootstrap.yml

@@ -0,0 +1,37 @@
spring:
  application:
    name: hos-broker
security:
  basic:
    enabled: false
---
spring:
  profiles: dev
  cloud:
    config:
      username: user
      password: configuration
      uri: ${spring.config.uri:http://172.19.103.73:1221}
      label: ${spring.config.label:dev}
---
spring:
  profiles: test
  cloud:
    config:
      username: user
      password: configuration
      uri: ${spring.config.uri:http://172.19.103.73:1221}
      label: ${spring.config.label:dev}
---
spring:
  profiles: prod
  cloud:
    config:
      username: user
      password: configuration
      uri: ${spring.config.uri}
      label: ${spring.config.label}

src/main/resources/jndi.properties

@@ -0,0 +1,7 @@
connectionFactoryNames = ConnectionFactory
# register some queues in JNDI using the form
# queue.[jndiName] = [physicalName]
# queue.logback-queue = business.log.queue
# topic.[jndiName] = [physicalName]
topic.logback-queue = business.log.queue

src/main/resources/logback-spring.xml

@@ -0,0 +1,113 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!--<property name="log_dir" value="logs/"/>-->
    <!--&lt;!&ndash;日志文件的保存路径,首先查找系统属性-Dlog.dir,如果存在就使用其；否则，在当前目录下创建名为logs目录做日志存放的目录 &ndash;&gt;-->
    <!--<property name="LOG_HOME" value="${log_dir:-logs}"/>-->
    <springProperty scope="context" name="logLevel" source="log.level"/>
    <springProperty scope="context" name="LOG_HOME" source="log.path"/>
    <!--<springProperty scope="context" name="ACTIVE_MQ_URL" source="log.mqUrl"/>-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>%date [%thread] %-5level %logger - %msg%n</Pattern>
        </layout>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>WARN</level>
        </filter>
    </appender>
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">　　　　
        <file>${LOG_HOME}/output.log</file>　　　　　　　　
        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
            <fileNamePattern>${LOG_HOME}/%d{yyyy-MM-dd_HH_mm}.%i.log.zip</fileNamePattern>
            <minIndex>1</minIndex>
            <maxIndex>3</maxIndex>
        </rollingPolicy>
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <maxFileSize>100MB</maxFileSize>
        </triggeringPolicy>
        <encoder>
            <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{25} - %msg%n</Pattern>
            <charset>utf-8</charset>
        </encoder>
    </appender>
    <appender name="queue" class="com.yihu.hos.broker.common.log.JmsAppender">
        <InitialContextFactoryName>
            org.apache.activemq.jndi.ActiveMQInitialContextFactory
        </InitialContextFactoryName>
        <ProviderURL>tcp://192.168.200.60:61616</ProviderURL>
        <!--<ProviderURL>tcp://172.19.103.57:61616</ProviderURL>-->
        <userName>admin</userName>
        <password>admin</password>
        <TopicConnectionFactoryBindingName>ConnectionFactory</TopicConnectionFactoryBindingName>
        <TopicBindingName>logback-queue</TopicBindingName>
    </appender>
    <!--<logger name="br.org.roger.logback" level="INFO" additivity="false">-->
    <!--<appender-ref ref="console" />-->
    <!--</logger>-->
    <!-- 开发环境配置 -->
    <springProfile name="dev">
        <logger name="org.apache.camel" level="INFO" additivity="false">
            <appender-ref ref="queue"/>
        </logger>
        <logger name="org.hibernate" level="WARN"/>
        <!--<logger name="org.springframework" level="INFO"/>-->
        <logger name="springfox.documentation" level="WARN"/>
        <root level="INFO">
            <appender-ref ref="file"/>
            <appender-ref ref="console"/>
        </root>
    </springProfile>
    <!-- 测试服务器配置 -->
    <springProfile name="test">
        <logger name="org.apache.camel" level="INFO" additivity="false">
            <appender-ref ref="queue"/>
        </logger>
        <logger name="org.hibernate" level="WARN"/>
        <logger name="org.springframework" level="WARN"/>
        <logger name="springfox.documentation" level="WARN"/>
        <root level="INFO">
            <appender-ref ref="file"/>
            <appender-ref ref="console"/>
        </root>
    </springProfile>
    <!-- 上饶服务器配置 -->
    <springProfile name="prod_sr">
        <logger name="org.apache.camel" level="ERROR" additivity="false">
            <appender-ref ref="queue"/>
        </logger>
        <logger name="org.hibernate" level="ERROR"/>
        <logger name="org.springframework" level="ERROR"/>
        <logger name="springfox.documentation" level="ERROR"/>
        <root level="ERROR">
            <appender-ref ref="file"/>
            <appender-ref ref="console"/>
        </root>
    </springProfile>
    <!-- 福州总院服务器配置 -->
    <springProfile name="prod_sr">
        <logger name="org.apache.camel" level="ERROR" additivity="false">
            <appender-ref ref="queue"/>
        </logger>
        <logger name="org.hibernate" level="ERROR"/>
        <logger name="org.springframework" level="ERROR"/>
        <logger name="springfox.documentation" level="ERROR"/>
        <root level="ERROR">
            <appender-ref ref="file"/>
            <appender-ref ref="console"/>
        </root>
    </springProfile>
</configuration>

src/test/java/com/yihu/hos/HosBrokerApplicationTests.java

@@ -0,0 +1,18 @@
package com.yihu.hos;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
@WebAppConfiguration
public class HosBrokerApplicationTests {
    @Test
    public void contextLoads() {
    }
}

src/test/java/com/yihu/hos/broker/services/camel/ESBCamelServiceTest.java

@@ -0,0 +1,95 @@
package com.yihu.hos.broker.services.camel;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import java.io.File;
import java.net.URI;
/**
 * @author Airhead
 * @since 2016/12/6.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
@WebAppConfiguration
public class ESBCamelServiceTest {
    @Autowired
    private ESBCamelService esbCamelService;
    @Test
    public void onServiceFlowAdd() throws Exception {
    String msg="{\n" +
            "    \"routeCode\" : \"invokeSync\",\n" +
            "    \"updated\" : null,\n" +
            "    \"flowType\" : \"class\",\n" +
            "    \"handleFiles\" : [ \n" +
            "        {\n" +
            "            \"usage\" : \"processor\",\n" +
            "            \"packageName\" : \"apisync.processor\",\n" +
            "            \"className\" : \"ApiProcessor\",\n" +
            "            \"filePath\" : \"22241906357fac850e39df5dd74e7ddc4f1c6808019c571a98e96ad7e01a635afe687822969a785b523d97cbc5d33904b5296227c61c08bb\",\n" +
            "            \"fileType\" : \"class\",\n" +
            "            \"routeCode\" : \"invokeSync\"\n" +
            "        }, \n" +
            "        {\n" +
            "            \"usage\" : \"route\",\n" +
            "            \"packageName\" : \"apisync.route\",\n" +
            "            \"className\" : \"ApiRouteBulider\",\n" +
            "            \"filePath\" : \"89108d6cbec5e48ae19806476e1e946fb10e5656424326c288c69dcfda6a3add873b0c64959cb310e96e4cd4f3c0d627f82f813633c2f8ebe73a3fa3a83feb15\",\n" +
            "            \"fileType\" : \"class\",\n" +
            "            \"routeCode\" : \"invokeSync\"\n" +
            "        }\n" +
            "    ]\n" +
            "}";
    esbCamelService.onServiceFlowAdd(msg);
    }
    @Test
    public void onServiceFlowModifyAdd() throws Exception {
    }
    @Test
    public void onServiceFlowModifyReduce() throws Exception {
    }
    @Test
    public void onServiceFlowDelete() throws Exception {
    }
    @Test
    public void onServiceFlowStart() throws Exception {
    }
    @Test
    public void onServiceFlowStop() throws Exception {
    }
    @Test
    public void onProcessorAdded() throws Exception {
        String url = this.getClass().getProtectionDomain().getClassLoader().getResource("").toString();
        System.out.println(url);
        File systemClassFlowPath = new File(this.getClass().getProtectionDomain().getClassLoader().getResource("").getPath());
        String sysPath = systemClassFlowPath.toURI().toURL().toString();
        System.out.println(sysPath);
        URI uri = ESBCamelService.class.getResource("").toURI();
        File file  = new File("d:/usr");
        URI uri1 = file.toURI();
        uri1.toURL();
    }
}