java整合kettle部署任务到远程服务器

由于kettle服务器时不时断电重启，部署的那些任务需要手动一个一个点比较麻烦，所以希望能通过代码一把部署多个任务或转换到服务器上。导入了相关jar包，但有些和项目原有的冲突，然后一点点试过来导入了一部分。

在本地运行任务和转换的能找到很多参考代码，然后部署到远程服务器上的相较少一些，找了许久，单独部署转换到服务器上的时候测试成功，但是任务中包含转换的就不行，会一直报找不到转换，无论我把转换的路径写成绝对路径还是${Internal.Job.Filename.Directory}这种都不行，我想着在部署job之前把trans先部署上去但是这样也不行... 好多相关文档都是下载要币的

然后我就下载了源码，首先在kettle中遇到这种问题，是因为运行环境的send resources to this server没有打钩，我就照着这种思路去找源码中的这个参数。

我觉得这个参数肯定是个boolean，首先搜索send resource等找到了疑似，然后想是不是有什么RunConfiguration的类需要在部署到服务器上之前进行设置，但找了半天没找到

后来又去搜DefaultRunConfiguration这个类，最终在DefaultRunConfigurationExecutor.java中找到了一行设置这个类的sendresource变量的。。。而且这个JobExecutionConfiguration刚好是部署到服务器上市用到的配置类，这才有了下面代码的180行。成功了~啊~解决了真的好开心哦~

package org.ssh.hip.job.util;

import org.pentaho.di.cluster.SlaveServer;
import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.job.Job;
import org.pentaho.di.job.JobExecutionConfiguration;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.RepositoryDirectoryInterface;
import org.pentaho.di.repository.kdr.KettleDatabaseRepository;
import org.pentaho.di.repository.kdr.KettleDatabaseRepositoryMeta;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransExecutionConfiguration;
import org.pentaho.di.trans.TransMeta;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class KettleEnvironments2 {
    
    static final Logger logger = LoggerFactory.getLogger(KettleEnvironments2.class);

    
    public static KettleDatabaseRepository repository;
    public static DatabaseMeta databaseMeta;
    public static RepositoryDirectoryInterface directory;
    public static SlaveServer remoteServer; 
 
    /**
     * 配置资源库环境 并接连接的资源库
     * @return 
     * 
     * @return
     * @throws KettleException
     */
    public static void repositoryCon(String repositoryName,String repositoryType,String repositoryConnectType,String repositoryIp,String repositoryDBName,String repositoryDBPort,String
            repositoryDBUsername,String repositoryDBPassword, String repositoryUsername, String repositoryPassword) throws KettleException {
        // 初始化
        KettleEnvironment.init(); // 感觉这句话很重要
        // 数据库连接元对象
        // （kettle数据库连接名称(KETTLE工具右上角显示)，资源库类型，连接方式，IP，数据库名，端口，用户名，密码） //cgmRepositoryConn
//        databaseMeta = new DatabaseMeta("ETL", "Oracle", "Native", "192.168.1.28","orcl", "1521",
//                "etl", "etl");//资源库数据库地址，我这里采用oracle数据库
        databaseMeta = new DatabaseMeta(repositoryName, repositoryType, repositoryConnectType, repositoryIp, repositoryDBName, repositoryDBPort,
                repositoryDBUsername, repositoryDBPassword);//资源库数据库地址，我这里采用oracle数据库
        // 数据库形式的资源库元对象
        KettleDatabaseRepositoryMeta kettleDatabaseMeta = new KettleDatabaseRepositoryMeta();
　　　　　　　kettleDatabaseMeta.setName(repositoryName); // 资源库名字，这里不写会导致转换里java代码通过名字获取资源库进而获取数据库连接获取不到
        kettleDatabaseMeta.setConnection(databaseMeta);
        // 数据库形式的资源库对象
        repository = new KettleDatabaseRepository();
        // 用资源库元对象初始化资源库对象
        repository.init(kettleDatabaseMeta);
        // 连接到资源库
        repository.connect(repositoryUsername, repositoryPassword);// 默认的连接资源库的用户名和密码
        directory = repository.loadRepositoryDirectoryTree();
        if (repository.isConnected()) {
            System.out.println("连接成功");
        } else {
            System.out.println("连接失败");
        }
    }
    
    /**
     * 加载子服务器
     */
    public static void initRemoteServer(String serverHostname, String serverPort,
            String serverName, String serverUsername, String serverPassword, boolean serverMaster) {
        remoteServer = new SlaveServer();
        remoteServer.setHostname(serverHostname);
        remoteServer.setPort(serverPort);
        remoteServer.setName(serverName);
        remoteServer.setUsername(serverUsername);
        remoteServer.setPassword(serverPassword);
        remoteServer.setMaster(serverMaster); // 是否是主服务器
    }

    /**
     * 调用Transformation示例
     * 
     * @param rep
     * @param transName
     */
    public static void runTrans(String path, String transName) {

        try {
            // 根据指定的字符串路径 找到目录，在 r_transformation中id_directory=0的代表根目录
            RepositoryDirectoryInterface dir = repository.findDirectory(path);
            // 根据转换名称获取转换id
            // 这个值就是从SELECT ID_TRANSFORMATION FROM `r_transformation` where name='fromto';来的
            ObjectId id = repository.getTransformationID(transName, dir);
            System.out.println("------ObjectId=" + id);
            // 根据转换id查询与其关联的step和hop
            // select name from r_step where ID_STEP=(SELECT ID_STEP_FROM FROM `r_trans_hop` where
            // ID_TRANSFORMATION='1');
            // select name from r_step where ID_STEP=(SELECT ID_STEP_TO FROM `r_trans_hop` where ID_TRANSFORMATION='1');
            TransMeta transMeta = repository.loadTransformation(id, null);
            //
            Trans trans = new Trans(transMeta);
            trans.execute(null);// 执行转换
            trans.waitUntilFinished(); // 等待转换执行结束
            if (trans.getErrors() != 0) {
                System.out.println("trans executed failed");
            } else {
                System.out.println("trans executed OK");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    

    /**
     * 本地运行job
     * @param path
     * @param jobName
     * @throws KettleException
     */
    public static void runJob(String path, String jobName) throws KettleException {
        // jobname 是Job脚本的路径及名称  
        // new JobMeta(jobName, null); // new出来的路径变成了D盘的
        // new JobMeta(jobName, repository); // new出来的路径变成了D:\workspace\ekhip_git\sshapp-ekhips\sshapp-ekhips-auth\sshapp-hip-app\sshapp-hip-job\
        RepositoryDirectoryInterface dir = repository.findDirectory(path);
        
        // 方法1
        JobMeta jobMeta = repository.loadJob(jobName, dir, null, null); 
        Job job = new Job(repository, jobMeta);
        
        // 方法2
//        ObjectId id = repository.getJobId(jobName, dir);
//        JobMeta jobMeta = repository.loadJob(id, null);
//        Job job = new Job(repository, jobMeta);
        
        // 向Job 脚本传递参数，脚本中获取参数值：${参数名}  
        // job.setVariable(paraname, paravalue);
    
//        try {
//            SlaveServerConfig config = new SlaveServerConfig("192.168.1.208", 9000, true);//ip与端口与通过Carte.bat启动时指定的参数一样
//            Carte.runCarte(config);
//        } catch (Exception e) { // 通过该静态方法启动carte
//            e.printStackTrace();
//        }
        
        job.start();
//        job.waitUntilFinished(); // 这个是等待job执行完，但是有的任务是定时的重复的
        if (job.getErrors() > 0) {
            System.out.println("job executed failed");
        } else {
            System.out.println("job executed OK");
        }
    }
    
    /**
     * 远程服务器上执行job
     * @param dir
     * @param jobName
     * @throws KettleException
     */
    public static void executeJobRemote(String path, String jobName) throws KettleException {

        RepositoryDirectoryInterface directory = repository.loadRepositoryDirectoryTree(); // Default

        RepositoryDirectoryInterface dir = repository.findDirectory(path);

//        JobMeta jobMeta = repository.loadJob(jobName, jobdir, null, null); // reads
        
        // 方法2
        ObjectId id = repository.getJobId(jobName, dir);
        JobMeta jobMeta = repository.loadJob(id, null);
        
        System.out.println("------ObjectId=" + id);
        
        // last
        // version
        JobExecutionConfiguration jobExecutionConfiguration = new JobExecutionConfiguration();
//        RunConfiguration run = new RunConfiguration();
        jobExecutionConfiguration.setRemoteServer(remoteServer);
        jobExecutionConfiguration.setRepository(repository); // 这里不设置不影响部署，但是转换中通过java代码获取资源库会获取不到，所以要写
//        jobExecutionConfiguration.setRunConfiguration("28"); // 没有差别
        jobExecutionConfiguration.setPassingExport(true); // send resources to this server
        String lastCarteObjectId = Job.sendToSlaveServer(jobMeta, jobExecutionConfiguration, repository, null);
        System.out.println(lastCarteObjectId);
        
//        SlaveServerJobStatus jobStatus = null;
//        do {
//            Thread.sleep(5000);
//            jobStatus = remoteServer.getJobStatus(jobMeta.getName(), lastCarteObjectId, 0);
//        } while (jobStatus != null && jobStatus.isRunning());
//        Result oneResult = new Result();
//        System.out.println(jobStatus);
//        if (jobStatus.getResult() != null) {
//            // 流程完成，得到结果
//            oneResult = jobStatus.getResult();
//            System.out.println("Result:" + oneResult);
//        } else {
//            System.out.println("取到空了");
//        }
        
//        SlaveServerJobStatus jobStatus = null;
//        Result oneResult = new Result();
//        while (true) {
//            try {
//                jobStatus = remoteServer.getJobStatus(jobMeta.getName(), lastCarteObjectId, 0);
//                if (jobStatus.getResult() != null) {
//                    // The job is finished, get the result...
//                    oneResult = jobStatus.getResult();
//                    break;
//                }
//            } catch (Exception e1) {
//                oneResult.setNrErrors(1L);
//                break; // Stop looking too, chances are too low the server
//                // will
//                // come back on-line
//            }
//        }
    }
    
    /**
     * 远程服务器上执行trans
     * @param dir
     * @param jobName
     * @throws KettleException
     */
    public static void executeTransRemote(String path, String transName) throws KettleException {

        RepositoryDirectoryInterface dir = repository.findDirectory(path);
        // 根据转换名称获取转换id
        // 这个值就是从SELECT ID_TRANSFORMATION FROM `r_transformation` where name='fromto';来的
        ObjectId id = repository.getTransformationID(transName, dir);
        System.out.println("------ObjectId=" + id);
        // 根据转换id查询与其关联的step和hop
        // select name from r_step where ID_STEP=(SELECT ID_STEP_FROM FROM `r_trans_hop` where
        // ID_TRANSFORMATION='1');
        // select name from r_step where ID_STEP=(SELECT ID_STEP_TO FROM `r_trans_hop` where ID_TRANSFORMATION='1');
        TransMeta transMeta = repository.loadTransformation(id, null);
        
        // last
        // version
        TransExecutionConfiguration transExecutionConfiguration = new TransExecutionConfiguration();

        transExecutionConfiguration.setRemoteServer(remoteServer);

        transExecutionConfiguration.setRepository(repository);
        
        String lastCarteObjectId = Trans.sendToSlaveServer(transMeta, transExecutionConfiguration, repository, null);
        System.out.println(lastCarteObjectId);

    }
    
}