为Java运行环境导入根证书解决Eclipse的TFS插件的"PKIX path building failed"错误

最近在项目中必须要使用微软的TFS作为项目管理工具以及版本控制,而开发的IDE使用的是Eclipse。好在TFS有一个Eclipse的插件能够在跨平台的环境下工作。不过这个插件的11.0版本中,连结服务器的时候如果使用HTTPS连结,可能会有一个证书的认证错误问题,

sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
...
Caused by: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
...

这个问题的是由于Java自带的根证书库中不包含HTTPS服务器上的根证书,因此无法得到认证。解决办法是将服务器的根证书导入到Java运行环境中的根证书库中。假设我的证书文件是zero.cer,首先确保命令行下所引用的java是下文命令中所指向$JAVA_HOME/jre/bin的是一个JRE,如果不是则需要修改JAVA_HOME的位置。

$ keytool -import -noprompt -trustcacerts -alias zero -file zero.cer -keystore ~/mykeystore

这个命令会新建一个keystore文件,命令运行后会要求输入密码,这个密码是新建的keystore文件的访问密码。

For Linux:

$ sudo keytool -importkeystore -srckeystore ~/mykeystore -destkeystore $JAVA_HOME/jre/lib/security/cacerts

For Mac:

$ sudo keytool -importkeystore -srckeystore ~/mykeystore -destkeystore /Library/Java/Home/lib/security/cacerts

第二个命令将之前建好的keystore中的证书导入jre自带的keystore文件中。过程中会要求输入目标keystore(也就是jre自带的keystore)文件的密码,这个密码默认是 changeit (linux和mac下),或者是 changeme 。

之后,重启Eclipse,再次连结TFS服务器,即可成功通过服务器验证。此外,可以下载一个小工具SSLPoke验证证书是否导入正常,下载之后在文件所在目录下,命令行运行

$ java SSLPoke tfs.yourserver.com 4343
Successfully connected

如果显示成功则说明证书导入的没有问题。

ant 中通过重新定义 project.all.jars.path 在 classpath 中引入外部 jar 文件

在Android开发中,除了通常在Eclipse中的编译方法之外,有的时候为了进行持续集成,可能还需要用ant进行自动化编译。Android SDK本身已经提供了默认的ant编译脚本,就在每个工程下的build.xml中,其中引用了SDK的编译脚本${sdk_dir}/tools/ant/build.xml 。 通常情况下,在工程根目录下直接执行 ant debug 即可进行一次正常的build。默认的classpath会包括libs目录下的所有jar文件。但是如果工程中使用了USER LIBRARY,或者引用了外部的jar文件,那么在编译中就可能会遇到问题,因为这些jar文件不会被自动包含在classpath中,这时就要扩展ant的path变量,把自己的jar文件加入到classpath中。

通过察看sdk提供的build.xml编译脚本,可以发现javac使用的classpath定义如下:

<path id="project.javac.classpath">
    <path refid="project.all.jars.path"></path>
    <path refid="tested.project.classpath"></path>
</path>


<javac encoding="${java.encoding}"
        source="${java.source}" target="${java.target}"
        debug="true" extdirs="" includeantruntime="false"
        destdir="${out.classes.absolute.dir}"
        bootclasspathref="project.target.class.path"
        verbose="${verbose}"
        classpathref="project.javac.classpath"
        fork="${need.javac.fork}">
    <src path="${source.absolute.dir}"></src>
    <src path="${gen.absolute.dir}"></src>
    <compilerarg line="${java.compilerargs}"></compilerarg>
</javac>

其中 project.all.jars.path 包含了所有的jar文件,我们可以通过在工程目录下的buildxml中重新定义这个变量来引入其他的jar文件。例如在我的工程中,引用了ormlite这个ORM库,为了能够在开发中使用“attach source”察看源码,该jar文件不能放在libs目录中,因为Eclipse不允许对libs目录中的jar文件“attach source”。因此我将此文件放到了libs/ormlite目录中,为了能够将这两个jar文件加入到classpath中,就要重新定义 project.all.jars.path 这个元素。

基本思路是,重新定义-pre-compile这个target,在其中重新定义 project.all.jars.path 的值。

<target name="-pre-compile">
    <echo message="JARPATH=${toString:project.all.jars.path}"></echo>

    <property name="ormlite.dir" value="${jar.libs.dir}/ormlite"></property>
    <path id="ormlite.lib">
        <path path="${toString:project.all.jars.path}"></path>
        <pathelement location="${ormlite.dir}/ormlite-android-4.41.jar"></pathelement>
        <pathelement location="${ormlite.dir}/ormlite-core-4.41.jar"></pathelement>
    </path>

    <path id="project.all.jars.path">
        <path refid="ormlite.lib"></path>
    </path>

    <echo message="JARPATH=${toString:project.all.jars.path}"></echo>
</target>

ThoughtWorks 的一道笔试题

PROBLEM ONE: TRAINS

Problem: The local commuter railroad services a number of towns in Kiwiland. Because of monetary concerns, all of the tracks are 'one-way.' That is, a route from Kaitaia to Invercargill does not imply the existence of a route from Invercargill to Kaitaia. In fact, even if both of these routes do happen to exist, they are distinct and are not necessarily the same distance!

The purpose of this problem is to help the railroad provide its customers with information about the routes. In particular, you will compute the distance along a certain route, the number of different routes between two towns, and the shortest route between two towns.

Input: A directed graph where a node represents a town and an edge represents a route between two towns. The weighting of the edge represents the distance between the two towns. A given route will never appear more than once, and for a given route, the starting and ending town will not be the same town.

Output: For test input 1 through 5, if no such route exists, output 'NO SUCH ROUTE'. Otherwise, follow the route as given; do not make any extra stops! For example, the first problem means to start at city A, then travel directly to city B (a distance of 5), then directly to city C (a distance of 4).

  1. The distance of the route A-B-C.
  2. The distance of the route A-D.
  3. The distance of the route A-D-C.
  4. The distance of the route A-E-B-C-D.
  5. The distance of the route A-E-D.
  6. The number of trips starting at C and ending at C with a maximum of 3 stops. In the sample data below, there are two such trips: C-D-C (2 stops). and C-E-B-C (3 stops).
  7. The number of trips starting at A and ending at C with exactly 4 stops. In the sample data below, there are three such trips: A to C (via B,C,D); A to C (via D,C,D); and A to C (via D,E,B).
  8. The length of the shortest route (in terms of distance to travel) from A to C.
  9. The length of the shortest route (in terms of distance to travel) from B to B.
  10. The number of different routes from C to C with a distance of less than 30. In the sample data, the trips are: CDC, CEBC, CEBCDC, CDCEBC, CDEBC, CEBCEBC, CEBCEBCEBC.

Test Input:

For the test input, the towns are named using the first few letters of the alphabet from A to D. A route between two towns (A to B) with a distance of 5 is represented as AB5.

Graph: AB5, BC4, CD8, DC8, DE6, AD5, CE2, EB3, AE7

Expected Output:

Output #1: 9 Output #2: 5 Output #3: 13 Output #4: 22 Output #5: NO SUCH ROUTE Output #6: 2 Output #7: 3 Output #8: 9 Output #9: 9

Output #10: 7

用一个带权重的有向图表示节点之间的关系,使用深度优先搜索。

1-5:

package com.log4think.code;

public class TrainMap {

    public int[][] map = {
        //    A   B   C   D   E
            {-1,  5, -1,  5,  7}, 
            {-1, -1,  4, -1, -1},
            {-1, -1, -1,  8,  2},
            {-1, -1,  8, -1,  6},
            {-1,  3, -1, -1, -1},
    };
    
    public int getDistance(String path)
    {
        int distance = 0;
        
        for (int i=0; i 0)
            System.out.println(distance);
        else
            System.out.println("NO SUCH ROUTE");
        
//      g.findDistance("AD");
//      g.findDistance("ADC");
//      g.findDistance("AEBCD");
//      g.findDistance("AED");
    }
}

6:

public class TrainMap {

    public int[][] map = { 
            {-1, 5, -1, 5, 7}, 
            {-1, -1, 4, -1, -1},
            {-1, -1, -1, 8, 2},
            {-1, -1, 8, -1, 6},
            {-1, 3, -1, -1, -1},
    };
    

    // used to record the trip round count
    public int tripCount = 0;
    
    /***
     * 
     * @param end , the end node. if we reach it we found a path
     * @param path , the current path we already have 
     * @param maxLength, the maximum stops
     */
    public void dfs(String end, String path, int maxLength)
    {
        // this is for debug and trace
        // System.out.println(";; " + path);
        
        // if the path reach the maximum stops, then cancel search
        if (path.length() - 1 > maxLength) return;
        
        // check if we have reach the "end" node
        if ( path.length() > 1 && path.endsWith(end) ) {
            System.out.println(path + ", " + tripCount);
            tripCount ++;
        }
        
        // caculate the lastest node index in map
        char lastChar = path.charAt(path.length()-1);
        int lastNodeIndex = lastChar - 'A';
        
        // loop all nodes in map which connected to lastNode, and try it
        for ( int i=0; i 0) {
                dfs(end, path + newChar, maxLength);
            }
        }
    }
    
    public static void main(String[] args) {
        TrainMap g = new TrainMap();
        
        g.dfs("C", "C", 3);
    }
}

7:

public class TrainMap {

    public int[][] map = { 
            { -1, 5, -1, 5, 7 }, 
            { -1, -1, 4, -1, -1 },
            { -1, -1, -1, 8, 2 }, 
            { -1, -1, 8, -1, 6 }, 
            { -1, 3, -1, -1, -1 }
    };

    public void bfs(String start, String end, int hops) {
        String lastRoute = start;

        for (int hop = 0; hop < hops; hop++) {
            String route = "";
            for (int i = 0; i < lastRoute.length(); i++) {
                char c = lastRoute.charAt(i);
                int id = c - 'A';

                for (int j = 0; j < map[id].length; j++) {
                    if (map[id][j] > 0)
                        route = route + (char) (j + 'A');
                }
            }
//          System.out.println(lastRoute);
            lastRoute = route;
        }

//      System.out.println(lastRoute);
        System.out.println(lastRoute.split(end).length - 1);
    }

    public static void main(String[] args) {
        TrainMap g = new TrainMap();

        g.bfs("A", "C", 4);
    }
}

8/9:

public class TrainMap {

    public int[][] map = { 
            {-1, 5, -1, 5, 7}, 
            {-1, -1, 4, -1, -1},
            {-1, -1, -1, 8, 2},
            {-1, -1, 8, -1, 6},
            {-1, 3, -1, -1, -1},
    };
    
    public void dfs(String end, String path, int cost) {
        if (path.endsWith(end) && cost < bestCost && cost > 0) {
            bestPath = path;
            bestCost = cost;
            return;
        }
        char lastChar = path.charAt(path.length() - 1);
        int lastNodeIndex = lastChar - 'A';

        for (int i = 0; i < map[lastNodeIndex].length; i++) {
            char newChar = (char) (i + 'A');
            int newCost = map[lastNodeIndex][i];
            if (newCost > 0) {
                if (path.indexOf(newChar) > 0)
                    continue;
                dfs(end, path + newChar, cost + newCost);
            }
        }
    }

    public String bestPath = "";
    public int bestCost = Integer.MAX_VALUE;

    public static void main(String[] args) {
        TrainMap g = new TrainMap();

        g.dfs("C", "A", 0); // 8 
//      g.dfs("B", "B", 0); // 9

        System.out.println("Best Path: " + g.bestPath + "\nCost: " + g.bestCost);
    }
}

10:

public class TrainMap {

    public int[][] map = { 
            {-1, 5, -1, 5, 7}, 
            {-1, -1, 4, -1, -1},
            {-1, -1, -1, 8, 2},
            {-1, -1, 8, -1, 6},
            {-1, 3, -1, -1, -1},
    };
    
    public void dfs(String end, String path, int cost) {
        if (cost >= 30)
            return;

        if (cost > 0 && path.endsWith(end)) {
            System.out.println(path + ", " + cost);
        }

        char lastChar = path.charAt(path.length() - 1);
        int lastNodeIndex = lastChar - 'A';

        for (int i = 0; i < map[lastNodeIndex].length; i++) {
            char newChar = (char) (i + 'A');
            int newCost = map[lastNodeIndex][i];
            if (newCost > 0) {
                dfs(end, path + newChar, cost + newCost);
            }
        }
    }

    public static void main(String[] args) {
        TrainMap g = new TrainMap();

        g.dfs("C", "C", 0);
    }
}