mojidong blog

关于

Sat, 13 Oct 2018 22:09:00 +0800

程序员一枚。

不断学习中。

mybatis批处理(batch)

Sun, 24 Mar 2019 06:54:17 +0800

最近一个老的项目从ibatis升级到了mybatis，之前的批处理方法需要在mybatis中重新实现。实际实现过程中发现并没有如ibatis类似的api需要一些特殊处理。下面来讲讲mybatis中实现批处理的方式。

sql处理方式

sql的处理方式批较简单，直接将对应的sql变成批量sql，如下：

批量插入

<insert id="batchInsert">
insert into 
    user(id, gmt_create, gmt_modified, username, age, sex, phone)
    values
    <foreatch item="user" collection="userList" separator=",">
    (#{user.id}, now(), now(), #{user.username}, #{user.age}, #{user.sex}, #{user.phone})
    </foreatch>
</insert>

批量更新

单行sql

<update id="batchUpdate">
update user set 
    age = #{age}
where id in 
    <foreatch item=id collection="idList" open="(" separator="," close=")">
    #{id}
    </foreatch>
</update>

多行sql

<update id="batchUpdate">
    <foreatch item=user collection="userList" separator=";">
    update user set 
        age = #{user.age},
        phone = #{user.phone}
    where 
        id = #{user.id}
    </foreatch>
</update>

批量删除

单行sql

<delete id="batchDelete">
delete from user 
where id in 
    <foreatch item=id collection="idList" open="(" separator="," close=")">
    #{id}
    </foreatch>
</update>

多行sql

<update id="batchUpdate">
    <foreatch item=id collection="idList" separator=";">
    delete from user where id = #{id}
    </foreatch>
</update>

多行sql需在mysql链接参数上增加allowMultiQueries=true

用sql批量处理方式存在局限性，最明显的是长度问题，另外就是in条件存在性能问题。

jdbc batch方式

ibatis中execute的回调api可以直接实现，底层使用的是jdbc的batch能力，代码如下：

public int batchUpdate(String statementId, List<Map<String, Object>> params) {
        
    return getSqlMapClientTemplate().execute(executor -> {

        int count = 0;
        int batchSize = 0;
        executor.startBatch();
        for (Map<String, Object> param : params) {
            executor.update(statementId, param);
            batchSize++;
            if (batchSize == 50) {
                count += executor.executeBatch();
                executor.startBatch();
                batchSize = 0;
            }
        }

        if (batchSize > 0) {
            count += executor.executeBatch();
        }

        return count;
    });
}

mybatis中不在提供execute这种api了，实际还是支持的但预要另外特殊处理下，代码如下：

@Autowired
private SqlSessionFactory sqlSessionFactory;

private SqlSession batchSqlSession;

@PostConstruct
public void init() {
    // 初始化批量处理的sql session
    batchSqlSession = new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
}

public int batchUpdate(String statementId, List<Map<String, Object>> params) {

    List<BatchResult> batchResults = new ArrayList<>();

    int batchSize = 0;
    for (Map<String, Object> param : params) {
        batchSqlSession.update(statementId, param);
        batchSize++;
        if (batchSize == 50) {
            batchResults.addAll(batchSqlSession.flushStatements());
            batchSize = 0;
        }
    }

    if (batchSize > 0) {
        batchResults.addAll(batchSqlSession.flushStatements());
    }

    return batchResults.stream().map(BatchResult::getUpdateCounts).flatMapToInt(Arrays::stream).sum();
}

这里的核心是初化一个BATCH的SqlSession，上面代码设置的BatcSize为50，你可以根据自已的情况进行调整，但这个值不建议过大，会导致游标过大的错误。

总结

单行sql这种方式比较简单直接针对sql进行处理即可，无需特殊编码，但是存在sql过长和性能问题。
jdbc batch这种方式需要额外的编码，但不存在sql过长和性能问题。

这里推荐jdbc batch方式，没有副作用，不存任何隐患。

笔者这里生产环境中3w数据的更新只需5s，未使用BATCH之前在15-20s左右。

thread pool中使用thread local的问题

Sat, 02 Mar 2019 20:58:56 +0800

最近发现生产环境一个十分诡异的问题，这里与大家分享一下。

问题

最近发现线上服务报错，报错是偶发的，会自动恢复。主体代码如下:

/**
 * Created by mojidong.
 */
public class Test {

    /**
     * 初始化线程池
     */
    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(128), (r, executor) -> r.run());


    public static void main(String[] args) throws Throwable {

        // 初始上下文
        BizContext.init();
        // 放入信息到上下文
        BizContext.putInfo("mainInfo", "main good");

        // 取出内部上下文用于下面投传到子线程中
        BizContext.InnerContext innerContext = BizContext.getContext();

        List<Callable<Object>>  callables = new ArrayList();
        for (int i = 0; i < 150; i++) {

            int taskCount = i;

            callables.add(() -> {

                // 子线程上下文用主线程内部上下文初始化
                BizContext.setContext(innerContext);

                // 放下信息到上下文中
                BizContext.putInfo("taskCount" + taskCount, taskCount);

                // 清除子线程上下文
                BizContext.clearContext();

                try {
                    TimeUnit.MICROSECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                return null;
            });
        }

        threadPool.invokeAll(callables);

        // 输出主线程上下文信息
        System.out.println("main thread context: " + BizContext.getContext());

        System.out.println(BizContext.getContext().get("mainInfo"));

        // 清除主线程上下文信息
        BizContext.clearContext();

        threadPool.shutdown();

    }


    /**
     * 业务上下文
     */
    static class BizContext {

        private static ThreadLocal<InnerContext> threadLocal = new ThreadLocal();

        public static void init() {
            threadLocal.set(new InnerContext());
        }

        public static void setContext(InnerContext innerContext) {
            threadLocal.set(innerContext);
        }

        public static InnerContext getContext() {
            return threadLocal.get();
        }

        public static void clearContext() {
            threadLocal.remove();
        }

        public static void putInfo(String key, Object object) {
            threadLocal.get().put(key, object);
        }

        public static Object getInfo(String key) {
            return threadLocal.get().get(key);
        }


        /**
         * 内部上下文
         */
        static class InnerContext {

            private Map<String, Object> map = new ConcurrentHashMap<>();

            public void put(String key, Object object) {
                map.put(key, object);
            }

            public Object get(String key) {
                return map.get(key);
            }

            @Override
            public String toString() {
                return map.toString();
            }
        }
    }
}

逻辑比较清淅，主要是使用ThreadLocal将上下文在主线程和子线程中传递。通过排查发现回到主线程后上下文被清空了，后续又有操作上下文的代码，所以抛了NPE。

1
2
3

// 这里输出是null
// 输出主线程上下文信息
System.out.println("main thread context: " + BizContext.getContext());

通过review代码并没有发现问题所在，主要是问题是偶发，并且之前很长的一段时间都没有问题，最近也未对这块代码作变更，最诡异的是它会随着时间的推移自动恢复，真是百思不得其解。

根源

通过对线上数据分析，发现任务数比较多的情况下大概率会出现该问题，也就是放入线程池中的任务多才会有问题。到了这里突然灵光乍现，肯定与任务队列溢出有关，立即查看线程池配置代码。

 /**
 * 初始化线程池
 */
private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES,
        new LinkedBlockingQueue<>(128), (r, executor) -> r.run());

任务队列是128，超过之后会触发RejectedExecutionHandler，这里的处理方式是：

`1`	`(r, executor) -> r.run()`

这个实际是直接在主线程中执行任务代码。到这里问题终于真相大白，由于任务在主线程中执行，所以任务本应该在子线程中清空上下文的操作实际是在主线程中执行了。

() -> {
    // 子线程上下文用主线程内部上下文初始化
    BizContext.setContext(innerContext);

    // 放下信息到上下文中
    BizContext.putInfo("taskCount" + taskCount, taskCount);

    // 清除子线程上下文
    // 由于在主线程中执行实际是清空了主线程上下文
    BizContext.clearContext();

    try {
        TimeUnit.MICROSECONDS.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
})

所以上面代码BizContext.clearContext();实际是在主线程中执行的，所以主线程上下文就被清空了。

方案

知道了原因就很好处理：

去掉自定义的RejectedExecutionHandler，默的RejectedExecutionHandler是抛异常。
让任务不超过溢出队列长度。

按照上面的2条代码调整如下：

/**
 * Created by mojidong.
 */
public class Test {

    /**
     * 初始化线程池
     */
    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(128));


    public static void main(String[] args) throws Throwable {

        // 初始上下文
        BizContext.init();
        // 放入信息到上下文
        BizContext.putInfo("mainInfo", "main good");

        // 取出内部上下文用于下面投传到子线程中
        BizContext.InnerContext innerContext = BizContext.getContext();

        List<Callable<Object>>  callables = new ArrayList();
        for (int i = 0; i < 150; i++) {

            int taskCount = i;

            callables.add(() -> {

                // 子线程上下文用主线程内部上下文初始化
                BizContext.setContext(innerContext);

                // 放下信息到上下文中
                BizContext.putInfo("taskCount" + taskCount, taskCount);

                // 清除子线程上下文
                BizContext.clearContext();

                try {
                    TimeUnit.MICROSECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                return null;
            });
        }

        for(List<Callable<Object>> subCallables : Lists.partition(callables, 128)) {
            threadPool.invokeAll(subCallables);
        }


        // 输出主线程上下文信息
        System.out.println("main thread context: " + BizContext.getContext());

        System.out.println(BizContext.getContext().get("mainInfo"));


        BizContext.clearContext();

        threadPool.shutdown();

    }


    /**
     * 业务上下文
     */
    static class BizContext {

        private static ThreadLocal<InnerContext> threadLocal = new ThreadLocal();

        public static void init() {
            threadLocal.set(new InnerContext());
        }

        public static void setContext(InnerContext innerContext) {
            threadLocal.set(innerContext);
        }

        public static InnerContext getContext() {
            return threadLocal.get();
        }

        public static void clearContext() {
            threadLocal.remove();
        }

        public static void putInfo(String key, Object object) {
            threadLocal.get().put(key, object);
        }

        public static Object getInfo(String key) {
            return threadLocal.get().get(key);
        }


        /**
         * 内部上下文
         */
        static class InnerContext {

            private Map<String, Object> map = new ConcurrentHashMap<>();

            public void put(String key, Object object) {
                map.put(key, object);
            }

            public Object get(String key) {
                return map.get(key);
            }

            @Override
            public String toString() {
                return map.toString();
            }
        }
    }
}

主要是两处改动点

/**
 * 初始化线程池
 */
private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES,
        new LinkedBlockingQueue<>(128));

1
2
3

for(List<Callable<Object>> subCallables : Lists.partition(callables, 128)) {
    threadPool.invokeAll(subCallables);
}

总结

不使建使用在主线程执行的RejectedExecutionHandler即(r, executor) -> r.run()。
超出溢出队列可以切割任务来避免。

java增强型Thread Local, InheritableThreadLocal

Sun, 24 Feb 2019 10:28:30 +0800

最近使用InheritableThreadLocal遇到一些问题，这里总结一下。

Thread Local

ThreadLocal是绑定到线程上的上下文，他可以让你很方便的在同一个线程里进行上下文数据传递和共享，线程与线程之间的ThreadLocal是相互不可见的。

下面是一个简单的例子：

public class Test {


    public static void main(String[] args) throws Exception {

        AService aService = new AService();
        BService bService = new BService();

        new Thread(() -> {

            // 初始化线程上下文
            ThreadLocalContext.initContext();

            // 操作上下文
            aService.genNum();

            // 获取上下文信息
            bService.showNum();
        }).start();

        TimeUnit.SECONDS.sleep(5);
    }

    /**
     * 共享上下文
     */
    static class Context {

        private Integer num;

        public Integer getNum() {
            return num;
        }

        public void setNum(Integer num) {
            this.num = num;
        }
    }

    /**
     * 线程上下文
     */
    static class ThreadLocalContext {

        public static ThreadLocal<Context> threadLocal;

        public static void initContext() {
            threadLocal = new ThreadLocal<>();
        }

        public static void putContext(Context context) {
            threadLocal.set(context);
        }

        public static Context getContext() {
            return threadLocal.get();
        }
    }


    static class AService {

        public void genNum() {
            Context context = ThreadLocalContext.getContext();
            if (context == null) {
                context = new Context();
                context.setNum(0);
            }

            context.setNum(context.getNum() + 1);
            ThreadLocalContext.putContext(context);
        }
    }

    static class BService {
        public void showNum() {
            System.out.println(ThreadLocalContext.getContext().getNum());
        }
    }
}

从上面可以看到在多个service中通过Thread Local传递共享数据非常便利，不用显示的在现有service进行显示传递。这在一些场景中非常有用，例如对老旧系统的功能修改，可以做到不破坏原有服务接口签名。还有全链路埋点（分析统计、监控）可以做到解藕。

InheritableThreadLocal

简单来讲InheritableThreadLocal是ThreadLocal的增强版，它带了一项新的能力，子线程会拷贝父线程中ThreadLocal

之前用ThreadLocal我们都是这样做的：

public class Test {


    public static void main(String[] args) throws Exception {

        AService aService = new AService();
        BService bService = new BService();
        CService cService = new CService();

        // 初始化主线程上下文
        ThreadLocalContext.initContext();

        // 主线程中的逻辑，会操作主线程上下文
        cService.setNum();

        // 获取主线程中的上下文
        Context context = ThreadLocalContext.getContext();

        new Thread(() -> {

            // 子线上下文直接用主线程中的上下文创建
            ThreadLocalContext.setContext(context);

            // 操作上下文
            aService.genNum();

            // 获取上下文信息
            bService.showNum();
        }).start();

        TimeUnit.SECONDS.sleep(5);
    }

    /**
     * 共享上下文
     */
    static class Context {

        private Integer num;

        public Integer getNum() {
            return num;
        }

        public void setNum(Integer num) {
            this.num = num;
        }
    }

    /**
     * 线程上下文
     */
    static class ThreadLocalContext {

        public static ThreadLocal<Context> threadLocal;

        public static void initContext() {
            threadLocal = new ThreadLocal<>();
        }

        public static void setContext(Context context) {
            threadLocal = new ThreadLocal<>();
            threadLocal.set(context);
        }

        public static void putContext(Context context) {
            threadLocal.set(context);
        }


        public static Context getContext() {
            return threadLocal.get();
        }
    }


    static class AService {

        public void genNum() {
            Context context = ThreadLocalContext.getContext();
            if (context == null) {
                context = new Context();
                context.setNum(0);
            }

            context.setNum(context.getNum() + 1);
            ThreadLocalContext.putContext(context);
        }
    }

    static class BService {
        public void showNum() {
            System.out.println(ThreadLocalContext.getContext().getNum());
        }
    }

    static class CService {
        public void setNum() {
            Context context = new Context();
            context.setNum(1);
            ThreadLocalContext.putContext(context);
        }
    }

}

需要自已手动将主线程中的上下文传递到子线程中的ThreadLocal中。

下面我们来看看使用InheritableThreadLocal

public class Test {


    public static void main(String[] args) throws Exception {

        AService aService = new AService();
        BService bService = new BService();
        CService cService = new CService();

        // 初始化主线程上下文
        ThreadLocalContext.initContext();

        // 主线程中的逻辑，会操作主线程上下文
        cService.setNum();

        // 获取主线程中的上下文
        // Context context = ThreadLocalContext.getContext();

        new Thread(() -> {

            // 子线上下文直接用主线程中的上下文创建
            // ThreadLocalContext.setContext(context);

            // 操作上下文
            aService.genNum();

            // 获取上下文信息
            bService.showNum();
        }).start();

        TimeUnit.SECONDS.sleep(5);
    }

    /**
     * 共享上下文
     */
    static class Context {

        private Integer num;

        public Integer getNum() {
            return num;
        }

        public void setNum(Integer num) {
            this.num = num;
        }
    }

    /**
     * 线程上下文
     */
    static class ThreadLocalContext {

        public static InheritableThreadLocal<Context> threadLocal;

        public static void initContext() {
            threadLocal = new InheritableThreadLocal<>();
        }


        public static void setContext(Context context) {
            threadLocal = new InheritableThreadLocal<>();
            threadLocal.set(context);
        }

        public static void putContext(Context context) {
            threadLocal.set(context);
        }


        public static Context getContext() {
            return threadLocal.get();
        }
    }


    static class AService {

        public void genNum() {
            Context context = ThreadLocalContext.getContext();
            if (context == null) {
                context = new Context();
                context.setNum(0);
            }

            context.setNum(context.getNum() + 1);
            ThreadLocalContext.putContext(context);
        }
    }

    static class BService {
        public void showNum() {
            System.out.println(ThreadLocalContext.getContext().getNum());
        }
    }

    static class CService {
        public void setNum() {
            Context context = new Context();
            context.setNum(1);
            ThreadLocalContext.putContext(context);
        }
    }

}

可以看到主动转递上下文的过程省去了，InheritableThreadLocal会自动搞定。

问题

InheritableThreadLocal看起来很美，但实际使用下来发现了几个问题：

拷贝ThreadLocal是在子线程创建的时候，所以线程池中ThreadLocal后续不拷贝主线程的ThreadLocal，因为线程池中大多数情况下线程是复用的，重新建的情况很少。
当初创建子线程的主线程如果清除ThreadLocal子线程中的ThreadLocal也会被清除。

下面是验证代码：

public class Test {

    static ExecutorService executorService = Executors.newFixedThreadPool(1);

    static AService aService = new AService();
    static BService bService = new BService();
    static CService cService = new CService();


    public static void main(String[] args) throws Throwable {

        // 第一次执行
        test();
        TimeUnit.SECONDS.sleep(1);
        
        // 第二次执行
        test();
        TimeUnit.SECONDS.sleep(1);

    }

    private static void test() {
        
        new Thread(() -> {

            // 初始化主线程上下文
            ThreadLocalContext.initContext();

            // 主线程中的逻辑，会操作主线程上下文
            cService.setNum();

            executorService.submit(() -> {


                // 操作上下文
                aService.genNum();

                // 获取上下文信息
                bService.showNum();
            });

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }

            ThreadLocalContext.clear();


        }).start();

    }

    /**
     * 共享上下文
     */
    static class Context {

        private Integer num;

        public Integer getNum() {
            return num;
        }

        public void setNum(Integer num) {
            this.num = num;
        }
    }

    /**
     * 线程上下文
     */
    static class ThreadLocalContext {

        public static InheritableThreadLocal<Context> threadLocal;

        public static void initContext() {
            threadLocal = new InheritableThreadLocal<>();
        }


        public static void setContext(Context context) {
            threadLocal = new InheritableThreadLocal<>();
            threadLocal.set(context);
        }

        public static void putContext(Context context) {
            threadLocal.set(context);
        }


        public static Context getContext() {
            return threadLocal.get();
        }

        public static void clear() {
            threadLocal.remove();
        }
    }


    static class AService {

        public void genNum() {
            Context context = ThreadLocalContext.getContext();
            if (context == null) {
                context = new Context();
                context.setNum(0);
            }

            context.setNum(context.getNum() + 1);
            ThreadLocalContext.putContext(context);
        }
    }

    static class BService {
        public void showNum() {
            System.out.println(ThreadLocalContext.getContext().getNum());
        }
    }

    static class CService {
        public void setNum() {
            Context context = new Context();
            context.setNum(1);
            ThreadLocalContext.putContext(context);
        }
    }

}

总结

总是优先使用ThreadLocal。
在使用线程池的情况下应避免使用InheritableThreadLocal。

java排序违返规约错误

Sat, 23 Feb 2019 20:33:39 +0800

问题

最近发现线上一段大半年都没有变动的代码报错。错误栈如下：

Exception in thread "main" java.lang.IllegalArgumentException: Comparison method violates its general contract!
	at java.util.TimSort.mergeHi(TimSort.java:899)
	at java.util.TimSort.mergeAt(TimSort.java:516)
	at java.util.TimSort.mergeCollapse(TimSort.java:441)
	at java.util.TimSort.sort(TimSort.java:245)
	at java.util.Arrays.sort(Arrays.java:1438)
	at java.util.Arrays$ArrayList.sort(Arrays.java:3895)

通过日志定位代码发现为排序报错

list.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 > o2 ? 1 : -1;
    }
});

很奇怪这代码为什么会报错，之前的排序好像都是这样写的并没有问题。

原因

根据日志错误信息Comparison method violates its general contract!通过google查询发现是违反了排序规约，原来从java7开始针对排序进行了更严格的限制。

sgn(compare(x, y)) == -sgn(compare(y, x))
((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0
compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z))

简单来说就是违反了自反性和传递性。

到这里问题的原因基本定位了，前不久将应用jdk6升级到了8, 那为什么大半年了才暴露出来。

扒了一下源码发现只有在排序元素大于32才会有机率出现此错误。

所以这也解释了为什么升级jdk8后大半年没有报错。

下面是一段测试代码:

public static void main(String[] args) throws Exception {
    while (true) {
        List<Integer> list = new ArrayList<>();
        while (list.size() < 32) {
            list.add(new Random().nextInt(100));
        }

        System.out.println("list:" + list);

        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 > o2 ? 1 : -1;
            }
        });
    }
}

有兴趣的同学可以自已研究一下源码。

解决方案

1. 实现规约的限制

拿开的代码头来说，o1 == o2和o1 = null, o2 = null的case没考虑，所以导致违反了自反性和传递性。正确的代码如下：

list.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        
        if(o1 == null && o2 == null) {
            return 0;
        }
        
        if(o1 == null) {
            return -1;
        }
        
        if(o2 == null) {
            return 1;
        }
        
        if(o1 == o2) {
            return 0;
        }
        
        return o1 > o2 ? 1 : -1;
    }
});

2. 降级排序算法为java7之前的版本

代码里设置系统变量降级

`1`	`System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");`

jvm启动参数增加降级参数

`1`	`-Djava.util.Arrays.useLegacyMergeSort=true`

可根据自身的实际情况来选则降级方案，这只是临时修复方案，应尽量改为更为严谨的排序算法。

迁移博客到hugo

Sun, 14 Oct 2018 12:53:58 +0800

这两天把blog从jekyll迁移到了hugo。下面是hugo对自已的简介：

The world’s fastest framework for building websites.

Hugo is one of the most popular open-source static site generators. With its amazing speed and flexibility, Hugo makes building websites fun again.

这里记录下期间遇到的问题

代码高亮
这里花了一点时间，按照文档进行高亮风格设置之后发现显示有问题，最后发现是选用主题之后高亮风格只能随主题走。这个坑是最后查看主题的repo才发现的，建议大家遇到问题的时候查看选用的主题文档和repo。
历史链接
尝试将文章链接调整为原blog一样，这样外链和搜索引擎还可以正常工作，结果不幸的是hugo的Permalinks支持有限调支持不了之前的url模式。查看文档发现可以用aliases对老的url进行重定向。这种方式比较繁琐需要每个页面都去设置一遍。

整体来讲迁移过程还算比较顺历。

zsh autosuggestions在tmux环境下高亮问题处理

Sun, 14 May 2017 00:00:00 +0000

问题

最近在尝试使用zsh-autosuggestions插件，在tmux中发现提示的高亮效果无效这里记录下解决方法。

现象如下：

在终端下zsh_ autosuggestions 正常工作，提标高亮正常。
在tmux下zsh autosuggestions 正常工作，提标高亮不正常（*提示为白色，不是正常的浅灰色*）。

处理

首先在网上查了一下好像没有对应的处理方法，官方的issue也有人提到了相同的问题但是也没有给出相应的解决方案。无耐只好自已动手解决。

首先想到的就是zsh_ autosuggestions 的提标色在tmux环境可能没有生效，查了一下zsh autosuggestions 的文档发现ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE可以控制高亮顔色。直接在tmux环境设置该配置

`1`	`$ ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE="fg=1"`

发现没有效果。难道是配置不正确，直接打开新的终端进行验证，发现顔色可改变配置应该是没有问题。

这时突然相到是不是终端的类型导致的，直接查看tmux环境的终端类型

1
2

$ env | grep TERM
TERM=screen

果然是这样。在看一下终端环境下的类型

1
2

$ env | grep TERM
TERM=xterm-256color

到这里基本就说明了为什么终端环境下高亮提示正常而在tmux环境不正常了。在tmux环境更改终端类型

`1`	`export TERM=xterm-256color`

果然高亮提示正常了。

方案

直接在.zshrc中加TERM配即可

`1`	`$ echo "export TERM=xterm-256color" >> ~/.zshrc`

注：MacOS iTerm2 可能还须要修改iTerm2配置Preferences -> Profile -> Terminal -> Report Terminal Type : xterm-256color

socket5 协议学习与实现(二)

Mon, 01 Feb 2016 00:00:00 +0000

今天我们就来实现一下socket5的tcp代理。根据之前的学习我们了解到建立socket5代理需要三个阶段

下面我们使用golang来实现它。

第一阶段：验证

这里为了简单我们使用无须校验的方式，下面是部分代码

buf := make([]byte, 1024)

// 协议校验......省略

len, err = c.Write([]byte{0x05, 0x00})
if len != 2 || err != nil  {
    println("[parse protol] write data fail!")
    return
}

这里因为是用无校验的方式，所以直接返回给客户端0x05,0x00 报文

第二阶段：建立代理链接

客户端收到代理服务器验证通过的响应报文(0x05,0x00)之后会发送需要代理的目标地址信息到代理服务器,代理服务器解析报文获得目标地址信息建立代理链接。

len, err = c.Read(buf)

// 协议校验......省略


// 解析报文中的地址信息，这里只解析ipv4和domain两种地址信息
var ip string
var port int
switch buf[3] {
    case 0x01: // ip
        ip = net.IPv4(buf[4], buf[5], buf[6], buf[7]).String()
        port = int(buf[len-2:][0])<<8 | int(buf[len-2:][1])
    case 0x03: // domain
        ip = string(buf[4 : len-2])
        port = int(buf[len-2:][0])<<8 | int(buf[len-2:][1])
}

addr := net.JoinHostPort(ip, strconv.Itoa(port))
println("start proxy:",addr)

r, err := net.Dial("tcp", addr) // 建立代理链接
if err != nil {
    println("connect proxy addr fail!", err.Error())
    return
} 

len, err = c.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) // 返回报文告诉客户端代理链接建立成
if len != 10 || err != nil  {
    println("[parse protol] write data fail!",err.Error())
    return
}

注意：

这里没有实现ipv6

经过我多次验证发现客户端并不关心返回报文中的地址信息所以我这里全部设为0x00,你也可以设为其他值

第三阶段：数据转发

这里就简单多了，直接将客户端的数据包转发到目标服务器，在将目标服务器的数据包转发给客户端

// 数据包转发函数
func forward(c, r net.Conn, buf []byte) {
    defer c.Close()
    defer r.Close()

    for {
        len, err := c.Read(buf)
        if len <= 0 || (err != nil && err != io.EOF) {
            break
        }

        len, err = r.Write(buf[0:len])
        if len <= 0 || err != nil  {
            break
        }
    }
}

// 使用上面函数转发数据包, c代表client链接，r代表remote链接
go forward(c, r, buf)
go forward(r, c, buf)

注意：因为我们无法得知客户端发给目标服务器数据包的长度和目标服务器返回给客户端数据包的长度（因为不知道传输的数据包具体协议所以无法得知长度），所以我们要使用协程对这两个链路上的数据包进行无限转发。

下面是完整的源码，写得比较简单没有太多校验，主要是为了帮助理解。只实现了tcp代理，udp部分比较复杂没有实现，有时间在弄。

package main

import (
        "io"
        "net"
        "strconv"
        "log"
       )

func println(s...interface{}){
    log.Println(s...) 
}

func parseProtocol(c net.Conn) {

    buf := make([]byte, 1024)

    len, err := c.Read(buf)
    if len == 0 || err != nil {
        println("[parse protol] read data fail!")
        return
    }

    if buf[0] != 0x05 {
        println("[parse protol] illegal data!")
        return
    }

    len, err = c.Write([]byte{0x05, 0x00})
    if len != 2 || err != nil  {
        println("[parse protol] write data fail!")
        return
    }

    len, err = c.Read(buf)
    if len == 0 || err != nil {
        println("[parse protol] read data fail!")
        return
    }

    if buf[0] != 0x05 || buf[1] != 0x01 {
        println("[parse protol] illegal data!")
        return
    }

    var ip string
    var port int
    switch buf[3] {
        case 0x01:
            ip = net.IPv4(buf[4], buf[5], buf[6], buf[7]).String()
            port = int(buf[len-2:][0])<<8 | int(buf[len-2:][1])
        case 0x03:
            ip = string(buf[4 : len-2])
            port = int(buf[len-2:][0])<<8 | int(buf[len-2:][1])
    }

    addr := net.JoinHostPort(ip, strconv.Itoa(port))
    println("start proxy:",addr)

    r, err := net.Dial("tcp", addr)
    if err != nil {
        println("connect proxy addr fail!", err.Error())
        return
    }

    len, err = c.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
    if len != 10 || err != nil  {
        println("[parse protol] write data fail!",err.Error())
        return
    }

    go forward(c, r, buf)
    go forward(r, c, buf)

}

func forward(c, r net.Conn, buf []byte) {
    defer c.Close()
    defer r.Close()

    for {
        len, err := c.Read(buf)
        if len <= 0 || (err != nil && err != io.EOF) {
            break
        }

        len, err = r.Write(buf[0:len])
        if len <= 0 || err != nil  {
            break
        }
    }
}


func main() {
    in, err := net.Listen("tcp", ":8080")
    if err != nil {
        println("bind 8080 fail!",err.Error())
        return
    }
    println("start server ok. listen port 8080")
    for {
        c, err := in.Accept()
        if err != nil {
            println("accept fail!",err.Error())
            continue
        }
        go parseProtocol(c)
    }
}

vpn的iptables配置

Mon, 01 Feb 2016 00:00:00 +0000

之前配置vpn在配置iptables这一块遇到一些问题这里总结一下。

我的iptables配置如下

iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 1723 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 6000 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 61234 -j ACCEPT
iptables -t nat -A PREROUTING ! -s 192.168.10.0/24 -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 6000
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -j MASQUERADE

配置完成后vpn连接成功。

socket5 协议学习与实现(一)

Sat, 07 Mar 2015 00:00:00 +0000

最近研究了下socket5协议,它是一个tcp、udp的代理协议(socket4不支持udp),大部分软件都支持socket5代理。

一般来说要建立起一个代理的连接要经过三个阶段。

阶段一: 验证

客户端告诉代理服务器自已支持的验证方式，可以有多种验证方式。

+---------+-----------------+------------------+
|协议版本  | 支持的验证式数量   | 验证方式          |
+---------+-----------------+------------------+
|1个字节   | 1个字节          | 1种式占一个字节    |
+---------+-----------------+------------------+
|0x05     |0x02             |0x00,0x02         |
+---------+-----------------+------------------+

上面例子，客户端告诉代理服务器自已支持两种验证方式。

0x00 无验证需求

0x01 通用安全服务应用程序接口(GSSAPI)

0x02 用户名/密码(USERNAME/PASSWORD)

0x03 至 X’7F’ IANA 分配(IANA ASSIGNED)

0x80 至 X’FE’ 私人方法保留(RESERVED FOR PRIVATE METHODS)

0xFF 无可接受方法(NO ACCEPTABLE METHODS)

代理服务器收到上面的报文，选择自已所能支持的验证方式,并返回相应的数所包

+----------+------------------+
|协议版本   |  支持的验证方式     |
+----------+------------------+
|1个字节    |  1个字节          |
+----------+------------------+
|0x05      |  0x00            |
+----------+------------------+

上面例子，服务端告诉客户端不需要验证。 > 注：如果代服务器不支持客户凋端给出的所有验证方式则代理服务器返回的验证方式为0xFF,即表示无可验证的方式, 客户端收到该报文后必須要关闭当前连接。

除了无需验证，其它的验证方式还需要子协议来进行验证。这里我们用0x02来举例，即用户/密码这种验证方式，这个也是用得最多的。

当客户端收到代理服务器支持0x02验证方式（用户密码验证），客户端要发送用户密码给代理服务器

+--------+-----------+-------------------------+---------+-------------------------------+
|协议版本 | 用户名长度  |用户名                    | 密码长度 |  密码                          |
+--------+-----------+-------------------------+---------+-------------------------------+
|1个字节  | 1个字节    |用户名字节数据             | 1个字节  |  密码字节数据                   |
+--------+-----------+-------------------------+---------+-------------------------------+
|0x01    | 0x05      |0x70,0x61,0x6b,0x6f,0x72 | 0x06    |  0x31,0x32,0x33,0x34,0x35,0x36|
+--------+-----------+-------------------------+---------+-------------------------------+

上面的例子用户名为pakor对应的字节长度为5,密码为12345对应的字节数为6。 > 注：这里的协议版本是子协议版本不是socket5的协议版本。 > 目前用户名/密码验证这个子议的版本是0x01

代理服务器接收到客户端的用户名和密码进行验证，然后返回验证状态。
1 2 3 4 5 6 7

+--------+-------+ |协议版本 |状态 | +--------+-------+ |1个字节 |1个字节 | +--------+-------+ |0x01 |0x00 | +--------+-------+
如果验证成功则返回装态0x00,否则返回任何非0x00的值。客户端收到未成功验的状态必须关闭当前连接。

更多关于用户名／密码子协议信息请参看rfc1929

阶段二：建立代理连接

完成了校验过程接下来就是让代理服务器建立代理连接。

客户端发送要建立的的代理连接的地址及端口，地址可以是域名、IPv4、IPv6。

+----------+------------+---------+-----------+-----------------------+------------+
|协议版本号  | 请求的类型  |保留字段   |  地址类型  |  地址数据              |  地址端口    |
+----------+------------+---------+-----------+-----------------------+------------+
|1个字节    | 1个字节     |1个字节   |  1个字节   |  变长                  |  2个字节    |
+----------+------------+---------+-----------+-----------------------+------------+
|0x05      | 0x01       |0x00     |  0x01     |  0x0a,0x00,0x01,0x0a  |  0x00,0x50 |
+----------+------------+---------+-----------+-----------------------+------------+

上面例子,客户端告诉代理服务器建立一个连接到10.0.1.10的80端口。这里的保留字段是固定的0x00。
地址类型有下面几种：

IPV4 : 0x01
域名 : 0x03
IPV6 : 0x04

请求类型有下面几种：

CONNECT : 0x01, 建立代理连接
BIND : 0x02,告诉代理服务器监听目标机器的连接,也就是让代理服务器创建socket监听来自目标机器的连接。FTP这类需要服务端主动联接客户端的的应用场景。

1. 只有在完成了connnect操作之后才能进行bind操作
2. bind操作之后，代理服务器会有两次响应, 第一次响应是在创建socket监听完成之后，第二次是在目标机器连接到代理服务器上之后。

UDP ASSOCIATE : 0x03, udp 协议请求代理。

注：UDP ASSOCIATE 时这里请求的地址和端口是告诉代理服务器客户端要使用这个地址发送数据到代理服务器。代理服务器可以用这个信息对访问进行一些限制。

代理服务器收到客户端的请求后，要创建到目标机器的连接或创建监听目标机器的socket,然后返回相应的信息

+----------+--------+---------+-----------+---------------------+------------+
|协议版本号  | 状态码  |保留字段  |  地址类型  |  绑定的地址           |顷绑定的端口  |   
+----------+--------+---------+-----------+---------------------+------------+
|1个字节    | 1个字节 |1个字节   |  1个字节   |  变长                |2个字节     |
+----------+--------+---------+-----------+---------------------+------------+
|0x05      | 0x00   |0x00     |  0x01     |  0x0a,0x00,0x01,0x0a|0x00,0x50   |
+----------+--------+---------+-----------+---------------------+------------+

上面的例子，代理服务器连接目标服务器10.0.1.10端口80成功。
状态码有下面几种：

X00 succeeded
X01 general SOCKS server failure
X02 connection not allowed by ruleset
X03 Network unreachable
X04 Host unreachable
X05 Connection refused
X06 TTL expired
X07 Command not supported
X08 Address type not supported
X09 to X’FF’ unassigned

绑定的地址和端口根据请求中的CMD的不同而不同

CONNECT : 此时绑定的地址是指代理服务器连接到目标机器时的ip和端口
BIND : 这里会有两次响应
- 第一次响应中是指代理服务器创建监听socket时绑定的ip和端口
- 第二次响应中是指代理服务器监听的scoket收来自目标机器连接时的ip和端口
UDP ASSOCIATE : 此时绑定地址指明了客户发送UDP消息至服务器的端口和地址

阶段三：数据包转发

到了这个阶段基本就是数据转发了,tcp就直接转发,udp还须要做点工作。

客户端发送给代理服务器和代理服务器返回给客户端的数据都需要包装下

+----+------+------+----------+----------+----------+
|RSV | FRAG | ATYP | DST.ADDR | DST.PORT |   DATA   |
+----+------+------+----------+----------+----------+
| 2  |  1   |  1   | Variable |    2     | Variable |
+----+------+------+----------+----------+----------+

RSV Reserved 0x00,0x00
- FRAG Current fragment number
- ATYP address type of following addresses:
  - IP V4 address: 0x01
  - DOMAINNAME: 0x03
  - IP V6 address: 0x04
- DST.ADDR desired destination address
- DST.PORT desired destination port
- DATA user data

详细文档参考rfc1928

设置action bar、action bar tab 样式及高度

Sat, 23 Aug 2014 00:00:00 +0000

android 3.0 引入了action bar,supper library支持2.1以上版本。

本文主要说下action bar样式的设置。

首先我们要使用action bar须要使用theme AppCompat

应用到全局

<application android:allowBackup="true"
        android:icon="@drawable/app"
        android:label="@string/app_name"
        android:theme="@style/Theme.AppCompat.Light" >
    ....
</application>

应用指定的activity

<activity android:name=".PagerActivity"
        android:theme="@style/CustomActionBarTheme" >
        android:parentActivityName=".MMActivity" >
        <meta-data android:name="android.support.PARENT_ACTIVITY" android:value="com.mojidong.mnt.MMActivity" />
    ....
</activity>

自定义action bar

前面说了要使用action bar必须用AppCompat这个theme,所以要修改样式我们就须要继承AppCompat，覆盖相应属性。

在styles.xml里加入

<!-- 继承AppCompat.Light，覆盖actionBarStyle -->
<style name="CustomActionBarTheme" parent="@style/Theme.AppCompat.Light">
    <item name="android:actionBarStyle">@style/BarStyle</item>

    <!-- Support library compatibility -->
    <item name="actionBarStyle">@style/BarStyle</item>
</style>

<!-- 继承AppCompat.ActionBar，覆盖background，titleTextStyle -->
<style name="BarStyle" parent="@style/Widget.AppCompat.ActionBar">
    <item name="android:background">@android:color/black</item>
    <item name="android:titleTextStyle">@style/TitleTextStyle</item>

    <!-- Support library compatibility -->
    <item name="titleTextStyle">@style/TitleTextStyle</item>
</style>

<!-- 继承AppCompat.Title，覆盖textColor -->
<style name="TitleTextStyle" parent="@style/TextAppearance.AppCompat.Widget.ActionBar.Title">
    <item name="android:textColor">#fff</item>
</style>

上面例子修改了默认的背景色和标题顔色，更多属性请参见这里。

自定义action bar tab

在上例中修改

<!-- 继承AppCompat.Light，覆盖actionBarStyle -->
<style name="CustomActionBarTheme" parent="@style/Theme.AppCompat.Light">
    <item name="android:actionBarStyle">@style/BarStyle</item>
    <item name="android:actionBarTabStyle">@style/TabStyle</item>
    <item name="android:actionBarTabTextStyle">@style/TabTextStyle</item>
    <item name="android:actionBarSize">50dp</item>

    <!-- Support library compatibility -->
    <item name="actionBarStyle">@style/BarStyle</item>
    <item name="actionBarTabStyle">@style/TabStyle</item>
    <item name="actionBarTabTextStyle">@style/TabTextStyle</item>
    <item name="actionBarSize">50dp</item>
</style>

<!-- 继承AppCompat.ActionBar，覆盖background，titleTextStyle -->
<style name="BarStyle" parent="@style/Widget.AppCompat.ActionBar">
    <item name="android:background">@android:color/black</item>
    <item name="android:titleTextStyle">@style/TitleTextStyle</item>

    <!-- Support library compatibility -->
    <item name="titleTextStyle">@style/TitleTextStyle</item>
</style>

<!-- 继承AppCompat.Title，覆盖textColor -->
<style name="TitleTextStyle" parent="@style/TextAppearance.AppCompat.Widget.ActionBar.Title">
    <item name="android:textColor">#fff</item>
</style>

<!-- 继承TabView，覆盖background -->
<style name="TabStyle" parent="@style/Widget.AppCompat.ActionBar.TabView">
    <item name="android:background">@android:color/black</item>
</style>

<!-- 继承TabText，覆盖textColor -->
<style name="TabTextStyle" parent="@style/Widget.AppCompat.ActionBar.TabText">
    <item name="android:textColor">#fff</item>
</style>

修改action bar tab高度须要设置actionBarSize，然而不幸的是这个属性具然是同时调整action bar和action bar tab的高度，没有办法做到分别调整。

加点效果

我们还可以给action bar tab 加上点效果在drawable下创建文件action_bar_selector.xml,action_bar_tab.xml

action_bar_tab_selector.xml内容如下:

<?xml version="1.0" encoding="utf-8"?>

<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_focused="false" android:state_selected="false" android:state_pressed="false" android:drawable="@color/tab_color"/>
    <item android:state_focused="false" android:state_selected="true" android:state_pressed="false" android:drawable="@drawable/action_bar_tab.xml"/>

    <item android:state_selected="true" android:state_pressed="true" android:drawable="@drawable/action_bar_tab"/>
</selector>

action_bar_tab.xml如下:

<?xml version="1.0" encoding="utf-8"?>

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:top="-5dp" android:left="-5dp" android:right="-5dp">
        <shape android:shape="rectangle">
            <stroke android:color="#ff4ba587" android:width="5dp"/>
            <gradient android:startColor="@color/tab_color" android:endColor="@color/tab_color"/>
        </shape>
    </item>
</layer-list>

在values在创建colors.xml内容如下：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="tab_color">#dc222222</color>
</resources>

让我们的效果生效，修改之前style

......

<!-- 继承TabView，覆盖background -->
<style name="TabStyle" parent="@style/Widget.AppCompat.ActionBar.TabView">
    <item name="android:background">@drawable/action_bar_tab_selector</item>
</style>

......

使用自定义主题

应用到全局

<application android:allowBackup="true"
        android:icon="@drawable/app"
        android:label="@string/app_name"
        android:theme="@style/CustomActionBarTheme" >
    ....
</application>

应用指定的activity

<activity android:name=".PagerActivity"
        android:parentActivityName=".MMActivity" >
        android:theme="@style/CustomActionBarTheme" >
        <meta-data android:name="android.support.PARENT_ACTIVITY" android:value="com.mojidong.mnt.MMActivity" />
    ....
</activity>

linux防火墙iptables详解(二)

Sun, 06 Jul 2014 00:00:00 +0000

之前讲解了iptables基本语法和用法，今天详细讲下iptables规则链的整个执行流程。

规则链执行流程

先上一张图（借用下鸟哥的图）

从上图可以很清晰的看到数据包在规则链中的流动路径:

数据包先经过mangle表的PREROUTING链,然后进入nat表的PREROUTING链,然后路由进行判定:
1. 如果目标是本机则进入mangle表的INPUT链,在进入filter表的INPUT链到达本机（应用层接受数据), 最后数据经由mangle表的OUTPUT链,nat表OUTPUT链,filter表OUTPUT链
2. 如果目标不是本机且开启了forward则数据包进入mangle表FORWARD链,然后到filter表FORWARD链
最终都到达mangle表POSTROUTING链,经过nat表POSTROUTING链传出

根据上图的数据包的流动情况现在我们可以很容易的添加规则到对应的链路来满足我们的需求,下面是我们常用的一些场景:

修改数据包的来源ip地址及端口可以在nat表的PREROUTING链添加规则
过滤未授权及非法ip来源及端口的数据包到达本机可以在filter表的INPUT链添加规则
过滤未授权及非法ip来源及端口的数据包forward可以在filter表的FORWARD链添加规则
修改出口数据包的ip地址及端口可以在nat表的POSTROUTING表添加规则(充当代理服务器)

一般来说我们接触并使用最多的是filter表的INPUT链和nat表的PREROUTING,POSTROUTING链

下面是一些简单的列子

iptables -i lo -j ACCEPT #开放loopback (就是对127.0.0.1的访问)
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT #对新的链接或与现有链接有关联，已经建立的链接的数据包开放
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT # 开放icmp type 为8的数据包可以到达本机
iptables -A INPUT -p tcp -m tcp --dport 22 -j ACCEPT # 开放本机22端口
iptables -A INPUT -s 192.168.1.0/24 -p tcp -m tcp --dport 22 -j ACCEPT #对来源ip在192.168.1.1~254范围开放22端口
iptables -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT # 开放本机的80端口
iptables -t nat -A POSTROUTING -j MASQUERADE # 从本机出去的数据包源ip更改为本机（一般是作为路由）
iptables -t nat -A PREROUTING -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 6000 # 把访问本机80端口数据包重定向到6000端口

实战

需求：

开放本机的22端口只允许ip为172.30.22.11的ip可以访问
http服务器只监听了6000端口,要求通过80端口可以访问到
禁止在192.168.2.1~192.168.2.254范围内的ip访问80端口
可以从内部访问外网
本机可以作路由使用使用

根据上述要求结合前面学到的只是我们马上写下了如下code

iptables -P INPUT ACCEPT   #设置filter表INPUT链的默认行为为ACCEPT
iptables -P OUPUT ACCEPT   #设置filter表OUTPUT链的默认行为为ACCEPT
iptables -F                #删除filter表所有规则
iptables -X                #删除filter表所有自定义的链
iptables -Z                #清空包计数器
iptables -A INPUT -s 172.30.22.11 -p tcp -m tcp --dport 22 -j ACCEPT
iptables -t nat -A PREROUTING -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 6000 # 把访问本机80端口数据包重定向到6000端口

最后更改默认规则为DROP

`1`	`iptables -P INPUT DROP`

测试发现需求1满足了，需求2没有，访问80端口无响应。这是为什么呢？

回头看看图,原来后面还有filter的INPUT链没作处理,加入如下规则

1
2

iptables -A INPUT -p tcp -m tcp --dport 80 -J ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 6000 -J ACCEPT

测试ok

要满足3我们需要改下之前的规则,如下

`1`	`iptables -A INPUT -s ! 192.168.1.0/24 -p tcp -m tcp --dport 80 -j ACCEPT`

测试ok

在服务器上访问外网发现不行,显然4没有满足,回头看图发现OUTPUT这一条路是通的没有问题,数据包是传出去了(可以通过tcpdump抓包验证),问题发生在回来的时候数据包被挡在了外面。

分析发现服务器访问外网发起请求会随机分配一个端口(tcp特性)，外网服务回传的的数据包会回应到这个端口,而我们前面就开了80和6000其他端口都是被拒绝的

原因知道了但是发现不好改啊，端口是随机的。看来只能换一个思路,我们可以根据链接状态来判定

`1`	`iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT #对新的链接或与现有链接有关联，已经建立的链接的数据包开放`

测试ok

现在整个规则如下

iptables -P INPUT ACCEPT   #设置filter表INPUT链的默认行为为ACCEPT
iptables -P OUPUT ACCEPT   #设置filter表OUTPUT链的默认行为为ACCEPT
iptables -F                #删除filter表所有规则
iptables -X                #删除filter表所有自定义的链
iptables -Z                #清空包计数器
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 172.30.22.11 -p tcp -m tcp --dport 22 -j ACCEPT
iptables -A INPUT -s ! 192.168.1.0/24 -p tcp -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -s -p tcp -m tcp --dport 6000 -j ACCEPT
iptables -t nat -A PREROUTING -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 6000 # 把访问本机80端口数据包重定向到6000端口
iptables -P INPUT DROP

需求5嘛就留个坑吧!

linux防火墙iptables详解(一)

Sun, 17 Nov 2013 00:00:00 +0000

今天详细讲下linux防火墙iptables。

1.表和链

iptables有如下几个表：

mangle表主要功能是修改数据包
nat表主要用来修改包的源地址和目标地址
filter表主要用来对包进行过滤

对于mangle一般不建议使用，会出现一些意想不到的问题，如果你愿意完全可以忘掉mangle的存在，后面主要围绕nat和filter讲解。

1.1 mangle

说了忘掉的。

1.2 nat

nat有如下几条链

PREROUTING 对进来的包进行处理
POSTROUTING 对出去的包进行处理
OUTPUT 对本地产生的出去的包进行处理

1.3 filter

filter有如下几条链

INPUT 对进来得包进行处理
OUTPUT 对出去的包进行处理
FORWARD 对转发的包进行处理

2.规则

一条规则一定是挂在某条链上的，一条链一定是挂在某张表上的，所以一条规则一定是挂在某张表的某条链上的。

table
  |
  ---chain
    	|
  		---rule

2.1 语法

新增一条规则需要使用iptables命令（需要root权限）。

我们先来看下iptables的基本语法

iptables [-t table] {-A|-D} chain rule-specification           #添加或删除规则

iptables [-t table] -I chain [rulenum] rule-specification      #插入规则

iptables [-t table] -R chain rulenum rule-specification        #替换规则

iptables [-t table] -D chain rulenum                           #删除规则

iptables [-t table] -S [chain [rulenum]]                       #列出某条链下的规则

iptables [-t table] {-F|-L|-Z} [chain [rulenum]] [options...]  #-F删除规则，-L列出规则，-Z清空数据包计数

iptables [-t table] -N chain                                   #创建链，一般用于自定义链

iptables [-t table] -X [chain]					                #删除链

iptables [-t table] -P chain target			                #设置链的默认行为

iptables [-t table] -E old-chain-name new-chain-name          #编辑规则

rule-specification = [matches...] [target]                    #规则语法

match = -m matchname [per-match-options]                      #规则语法matches部分

target = -j targetname [per-target-options]                   #规则语法target部分

参数table是可选的，如果没有设置table默认则是filter。

2.2 初始化

在添加规则之前我们一般会初始化防火墙

iptables -P INPUT ACCEPT   #设置filter表INPUT链的默认行为为ACCEPT
iptables -P OUPUT ACCEPT   #设置filter表OUTPUT链的默认行为为ACCEPT
iptables -F                #删除filter表所有规则
iptables -X                #删除filter表所有自定义的链
iptables -Z                #清空包计数器

这里有个值得注意的地方就是一定要记得设置filter的INPUT,OUTPUT的默认行为为ACCEPT,因为如果不设置，后面的命令把所有规则删除了，这个时候就会走到链的默认行为，如果之前的默认行为是DROP或REJECT那就会把自己挡在外面（假定你是ssh登录），到时候真是欲哭无泪。

2.3 添加规则

1
2
3

iptables [-t table] -A chain rule-specification 
rule-specification = [matches...] [target] 
target = -j targetname [per-target-options]

根据上面的语法我们得知规则就是matches和target。

一旦matches成功就执行后面的target，如果不成功则继续下一条规则。

例如开放22端口

`1`	`iptables -A INPUT -p tcp -m tcp --dport 22 -j ACCEPT`

这里的matches就是-p tcp -m tcp --dport 22，target就是-j ACCEPT

target比较常用的有ACCEPT,DROP,REJECT

我们还可以修改matches以达到更精确的控制

`1`	`iptables -A INPUT -s 192.168.1.0/24 -p tcp -m tcp --dport 22 -j ACCEPT`

上面命令仅当网段是192.168.1.1-225的ip访问22端口时才会匹配，所以你可以不断调整你的matches来达到你的目的。

说到这里你可能会有疑问了，如果所有的规则都没匹配上怎么办。还记得之前说的链的默认规则吗？

我们之前把INPUT设置为了ACCEPT，之所以把它设置为ACCEPT是为了避免我们设置规则的时候把自己关在外面，当你把所有规则设置好之后确认没有任何问题之后记得把它设置为DROP，这个时候你的防火墙才真真正正有效了。

`1`	`iptables -P INPUT DROP`

linux防火墙iptable使用简介

Tue, 12 Nov 2013 00:00:00 +0000

iptables是Linux上常用的防火墙软件。这里简单介绍下怎么使用，依葫芦画瓢就可以了，对于懒人来说足够了。如果你想更详细的了解iptables,以后会详细的讲解。

iptables命令要在root下执行

初始化防火墙

iptables -P INPUT ACCEPT    # 设置INPUT chain默认行为为接受
iptables -P OUTPUT ACCEPT   # 设置OUTPUT chain默认行为为接受
iptables -P FORWARD ACCEPT  # 设置FORWARD chain默认行为为接受
iptables -F                 # 删除所有chain的rule
iptables -Z                 # 封包计数清零
iptables -X					# 删除所有自定义的chain

经过上述操作之后你的防火墙现在没有任何规则，也就说你的机器完全暴露在了网络之中，跟没穿衣服没两样。

新增规则

对于进来的封包过滤的规则都是在INPUT chain上设置的。

基本配置

iptables -A INPUT -i lo -j ACCEPT # 接受本地会回环（127.0.0.1）
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT # 接受已建立的   联建和与已建立的链接有关系的链接
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT # 接受回显请求的ping
iptables -A INPUT -p tcp -m tcp --dport 22 -j ACCEPT # 开放ssh端口

如果你的ssh端口不是22，请修改为你相应的端口。 ssh端口是一定要开放的，不然你就会把自己关在外面，到时候欲哭无泪哦。

端口配置

这里是重点了，开放端口的语法如下

1
2

iptables -A INPUT -p tcp -m tcp --dport 端口 -j ACCEPT
iptables -A INPUT -p tcp -m udp --dport 端口 -j ACCEPT

例如

1
2
3

iptables -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 3306 -j ACCEPT
iptables -A INPUT -p tcp -m udp --dport 3721 -j ACCEPT

要开放什么端口按这样加就好了

切换默认策略

把衣服穿起来

`1`	`iptables -P INPUT DROP # 设置INPUT chain默认行为为丢弃`

如果之前的规则一个都没匹配上最终这里的默认行为会触发。

查看规则

1
2
3

iptables -L -n
或者
iptables-save

个人比较喜欢用iptables-save

保存规则

如果你是redhat或centos

`1`	`service iptables save #保存规则`

如果是其他系统你可以利用iptables-save保存规则，iptables-restore恢复规则

1
2

iptables-save > /path/to/iptables   #将规则保存到指定文件中
iptables-restore /path/to/iptables  #将规则从之前的文件中恢复

chrome extension show ip

Tue, 05 Nov 2013 00:00:00 +0000

最近开发了一个chrome插件show ip用来显示请求页面的ip地址。

起因

最近经常会在测试环境和线上环境切换（修改host），由于chrome有dns缓存，以至于不确定是否已经切换到相应环境，chrome的开发工具网络里没有显示ip，又不想换firefox，于是到chrome store里寻找下看有没有相应的扩展，找了下还比较多，试用了几款感觉多多少少有点小问题，于是决定自己搞一个。

结果

经过一天的折腾就有了现在的show ip

当然源码是必须得猛戳这里

ruby字符串的encoding,force_encoding,encode,encode!

Sun, 19 May 2013 00:00:00 +0000

ruby1.9开始对字符串编码支持已经比较完善，我们可以直接通过使用String类的实例方法 encoding,force_encoding,encode,encode!进行相关的编码操作。

encoding

ruby1.9中为每个字符串对象增加了encoding信息

1
2
3

1.9.3p392 :001 > '我还是不懂'.encoding
 => #<Encoding:UTF-8> 
1.9.3p392 :002 >

force_encoding

某些情况下这个附加编码信息可能不正确我们可以修正它

1.9.3p392 :011 > x='我还是不懂'
 => "我还是不懂" 
1.9.3p392 :012 > x.encoding
 => #<Encoding:UTF-8> 
1.9.3p392 :013 > x.bytes.to_a
 => [230, 136, 145, 232, 191, 152, 230, 152, 175, 228, 184, 141, 230, 135, 130] 
1.9.3p392 :014 > x.force_encoding 'gbk'
 => "\x{E688}\x{91E8}\x{BF98}\x{E698}\x{AFE4}\x{B88D}\x{E687}\x82" 
1.9.3p392 :015 > x.encoding
 => #<Encoding:GBK> 
1.9.3p392 :016 > x.bytes.to_a
 => [230, 136, 145, 232, 191, 152, 230, 152, 175, 228, 184, 141, 230, 135, 130] 
1.9.3p392 :017 >

注意：force_encoding 方法只是改变了字符串对象的编码信息，并没有改变字符串对象实际存储的内容。

encode、encode!

在ruby1.9之前如我我们需要编码转换则需要使用一些外部库，现在我们可以直接使用String对象的实例方法encode,encode!进行操作

encode(encoding [, options] ) → str click to toggle source
encode(dst_encoding, src_encoding [, options] ) → str
encode([options]) → str
encode!(encoding [, options] ) → str click to toggle source
encode!(dst_encoding, src_encoding [, options] ) → str

详细的api请参考这里

1.9.3p392 :009 > x='我还是不懂'
 => "我还是不懂" 
1.9.3p392 :010 > x.encoding
 => #<Encoding:UTF-8> 
1.9.3p392 :011 > x.bytes.to_a
 => [230, 136, 145, 232, 191, 152, 230, 152, 175, 228, 184, 141, 230, 135, 130] 
1.9.3p392 :012 > y=x.encode 'gbk','utf-8'
 => "\x{CED2}\x{BBB9}\x{CAC7}\x{B2BB}\x{B6AE}" 
1.9.3p392 :013 > y.encoding
 => #<Encoding:GBK> 
1.9.3p392 :014 > y.bytes.to_a
 => [206, 210, 187, 185, 202, 199, 178, 187, 182, 174] 
1.9.3p392 :015 > x.encode! 'gbk','utf-8'
 => "\x{CED2}\x{BBB9}\x{CAC7}\x{B2BB}\x{B6AE}" 
1.9.3p392 :016 > x.encoding
 => #<Encoding:GBK> 
1.9.3p392 :017 > x.bytes.to_a
 => [206, 210, 187, 185, 202, 199, 178, 187, 182, 174] 
1.9.3p392 :018 >

可以看到encode改变了编码信息同时也改变了字符串对象存储的内容

总结

encdoing 用来查看字符串的编码信息。
force_encoding 用来修正字符串编码信息，注意是修正。
encode,encode! 用来转码字符串。

ruby编码详解

Sat, 18 May 2013 00:00:00 +0000

今天主要说下ruby编码，主要针对ruby1.9及以上版本。 > ruby1.8对编码的支持是比较弱的

ruby中的编码

ruby中编码大致分为两类:

source encoding
io encoding,其中还分internal encoding和external encoding

source encoding

我们一般会在ruby源码文件头部声明编码格式(magic comment)类似下面这样

1
2
3

# encoding: utf-8

# some logic

或者

1
2
3

# coding: utf-8

# some logic

或者

1
2
3

# -*- coding: utf-8 -*-

# some logic

以上三种方式效果是一样的，都告诉ruby解析器此源码文件格式为utf-8。

注意：这里声明只是告诉ruby解析器源码文件格式，并不是设置文件格式。

比方说你声明# encoding: gbk，然而文件格式却是utf-8，运行可是会出错的，

因为ruby解析器会用你告诉它的gbk编码解析文件，显然这个肯定是要乱码的，出错是必然的。

io encodings

external encoding

默认的情况下，当创建的字符串对象来自以下位置时使用default external encoding：
- CSV
- File data read from disk
- SDBM
- StringIO
- Zlib::GzipReader
- Zlib::GzipWriter
- String#inspect
- Regexp#inspect
internal encoding

如果default internal encoding不为nil,则从以下来源的字符串将被转码为default internal encoding
- CSV
- Etc.sysconfdir and Etc.systmpdir
- File data read from disk
- File names from Dir
- Integer#chr
- String#inspect and Regexp#inspect
- Strings returned from Curses
- Strings returned from Readline
- Strings returned from SDBM
- Time#zone
- Values from ENV
- Values in ARGV including $PROGRAM_NAME
- __FILE__

我们有三种方式可以设置internal encoding和external encoding。

通过Encoding.default_internal和Encoding.default_external设置

xx.rb

  # encoding: utf-8
  
  Encoding.default_external = 'utf-8'
  Encoding.default_internal = 'gbk'
  
  x='我还是不懂'
  puts x.encoding
  
  open('xx.rb') do |f|
      f.each { |line| puts "[#{line.encoding},#{line.strip}]" if line.strip.size > 0 }
  end

结果

  ➜  ~  ruby xx.rb
  UTF-8
  [GBK,# encoding: utf-8]
  [GBK,x='我还是不懂']
  [GBK,puts x.encoding]
  [GBK,open('xx.rb') do |f|]
  [GBK,f.each { |line| puts "[#{line.encoding},#{line.strip}]" if line.strip.size > 0 }]
  [GBK,end]

通过命令行ruby -E external:internal 设置

xx.rb

  # encoding: utf-8
  
  x='我还是不懂'
  puts x.encoding
  
  open('xx.rb') do |f|
      f.each { |line| puts "[#{line.encoding},#{line.strip}]" if line.strip.size > 0 }
  end

结果

  ➜  ~  ruby -E utf-8:gbk xx.rb
  UTF-8
  [GBK,# encoding: utf-8]
  [GBK,x='我还是不懂']
  [GBK,puts x.encoding]
  [GBK,open('xx.rb') do |f|]
  [GBK,f.each { |line| puts "[#{line.encoding},#{line.strip}]" if line.strip.size > 0 }]
  [GBK,end]

io encoding

xx.rb

  # encoding: utf-8
  
  x='我还是不懂'
  puts x.encoding
  
  open('xx.rb','r:utf-8:gbk') do |f|
      f.each { |line| puts "[#{line.encoding},#{line.strip}]" if line.strip.size > 0 }
  end

结果

  ➜  ~  ruby xx.rb
  UTF-8
  [GBK,# encoding: utf-8]
  [GBK,x='我还是不懂']
  [GBK,puts x.encoding]
  [GBK,open('xx.rb') do |f|]
  [GBK,f.each { |line| puts "[#{line.encoding},#{line.strip}]" if line.strip.size > 0 }]
  [GBK,end]

其中第一种和第二种方式是全局的，第三种是局部的，一般推荐使用第三种。

默认情况下external encoding会读取当前操作系统的语言环境，internal encoding则为nil。

浮点数在计算机中的存储方式

Sat, 11 May 2013 00:00:00 +0000

今天来说下小数在计算机中是怎样存储的。

定点数与浮点数

小数点在计算机中通常有两种表示方法：

约定所有数值数据的小数点隐含在某一个固定位置上，称为定点表示法，简称 定点数。
小数点位置可以浮动，称为浮点表示法，简称 浮点数。

1. 定点数表示法(fixed-point)

所谓定点格式，即约定机器中所有数据的小数点位置是固定不变的。在计算机中通常采用两种简单的约定：

将小数点的位置固定在数据的最高位之前。
将小数点的位置固定在最低位之后。

一般常称前者为 定点小数，后者为 定点整数。

定点小数是纯小数，约定的小数点位置在符号位之后、有效数值部分最高位之前。

若数据 x 的形式为 x = x0.x1x2…xn ( 其中x0为 符号位，x1～xn是数值的有效部分，也称为尾数， x1为最高有效位 )，则在计算机中的表示形式为：

  |符号位 |小数点位置 |数值部分
  +------+----------+-------+-------+----------------+-----------+
  |  x0  |          |  x1   |  x2   |     .......    |    xn     |
  +------+----------+-------+-------+----------------+-----------+

一般说来，如果最末位 x^n = 1，前面各位都为 0 ，则数的绝对值最小，即 |x|min = 2^-n 。如果各位均为 1，则数的绝对值最大，即 |x|max =1-2^-n 。

所以定点小数的表示范围是：2^-n ≤ | x | ≤ 1 - 2^-n

定点整数是纯整数，约定的小数点位置在有效数值部分最低位之后。

若数据 x 的形式为 x = x0 x1x2…xn ( 其中x0为 符号位，x1～xn 是尾数， xn 为最低有效位 )，则在计算机中的表示形式为：

  |符号位 |数值部分                                  |小数点位置
  +------+------+------------------------+---------+-------------+
  |  x0  |  x1  |      ..........        |    xn   |             |
  +------+------+------------------------+---------+-------------+

定点整数的表示范围是：1≤ | x | ≤ 2^n - 1

当数据小于定点数能表示的最小值时，计算机将它们作0处理，称为下溢；大于定点数能表示的最大值时，计算机将无法表示，称为上溢，上溢和下溢统称溢出。

计算机采用定点数表示时，对于既有整数又有小数的原始数据，需要设定一个比例因子，数据按其缩小成定点小数或扩大成定点整数再参加运算，运算结果，根据比例因子，还原成实际数值。若比例因子选择不当，往往会使运算结果产生溢出或降低数据的有效精度。用定点数进行运算处理的计算机被称为定点机。

2. 浮点数表示法(floating-point number)

与科学计数法相似，任意一个J进制数N，总可以写成N = J^E × M

式中M称为数 N 的尾数(mantissa)，是一个纯小数；E 为数 N 的阶码(exponent)，是一个整数，J称为比例因子 J^E 的底数。这种表示方法相当于数的小数点位置随比例因子的不同而在一定范围内可以自由浮动，所以称为浮点表示法。

底数是事先约定好的(常取2)，在计算机中不出现。在机器中表示一个浮点数时，一是要给出尾数，用定点小数形式表示。尾数部分给出有效数字的位数，因而决定了浮点数的表示精度。二是要给出阶码，用整数形式表示，阶码指明小数点在数据中的位置，因而决定了浮点数的表示范围。浮点数也要有符号位。因此一个机器浮点数应当由阶码和尾数及其符号位组成：

|阶符   |阶码            |尾符   |尾数                            
+------+----------------+-------+------------------------------+ 
| Es   |     E          |  Ms   |           M                  | 
+------+----------------+-------+------------------------------+

当底数取 2 时，二进制数 N 的小数点每右移一位，阶码减小 1，相应尾数右移一位；反之，小数点每左移一位，阶码加 1，相应尾数左移一位。

若不对浮点数的表示作出明确规定，同一个浮点数的表示就不是唯一的。例如 11.01 也可以表示成 0.011012-3 ，0.1101×2-2 等等。这个时候就需要一个统一的标准，现在比较通用的标准是IEEE 754:

float(32位单精度)

|符号位|指数位            |尾数位
+------+----------------+--------------------------------------+
|1bit  |     8bit       |               23bit                  |
+------+----------------+--------------------------------------+

double(64位双精度)

|符号位|指数位            |尾数位
+------+----------------+--------------------------------------+
|1bit  |     11bit      |               52bit                  |
+------+----------------+--------------------------------------+

python的exec、eval详解

Fri, 10 May 2013 00:00:00 +0000

简介

python 动态执行字符串代码片段（也可以是文件），一般会用到exec,eval。

exec

`1`	`exec_stmt ::= "exec" or_expr ["in" expression ["," expression]]`

注意：exec 是一个语法声明，不是一个函数.也就是说和if,for一样.

官方文档对于exec的解释 > This statement supports dynamic execution of Python code.

exec的第一个表达式可以是：

代码字符串
文件对象
代码对象
tuple

前面三种情况差不多，第四种比较特殊最后讲

如果忽略后面的可选表达式,exec后面代码将在当前域执行

>>> a=2
>>> exec "a=1"
>>> a
1
>>>

如果在表达式之后使用in选项指定一个dic，它将作为global和local变量作用域

>>> a=10
>>> b=20
>>> g={'a':6,'b':8}
>>> exec "global a;print a,b" in g
6 8
>>>

如果in后详指定两个表达式，它们将分别用作global和local变量作用域

>>> a=10
>>> b=20
>>> c=20
>>> g={'a':6,'b':8}
>>> l={'b':9,'c':10}
>>> exec "global a;print a,b,c" in g,l
6 9 10
>>>

现在说下tuple的情况，这也是导致很多人误以为exec是一个函数的原因。

如果第一个表达式是tuple

`1`	`exec(expr, globals) #它等效与 exec expr in globals`

`1`	`exec(expr, globals, locals) #它等效与 exec expr in globals,locals`

eval

eval通常用来执行一个字符串表达式，并返回表达式的值。

`1`	`eval(expression[, globals[, locals]])`

有三个参数，表达式字符串，globals变量作用域，locals变量作用域。其中第二个和第三个参数是可选的。

如果忽略后面两个参数，则eval在当前作用域执行。

>>> a=1
>>> eval("a+1")
2
>>>

如果指定globals参数

>>> a=1
>>> g={'a':10}
>>> eval("a+1",g)
11
>>>

如果指定locals参数

>>> a=10
>>> b=20
>>> c=20
>>> g={'a':6,'b':8}
>>> l={'b':9,'c':10}
>>> eval("a+b+c",g,l)
25
>>>

如果要严格限制eval执行，可以设置globals为__builtins__,这样这个表达式只可以访问__builtin__ module。

忠告

exec,eval给我带来了极大的灵活性，同时也带来了隐含的危险性，当我们使用它们的时候应该总是记得详细指定其执行的作用域。

rails部署nginx+unicorn详解

Sat, 20 Apr 2013 00:00:00 +0000

rails部署方案众多，今天介绍下nginx+unicorn.

简介

unicorn是一个高性能的Rack HTTP server,它可以使用unix domain socket通信，获得更好的性能。

官方列举了诸多特性

更好的进程管理。
由内核调度的负载均衡。
类似nginx的无缝升级。
更好的内存管理。
Ruby DSL 的简单配置。
等等特性

安装

`1`	`gem install unicorn`

或者在Gemfile加入

`1`	`gem 'unicorn'`

使用

非rails的rack应用

在应用跟目录运行

`1`	`unicorn #默认会监听8080端口`

Rails应用

在rails跟目录运行

`1`	`unicorn_rails #默认会监听8080端口`

我们可以使用-l选项改变默认监听的地址和端口。
我们可以使用 unicorn -h 或 unicorn_rails -h 查看更多选项说明

配置

unicorn提供配置文件,让我们进行详细的设置。详细的说明请看这里。

after_fork(*args, &block)

worker fork 之后被调用。
before_exec(*args, &block)

在启动unicorn master之前被调用。
before_fork(*args, &block)

在master fork work之前被调用。
check_client_connection(bool)

检查客户端链接是否断开，防止断开的请求调用。:tcp_nopush选项下无效。

listen(address, options = {})

监听地址，可以使是tcp地址，也可以是UNIX domain sockets

listen 3000 # listen to port 3000 on all TCP interfaces
listen "127.0.0.1:3000"  # listen to port 3000 on the loopback interface
listen "/tmp/.unicorn.sock" # listen on the given Unix domain socket
listen "[::1]:3000" # listen to port 3000 on the IPv6 loopback interface

logger(obj)

设置logger级别
- debug
- info
- warn
- error
- fatal 默认情况下log将输出到stderr_path,如果unicorn运行在daemonized模式下，则必须设置详细的stderr_path避免错误信息进入/dev/null
pid(path)

设置pid文件的位置
preload_app(bool)

在forking worker processes之前预加载程序
rewindable_input(bool)

禁止rewindability，可以提高上传的性能，降低io和内存使用
stderr_path(path)

重定向stderr到指定文件
stdout_path(path)

重定向stdout到指定文件
timeout(seconds)

设置worker processes的超时时间
user(user, group = nil)

设置运行worker processes的用户和组
worker_processes(nr)

设置worker_processes数量
working_directory(path)

设置unicorn工作目录，SIGUSR2将启动一个新的unicorn实例在这个目录。

官方给出的最小化配置

# Minimal sample configuration file for Unicorn (not Rack) when used
# with daemonization (unicorn -D) started in your working directory.
#
# See http://unicorn.bogomips.org/Unicorn/Configurator.html for complete
# documentation.
# See also http://unicorn.bogomips.org/examples/unicorn.conf.rb for
# a more verbose configuration using more features.

listen 2007 # by default Unicorn listens on port 8080
worker_processes 2 # this should be >= nr_cpus
pid "/path/to/app/shared/pids/unicorn.pid"
stderr_path "/path/to/app/shared/log/unicorn.log"
stdout_path "/path/to/app/shared/log/unicorn.log"

官方给出的完整配置

# Sample verbose configuration file for Unicorn (not Rack)
#
# This configuration file documents many features of Unicorn
# that may not be needed for some applications. See
# http://unicorn.bogomips.org/examples/unicorn.conf.minimal.rb
# for a much simpler configuration file.
#
# See http://unicorn.bogomips.org/Unicorn/Configurator.html for complete
# documentation.

# Use at least one worker per core if you're on a dedicated server,
# more will usually help for _short_ waits on databases/caches.
worker_processes 4

# Since Unicorn is never exposed to outside clients, it does not need to
# run on the standard HTTP port (80), there is no reason to start Unicorn
# as root unless it's from system init scripts.
# If running the master process as root and the workers as an unprivileged
# user, do this to switch euid/egid in the workers (also chowns logs):
# user "unprivileged_user", "unprivileged_group"

# Help ensure your application will always spawn in the symlinked
# "current" directory that Capistrano sets up.
working_directory "/path/to/app/current" # available in 0.94.0+

# listen on both a Unix domain socket and a TCP port,
# we use a shorter backlog for quicker failover when busy
listen "/tmp/.sock", :backlog => 64
listen 8080, :tcp_nopush => true

# nuke workers after 30 seconds instead of 60 seconds (the default)
timeout 30

# feel free to point this anywhere accessible on the filesystem
pid "/path/to/app/shared/pids/unicorn.pid"

# By default, the Unicorn logger will write to stderr.
# Additionally, ome applications/frameworks log to stderr or stdout,
# so prevent them from going to /dev/null when daemonized here:
stderr_path "/path/to/app/shared/log/unicorn.stderr.log"
stdout_path "/path/to/app/shared/log/unicorn.stdout.log"

# combine Ruby 2.0.0dev or REE with "preload_app true" for memory savings
# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
preload_app true
GC.respond_to?(:copy_on_write_friendly=) and
  GC.copy_on_write_friendly = true

# Enable this flag to have unicorn test client connections by writing the
# beginning of the HTTP headers before calling the application.  This
# prevents calling the application for connections that have disconnected
# while queued.  This is only guaranteed to detect clients on the same
# host unicorn runs on, and unlikely to detect disconnects even on a
# fast LAN.
check_client_connection false

before_fork do |server, worker|
  # the following is highly recomended for Rails + "preload_app true"
  # as there's no need for the master process to hold a connection
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.connection.disconnect!

  # The following is only recommended for memory/DB-constrained
  # installations.  It is not needed if your system can house
  # twice as many worker_processes as you have configured.
  #
  # # This allows a new master process to incrementally
  # # phase out the old master process with SIGTTOU to avoid a
  # # thundering herd (especially in the "preload_app false" case)
  # # when doing a transparent upgrade.  The last worker spawned
  # # will then kill off the old master process with a SIGQUIT.
  # old_pid = "#{server.config[:pid]}.oldbin"
  # if old_pid != server.pid
  #   begin
  #     sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
  #     Process.kill(sig, File.read(old_pid).to_i)
  #   rescue Errno::ENOENT, Errno::ESRCH
  #   end
  # end
  #
  # Throttle the master from forking too quickly by sleeping.  Due
  # to the implementation of standard Unix signal handlers, this
  # helps (but does not completely) prevent identical, repeated signals
  # from being lost when the receiving process is busy.
  # sleep 1
end

after_fork do |server, worker|
  # per-process listener ports for debugging/admin/migrations
  # addr = "127.0.0.1:#{9293 + worker.nr}"
  # server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)

  # the following is *required* for Rails + "preload_app true",
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.establish_connection

  # if preload_app is true, then you may also want to check and
  # restart any other shared sockets/descriptors such as Memcached,
  # and Redis.  TokyoCabinet file handles are safe to reuse
  # between any number of forked children (assuming your kernel
  # correctly implements pread()/pwrite() system calls)
end

github的配置

# unicorn_rails -c /data/github/current/config/unicorn.rb -E production -D
 
rails_env = ENV['RAILS_ENV'] || 'production'
 
# 16 workers and 1 master
worker_processes (rails_env == 'production' ? 16 : 4)
 
# Load rails+github.git into the master before forking workers
# for super-fast worker spawn times
preload_app true
 
# Restart any workers that haven't responded in 30 seconds
timeout 30
 
# Listen on a Unix data socket
listen '/data/github/current/tmp/sockets/unicorn.sock', :backlog => 2048
 
 
##
# REE
 
# http://www.rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
if GC.respond_to?(:copy_on_write_friendly=)
  GC.copy_on_write_friendly = true
end
 
 
before_fork do |server, worker|
  ##
  # When sent a USR2, Unicorn will suffix its pidfile with .oldbin and
  # immediately start loading up a new version of itself (loaded with a new
  # version of our app). When this new Unicorn is completely loaded
  # it will begin spawning workers. The first worker spawned will check to
  # see if an .oldbin pidfile exists. If so, this means we've just booted up
  # a new Unicorn and need to tell the old one that it can now die. To do so
  # we send it a QUIT.
  #
  # Using this method we get 0 downtime deploys.
 
  old_pid = RAILS_ROOT + '/tmp/pids/unicorn.pid.oldbin'
  if File.exists?(old_pid) && server.pid != old_pid
    begin
      Process.kill("QUIT", File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
      # someone else did our job for us
    end
  end
end
 
 
after_fork do |server, worker|
  ##
  # Unicorn master loads the app then forks off workers - because of the way
  # Unix forking works, we need to make sure we aren't using any of the parent's
  # sockets, e.g. db connection
 
  ActiveRecord::Base.establish_connection
  CHIMNEY.client.connect_to_server
  # Redis and Memcached would go here but their connections are established
  # on demand, so the master never opens a socket
 
 
  ##
  # Unicorn master is started as root, which is fine, but let's
  # drop the workers to git:git
 
  begin
    uid, gid = Process.euid, Process.egid
    user, group = 'git', 'git'
    target_uid = Etc.getpwnam(user).uid
    target_gid = Etc.getgrnam(group).gid
    worker.tmp.chown(target_uid, target_gid)
    if uid != target_uid || gid != target_gid
      Process.initgroups(user, target_gid)
      Process::GID.change_privilege(target_gid)
      Process::UID.change_privilege(target_uid)
    end
  rescue => e
    if RAILS_ENV == 'development'
      STDERR.puts "couldn't change user, oh well"
    else
      raise e
    end
  end
end

我的配置

unicorn.rb(此配置文件在rails项目config目录下)

module Rails
  class <<self
    def root
      File.expand_path(__FILE__).split('/')[0..-3].join('/')
    end
  end
end

worker_processes 4

working_directory Rails.root

listen "#{Rails.root}/tmp/sockets/socket", :backlog => 64

timeout 30

pid "#{Rails.root}/tmp/pids/unicorn.pid"

stderr_path "#{Rails.root}/log/unicorn.log"
stdout_path "#{Rails.root}/log/unicorn.log"

# combine Ruby 2.0.0dev or REE with "preload_app true" for memory savings
# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
preload_app true
GC.respond_to?(:copy_on_write_friendly=) and
  GC.copy_on_write_friendly = true

check_client_connection false

before_fork do |server, worker|
  # the following is highly recomended for Rails + "preload_app true"
  # as there's no need for the master process to hold a connection
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.connection.disconnect!

  old_pid = "#{server.config[:pid]}.oldbin"
  if File.exists?(old_pid) && old_pid != server.pid
    begin
      sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
      Process.kill(sig, File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
    end
  end
  
  # Throttle the master from forking too quickly by sleeping.  Due
  # to the implementation of standard Unix signal handlers, this
  # helps (but does not completely) prevent identical, repeated signals
  # from being lost when the receiving process is busy.
  sleep 1
end

after_fork do |server, worker|

  # the following is *required* for Rails + "preload_app true",
  defined?(ActiveRecord::Base) and
    ActiveRecord::Base.establish_connection

  # if preload_app is true, then you may also want to check and
  # restart any other shared sockets/descriptors such as Memcached,
  # and Redis.  TokyoCabinet file handles are safe to reuse
  # between any number of forked children (assuming your kernel
  # correctly implements pread()/pwrite() system calls)
end

nginx.conf

worker_processes 1;

events {
  worker_connections 1024;
}

http {
  
  include mime.types;

  default_type application/octet-stream;

  sendfile on;
  
  keepalive_timeout 0;

  upstream app_server {
    # fail_timeout=0 means we always retry an upstream even if it failed
    # to return a good HTTP response (in case the Unicorn master nukes a
    # single worker for timing out).

    # for UNIX domain socket setups:
    server unix: /path/to/app/tmp/sockets/socket fail_timeout=0;
  }
  
  server {
        listen 8080 default;
        return 403; 
  }

  server {
    listen 8080;

    server_name www.explame.com;

    location / {
      proxy_pass http://app_server;
    }

    # Rails error pages
    error_page 500 502 503 504 /500.html;
    location = /500.html {
      root /path/to/app/current/public;
    }
  }
}

启动unicorn

`1`	`unicorn_rails -c /path/to/app/config/unicorn.rb -D -E production`

无缝重启服务使用kill -USR2 `cat path/to/app/tmp/pids/unicorn.pid` 这样会启动一个新的unicorn master然后关闭旧的unicorn master

有可能你会发现你执行了上述命令但是没起作用，这是因为你可能没有在你的Gemfile中加入gem 'unicorn'

nginx的location匹配规则详解

Mon, 15 Apr 2013 00:00:00 +0000

nginx中我们会用location指令来匹配指定的uri进行一些逻辑处理。

location指令语法

`1`	`location [ = \| ~ \| ~* \| ^~ ] uri { ... }`

location 支持常规字符串和正则表达式两种匹配模式。

= 提高常规字符串匹配优先级
~ 正则匹配，大小写敏感
~* 正则匹配，大小写不敏感
^~ 提高常规字符串匹配优先级

匹配顺序

首先匹配=前缀的常规字符串，如果匹配成功则停止后续匹配。
其次匹配^~前缀的常规的字符串，如果匹配成功则停止后续匹配。
再次匹配~或~*前缀的正则表达式，如果匹配成功则停止后续匹配。
最后匹配不带任何前缀的常规字符串，如果匹配成功则停止后续匹配。
上述都未匹配上则返回404。

多个正则表达式的匹配优先级是由在文件中的物理顺序决定的。

下面举例说明

location / {
	# ...
}

location =/index.html {
	# ...
}

location ~* .*\.html {
	# ...
}

location ^~ /list.html {
	# ...
}

location /about.html {
	# ...
}

如果请求的uri是/index.html，根据之前的规则=前缀的常规字符串被优先匹配（第二个location配置）。

如果请求的uri是/list.html，根据之前的规则^~前缀的常规字符串被优先匹配（第三个location配置）。

如果请求的uri是/about.html，根据之前的规则~或~*前缀正则表达式被优先匹配（第四个location配置），第五个location配置实际上不会起作用,因为正则匹配的优先级高于它。

如果请求的uri是/robots.txt，根据之前的规则常规字符串会被匹配（第一个location配置）。

总结

=总是被优先匹配，其次是^~，再次是~和~*,最后才是没有任何前缀的常规字符串。

expect自动交互详解

Sun, 14 Apr 2013 00:00:00 +0000

expect是Unix系统中用来进行自动化控制和测试的软件工具，应用在交互式软件中如telnet，ftp，Passwd，fsck，rlogin，tip，ssh等等。

简介

linux下我们经常会写一些脚本来完成一系列繁琐的工作,不幸的是很多交互式的命令，我们不得不人肉去响应。

expect出现就是为了解决这个问题。

#!/usr/bin/env expect
# 假设用户名和密码都是admin
spawn ssh admin@10.0.0.10
expect {
    password: {
        send admin
    } connecting {
        send yes\n
        expect {
            password: {
                send admin
            }
        }
    }
}
expect eof

上面模拟了ssh登陆，无需我们手动输入密码。

详解

expect实际就是监听我们目标进程的输出(spawn)，根据期望输出(expect)，进行响应(send)。

expect的核心指令分别是spawn,expect,send。

spawn

`1`	`spawn [args] program [args]`

创建一个新的进程，并执行给定的程序,后面就可以使用expect监听程序的输出。 (详细的args请自行man)

expect

`1`	`expect [[-opts] pattern body1] ... [-opts] pattern [bodyn]`

expect指令的参数是一连串的opts,pattern,body，其中opts是可选的，最后一个pattern的body也是可选的。

pattern就是用来匹配期望的输出，一旦匹配上就执行后面的body

  expect {
      busy               {puts busy\n}
      -re "failed|invalid password" {puts failed]\n}
      timeout            {puts timeout\n}
      connected
  }

-re选项开启正则匹配(更多选项请自行man)。

expect会等待目标进程的输出，然后进行匹配，这个等待的时间默认是10秒，一旦超过这个时间就直接执行下一条指令，我们可以通过设置timeout来更改这个时间

send

`1`	`send [-flags] string`

将字符串传递给当前进程，这里就是模拟人的输入。(详细的flags请自行man)

关于 expect eof

好奇你的肯定会问最后那个expect eof是干嘛的。

这是因为没有expect eof程序就直接退出了，因为没什么可干的了。显然这样是有问题的，因为我们的程序实际上是没执行完的。

由spawn启动的程序在结束的时候会产生一个eof标示，expect eof会等待程序的退出标示，一旦匹配就什么也不做，是的什么也不做，没什么可做也就退出了。

这样就完了吗？不，还有很大的问题，还记得之前说的expect的超时时间么，是的是10秒，如果程序执行时间超过10秒或更久，显然expect eof会超时，程序会直接退出，解决办法就是设置timeout

下面给出一个远程备份文件的例子，来说明问题

#!/usr/bin/env expect
# 假设用户名和密码都是admin
spawn rsync admin@10.0.0.10:~/data .
set timeout 600 #设置expect超时时间为10分钟,如果不设置同步则无法正确完成
expect {
    password: {
        send admin
    } connecting {
        send yes\n
        expect {
            password: {
                send admin
            }
        }
    }
}
expect eof

expect使用Tcl脚本语言作流程控制，这样就可以实现更为复杂的业务逻辑,详情请点这里

kaminari设置最大页数

Wed, 03 Apr 2013 00:00:00 +0000

kaminari是一款非常优秀的分页插件，它支持 Rails/Sinatra/Padrino。

它基本上解决我所有的分页需求，不过最近发现一个不足，好像没有设置最大页数的功能。

例如我的数据有1000页，但是我只想显示100页，这个时候就搞不定了。

初步来看有两个办法来解决问题

1.修改源代码

2.修改template

个人倾向第二种，侵入性小，方案确定那么就开始动手

走起

`1`	`<%= paginate @blogs %>`

该方法定义在 ~/.rvm/gems/ruby-1.9.3-p392/gems/kaminari-0.14.1/lib/kaminari/helpers/action_view_extension.rb (源码)

 	# A helper that renders the pagination links.
    #
    #   <%= paginate @articles %>
    #
    # ==== Options
    # * <tt>:window</tt> - The "inner window" size (4 by default).
    # * <tt>:outer_window</tt> - The "outer window" size (0 by default).
    # * <tt>:left</tt> - The "left outer window" size (0 by default).
    # * <tt>:right</tt> - The "right outer window" size (0 by default).
    # * <tt>:params</tt> - url_for parameters for the links (:controller, :action, etc.)
    # * <tt>:param_name</tt> - parameter name for page number in the links (:page by default)
    # * <tt>:remote</tt> - Ajax? (false by default)
    # * <tt>:ANY_OTHER_VALUES</tt> - Any other hash key & values would be directly passed into each tag as :locals value.
    def paginate(scope, options = {}, &block)
      paginator = Kaminari::Helpers::Paginator.new self, options.reverse_merge(:current_page => scope.current_page, :total_pages => scope.total_pages, :per_page => scope.limit_value, :param_name => Kaminari.config.param_name, :remote => false)
      paginator.to_s
    end

看看Kaminari::Helpers::Paginator#initialize (源码)

 def initialize(template, options) #:nodoc:
        @window_options = {}.tap do |h|
          h[:window] = options.delete(:window) || options.delete(:inner_window) || Kaminari.config.window
          outer_window = options.delete(:outer_window) || Kaminari.config.outer_window
          h[:left] = options.delete(:left) || Kaminari.config.left
          h[:left] = outer_window if h[:left] == 0
          h[:right] = options.delete(:right) || Kaminari.config.right
          h[:right] = outer_window if h[:right] == 0
        end
        @template, @options = template, options
        @theme = @options[:theme] ? "#{@options[:theme]}/" : ''
        @options[:current_page] = PageProxy.new @window_options.merge(@options), @options[:current_page], nil
        #FIXME for compatibility. remove num_pages at some time in the future
        @options[:total_pages] ||= @options[:num_pages]
        @last = nil
        # initialize the output_buffer for Context
        @output_buffer = ActionView::OutputBuffer.new
      end

显然@window_options和@options是重点，它里面包含了我们需要的数据。

继续

1
2
3

<%= paginator.render do -%>
	# ...
<% end -%>

该方法定义在~/.rvm/gems/ruby-1.9.3-p392/gems/kaminari-0.14.1/lib/kaminari/helpers/paginator.rb (源码)

# render given block as a view template
def render(&block)
  instance_eval(&block) if @options[:total_pages] > 1
  @output_buffer
end

显然这个block可以访问@window_options和@options,那么问题就解决了，于是修改如下

<%= paginator.render do -%>
	# 默认max_page等于total_pages
	<% @options[:max_page] ||= total_pages %>
	<div class="page-bar">
		<%#= first_page_tag unless current_page.first? -%>
		<%= prev_page_tag unless current_page.first? %>
		<% each_page do |page| -%>
        	# 达到max_pages则不在渲染按钮
			<% break if page > @options[:max_page] %>
			<% if page.left_outer? || page.right_outer? || page.inside_window? -%>
				<%= page_tag page %>
			<% elsif !page.was_truncated? -%>
				<%= gap_tag %>
			<% end -%>
		<% end -%>
        # 隐藏下一页按钮
		<% if current_page < @options[:max_page] %>
			<%= next_page_tag unless current_page.last? %>
		<% end %>
		<%#= last_page_tag unless current_page.last? -%>
	</div>
<% end -%>

如果只要显示100页则

`1`	`<%= paginate @blogs, :max_page => 100 %>`

嗯，有些小瑕疵，不过这显然难不倒我们。

轻量级代码语法高亮插件Highlight.js

Wed, 03 Apr 2013 00:00:00 +0000

Highlight.js是一款轻量级的语法高亮插件, 支持54种语言和26种主题，详情见这里

本站使用就是该插件。

简单使用

1
2
3

<link rel="stylesheet" href="styles/default.css">
<script src="highlight.pack.js"></script>
<script>hljs.initHighlightingOnLoad();</script>

默认高亮<pre><code></code></pre>块包裹的代码

定制

你也可以有选择的高亮代码块

1
2
3

$(document).ready(function() {
  $('pre code').each(function(i, e) {hljs.highlightBlock(e)});
});

如果你的代码不在pre中，则你可能需要使用<br>换行，传递参数true告诉Highlight用<br>换行

`1`	`$('div.code').each(function(i, e) {hljs.highlightBlock(e, null, true)});`

更多api详情请点这里

有时你可能需要替换TAB为你想要的任意字符,便于排版

<script type="text/javascript">
  //替换TAB为4个空白
  hljs.tabReplace = '    '; 
  //替换为span \t
  hljs.tabReplace = '<span class="indent">\t</span>';
  
  hljs.initHighlightingOnLoad();
</script>

语法识别

Highlight是根据code标签上的class识别语言的

<pre><code class="java">...</code></pre>
<pre><code class="python">...</code></pre>
<pre><code class="ruby">...</code></pre>
<pre><code class="erlang">...</code></pre>

有些情况下可能需要禁止高亮

`1`	`<pre><code class="no-highlight">...</code></pre>`

node.js

Highlight.js 也能够在node.js中使用

`1`	`npm install highlight.js`

var hljs = require('highlight.js');

// 设置具体的语言
hljs.highlight(lang, code).value;

// 自动识别语言
hljs.highlightAuto(code).value;

如果你有兴趣深入研究请参见源码

Rails3:ActiveSupport::Concern详解

Wed, 27 Mar 2013 00:00:00 +0000

模块是方法和常量的集合，模块和类一样，其中的可以包括两种方法：实例方法(Instance Method)、模块方法(Module Method)。

当一个类include(Mixin)一个模块时，模块中的实例方法会成为该类的实例方法，expand(Mixin)时,模块中的实例方法会成为该类的类方法。两种情况下模块方法都会被忽略。

同时实现类方法和实例方法的混入看起来是鱼和熊掌的问题，要放弃吗？显然是不可能的，我们都是贪婪的。

一个解决办法

module ClassMethods
end

module InstanceMethods
end

class Foo
    extend ClassMethods
    include InstanceMethods
end

看起来可以正常工作，但是不那么优雅，粒度太大。

聪明的程序员总是能想到解决办法

module Mod

    def self.included(base)
        base.extend(ClassMothods)
    end

    module ClassMethods
        # 类方法定义
    end

    #实例方法定义
end

class M
    include Mod
end

嗯，看起来不错，比第一种方法优雅多了。但是用着用着问题就来

module Foo
  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods
    def say
      puts 'say'
    end
  end
end

module Bar
  include Foo

  def self.included(base)
      base.say
  end
end

class Host
  include Bar
end

上面代码会抛出NoMethodError: undefined method 'say' for Host:Class异常

原因在于include Bar的时候Foo中included(base)被执行,此时base是Bar

一个解决办法

module Foo
  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods
    def say
      puts 'say'
    end
  end
end

module Bar
  def self.included(base)
      base.say
  end
end

class Host
  include Foo
  include Bar
end

问题虽然解决的，但是引入了一个新的问题，所有使用Bar的地方都要知道它依赖Foo,需要分出额外的精力来维护这种依赖关系，我们应该把他们的依赖关系隐藏起来。

看来我们还是太挑剔

ActiveSupport::Concern

本文重点来了

为了解决这种依赖关系，rails中增加了ActiveSupport::Concern(源码)这个工具。

module ActiveSupport
  # A typical module looks like this:
  #
  #   module M
  #     def self.included(base)
  #       base.extend ClassMethods
  #       base.class_eval do
  #         scope :disabled, -> { where(disabled: true) }
  #       end
  #     end
  #
  #     module ClassMethods
  #       ...
  #     end
  #   end
  #
  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
  # written as:
  #
  #   require 'active_support/concern'
  #
  #   module M
  #     extend ActiveSupport::Concern
  #
  #     included do
  #       scope :disabled, -> { where(disabled: true) }
  #     end
  #
  #     module ClassMethods
  #       ...
  #     end
  #   end
  #
  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
  # and a +Bar+ module which depends on the former, we would typically write the
  # following:
  #
  #   module Foo
  #     def self.included(base)
  #       base.class_eval do
  #         def self.method_injected_by_foo
  #           ...
  #         end
  #       end
  #     end
  #   end
  #
  #   module Bar
  #     def self.included(base)
  #       base.method_injected_by_foo
  #     end
  #   end
  #
  #   class Host
  #     include Foo # We need to include this dependency for Bar
  #     include Bar # Bar is the module that Host really needs
  #   end
  #
  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
  #
  #   module Bar
  #     include Foo
  #     def self.included(base)
  #       base.method_injected_by_foo
  #     end
  #   end
  #
  #   class Host
  #     include Bar
  #   end
  #
  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
  # module dependencies are properly resolved:
  #
  #   require 'active_support/concern'
  #
  #   module Foo
  #     extend ActiveSupport::Concern
  #     included do
  #       def self.method_injected_by_foo
  #         ...
  #       end
  #     end
  #   end
  #
  #   module Bar
  #     extend ActiveSupport::Concern
  #     include Foo
  #
  #     included do
  #       self.method_injected_by_foo
  #     end
  #   end
  #
  #   class Host
  #     include Bar # works, Bar takes care now of its dependencies
  #   end
  module Concern
    def self.extended(base) #:nodoc:
      base.instance_variable_set("@_dependencies", [])
    end

    def append_features(base)
      if base.instance_variable_defined?("@_dependencies")
        base.instance_variable_get("@_dependencies") << self
        return false
      else
        return false if base < self
        @_dependencies.each { |dep| base.send(:include, dep) }
        super
        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
      end
    end

    def included(base = nil, &block)
      if base.nil?
        @_included_block = block
      else
        super
      end
    end
  end
end

实现代码相当简短，使用也非常简单

module M
    extend ActiveSupport::Concern
    included do
        self.send(:do_host_something)
    end

   module ClassMethods
      def wo
        # do something
      end
   end

   module InstanceMethods
      def ni
         # do something
      end
   end
end

终极版

require 'active_support/concern'
module Foo
  extend ActiveSupport::Concern
  module ClassMethods
    def say
      puts 'say'
    end
  end
end

module Bar
  extend ActiveSupport::Concern
  include Foo
  included do
      self.say
  end
end

class Host
  include Bar
end

洗洗睡觉

rails3中autoload_paths加载详解

Sat, 16 Mar 2013 00:00:00 +0000

在rails3中默认不在加载lib目录下的rb文件。

config/application.rb文件中

1
2

#Custom directories with classes and modules you want to be autoloadable.
#config.autoload_paths += %W(#{config.root}/exters)

显然被注释掉了。

要开启则取消注释，修改为自己想加载的路径。

`1`	`config.autoload_paths += %W(#{config.root}/lib)`

这样rails会自动加载lib下的rb文件。

没有子目录

在lib下有go.rb

module Go
    def say
        puts 'hello'
    end
end

在其他地方使用的时候include进来，例如

class ProductsController < ApplicationController
    include Go
    def index
        say()
    end
end

含有子目录

在lib下有tools目录，下面有go.rb
1 2 3 4 5

module Go def say puts 'hello' end end
controller中
1 2 3 4 5 6

class ProductsController < ApplicationController include Go def index say() end end
很遗憾这这样会抛出异常uninitialized constant 。

原因rails加载lib使用的const_missing机制，在找不到常量时，会根据这个常量的名字，加载文件。 >如果类名（常量名、模块名都是常量）是 A::B::C，那么就把 :: 替换为 ‘/‘，单词变成小写，然后尝试在 ActiveSupport::Dependencies.autoload_paths 里的路径中，去查找是否有 a/b/c.rb。

显然lib下没有任何rb可加载,inculde Go肯定是找不到的，此时触发const_missing还是找不到。

应该将go.rb里modules的名字改为Tools::Go
1 2 3 4 5

module Tools::Go def say puts 'hello' end end
controller中inlude修改为include Tools::Go
1 2 3 4 5 6

class ProductsController < ApplicationController include Tools::Go def index say() end end
同样inculde Tools::Go肯定是找不到的，此时触发const_missing，根据规则可知此时会去加载tools/go.rb，显然加载成功。

页面回到顶部的实现及原理

Sun, 03 Mar 2013 00:00:00 +0000

现在很多网页都有一个回到顶部的功能，当你拖动滚动条往下拉到一定程度就会在右下方显示一个回到顶部的按钮，点击则可以立即回到页面顶部，非常贴心的设计。

今天打算自己做一个，分析了一下，要点如下

监听当前页面滚动事件
当滚动到一定像素显示回到顶部的按钮
给回到顶部按钮绑定点击事件，点击按钮让滚动条回到顶部并隐藏按钮

核心点主要在js控制按钮的显示和隐藏及点击按钮回到顶部及如何控制回到顶部按钮不随文档滚动

js伪代码如下

//绑定页面滚动事件
$(document).bind('scroll',function(){
	var len=$(this).scrollTop()
	if(len>=100){
		//显示回到顶部按钮
    }else{
    	//隐藏回到顶部按钮
    }
})
//绑定回到顶部按钮的点击事件
$('#回到顶部').click(function(){
	//动画效果，平滑滚动回到顶部
	$(document).animate({ scrollTop: 0 });
	//不需要动画则直接回到顶部
	//$(document).scrollTop(0)
})

让按钮不随文档滚动需要使用到css属性position >static：无特殊定位，对象遵循正常文档流。top，right，bottom，left等属性不会被应用。

relative：对象遵循正常文档流，但将依据top，right，bottom，left等属性在正常文档流中偏移位置。

absolute：对象脱离正常文档流，使用top，right，bottom，left等属性进行绝对定位。而其层叠通过z-index属性定义。

fixed：对象脱离正常文档流，使用top，right，bottom，left等属性以窗口为参考点进行定位，当出现滚动条时，对象不会随着滚动。IE6及以下不支持此参数值

很明显我们需要fixed(ie6真是蛋疼)

思路有了就写测试代码

<!DOCTYPE HTML>
<html>
	<head>
		<meta http-equiv="content-type" content="text/html; charset=utf-8" />
		<title>回到顶部demo</title>
		<style type="text/css">
			.up{
				position:fixed;
				bottom:20px;
				right:20px;
				width:10px;
				display:none;
			}
		</style>
	</head>
	<body>
		<div style="background:rgb(200,200,200);height:2000px;">我很长</div>
		<a id="up" href="javascript:;" class="up">回到顶部</a>
	</body>
	<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
	<script type="text/javascript">
		//绑定页面滚动事件
		$(document).bind('scroll',function(){
			var len=$(this).scrollTop()
			if(len>=100){
				//显示回到顶部按钮
				$('#up').show();
			}else{
				//影藏回到顶部按钮
				$('#up').hide();
			}
		})
		//绑定回到顶部按钮的点击事件
		$('#up').click(function(){
			//动画效果，平滑滚动回到顶部
			$(document).animate({ scrollTop: 0 });
			//不需要动画则直接
			//$(document).scrollTop(0)
		})
	</script>
</html>

测试结果不是很令人满意，拖动滚动条按钮是显示出来了，但是点击却没有回到顶部。

原来问题出在滚动操作的对象上，将document换成body

//绑定回到顶部按钮的点击事件
$('#up').click(function(){
	//动画效果，平滑滚动回到顶部
	$('body').animate({ scrollTop: 0 });
	//不需要动画则直接
	//$('body').scrollTop(0)
})

测试一切ok

以为这样就完了，你太天真了少年

浏览器兼容，攻城师心中永远的痛~

代码在ie上不给力，滚动显示不了按钮，滚到底都显示不出来，崩溃。

原来事件要绑在window上

//绑定页面滚动事件
$(window).bind('scroll',function(){
	var len=$(this).scrollTop()
	if(len>=100){
		//显示回到顶部按钮
		$('#up').show();
	}else{
		//影藏回到顶部按钮
		$('#up').hide();
	}
})

上最终代码

<!DOCTYPE HTML>
<html>
	<head>
		<meta http-equiv="content-type" content="text/html; charset=utf-8" />
		<title>回到顶部demo</title>
		<style type="text/css">
			.up{
				position:fixed;
				bottom:20px;
				right:20px;
				width:10px;
				display:none;
			}
		</style>
	</head>
	<body>
		<div style="background:rgb(200,200,200);height:2000px;">我很长</div>
		<a id="up" href="javascript:;" class="up">回到顶部</a>
	</body>
	<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
	<script type="text/javascript">
		//绑定页面滚动事件
		$(window).bind('scroll',function(){
			var len=$(this).scrollTop()
			if(len>=100){
				//显示回到顶部按钮
				$('#up').show();
			}else{
				//影藏回到顶部按钮
				$('#up').hide();
			}
		})
		//绑定回到顶部按钮的点击事件
		$('#up').click(function(){
			//动画效果，平滑滚动回到顶部
			$(document).animate({ scrollTop: 0 });
			//不需要动画则直接
			//$(document).scrollTop(0)
		})
	</script>
</html>

神马还有ie6，哥哥早点洗洗睡吧~

python多版本管理工具pythonbrew

Sun, 06 Jan 2013 00:00:00 +0000

当你需要在一台机器上同时安装多个不同版本的python的时候，你可能就需要使用pythonbrew。

pythonbrew可以帮你下载安装不同版本的python并且可以自由的在多个版本间进行切换,它和ruby的rvm类似。

安装

终端输入curl -kL http://xrl.us/pythonbrewinstall | bash > 执行完成之后它会安装在~/.pythonbrew.目录下
如果你想将pythonbrew安装到指定的位置你需要这样做
1 2 3 4

export PYTHONBREW_ROOT=/path/to/pythonbrew curl -kLO http://xrl.us/pythonbrewinstall chmod +x pythonbrewinstall ./pythonbrewinstall
在~/.bashrc添加[[ -s $HOME/.pythonbrew/etc/bashrc ]] && source $HOME/.pythonbrew/etc/bashrc

使用

安装python

pythonbrew install 2.7.2
pythonbrew install --verbose 2.7.2
pythonbrew install --test 2.7.2
pythonbrew install --test --force 2.7.2
pythonbrew install --configure="CC=gcc_4.1" 2.7.2
pythonbrew install --no-setuptools 2.7.2
pythonbrew install http://www.python.org/ftp/python/2.7/Python-2.7.2.tgz
pythonbrew install /path/to/Python-2.7.2.tgz
pythonbrew install /path/to/Python-2.7.2
pythonbrew install 2.7.2 3.2

临时切换到指定版本的(当前shell)

`1`	`pythonbrew use 2.7.2`

永久切换到指定版本的

1
2

pythonbrew switch 2.7.2
pythonbrew switch 3.2

列出以安装的版本

`1`	`pythonbrew list`

列出所有可安装的版本

`1`	`pythonbrew list -k`

卸载

1
2

pythonbrew uninstall 2.7.2
pythonbrew uninstall 2.7.2 3.2

清理源文件和安装包

`1`	`pythonbrew cleanup`

更新pythonbrew

1
2
3

pythonbrew update
pythonbrew update --master
pythonbrew update --develop

停用pythonbrew

`1`	`pythonbrew off`

更多使用方法请参考https://github.com/utahta/pythonbrew

python获取mac地址

Thu, 03 Jan 2013 00:00:00 +0000

import uuid
node = uuid.getnode()
mac = uuid.UUID(int = node).hex[-12:]
print mac

python获取机器名

Thu, 03 Jan 2013 00:00:00 +0000

1
2

import socket
print socket.gethostname()

urllib2上传文件

Thu, 03 Jan 2013 00:00:00 +0000

httplib2好像不支持文件上传,无奈不得不回去使用urllib2。

urllib2本身是不支持文件上传的，但是其良好的扩展性使得其实现这一功能非常简单。

urllib2所有功能都是由一个个handle实现的。

urllib2加入poster这个handle将具备上传功能。

`1`	`$ pip install poster`

使用非常简单

from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
import urllib2

#注册poster这个handle
register_openers()

#编码数据
datagen, headers = multipart_encode({"image": open("explame.jpg", "rb")})

request = urllib2.Request("http://www.explame.org/upload", datagen, headers)
#上传文件并获得响应信息
print urllib2.urlopen(request).read()

由urlib2转向使用httplib2

Wed, 02 Jan 2013 00:00:00 +0000

提到python下http相关的库一般都会想到urllib、urllib2、httplib。

httplib实现了HTTP和HTTPS的客户端协议，一般不直接使用
urllib则是封装了httplib
urllib2则可以认为是urllib的升级版

urllib和urllib2经常一起用

使用非常简单

1
2
3

import urllib2
resp=urllib2.urlopen('http://www.explame.com/')
print resp.read()

更多信息请参考官方文档http://docs.python.org/2/library/urllib2.html

一切都很顺利，但是最近使用的时候发现抓取部分站点页面的时候偶尔会抛出connection reset by peer异常。

开始以为是没有加user-agent被目标站点屏蔽了，加上之后问题依旧，又尝试加上Referer问题依然存在，最后把cookie也加上了依然无果。

google发现很多人也遇到类似问题，说是网络问题造成的。

我可以肯定网络是没有问题的，浏览器能够打开，程序就会报错（偶尔），百思不得其解。

最后我开始怀疑类库有问题，转而使用httplib2。

httplib2是一个第三方的类库,支持python2.3之后的版本,0.5.0之后的版本支持python3,官方首页上列举了诸多特性。

使用也非常简单

import httplib2

h = httplib2.Http()
resp, content = h.request("http://example.org/", "GET")
print content

提交表单

import httplib2
import urllib

url = 'http://www.example.com/login'   
body = {'USERNAME': 'foo', 'PASSWORD': 'bar'}
headers = {'Content-type': 'application/x-www-form-urlencoded'}
http = httplib2.Http()
response, content = http.request(url, 'POST', headers=headers, body=urllib.urlencode(body))

使用cookie

import urllib
import httplib2

http = httplib2.Http()
url = 'http://www.example.com/login'   
body = {'USERNAME': 'foo', 'PASSWORD': 'bar'}
headers = {'Content-type': 'application/x-www-form-urlencoded'}
response, content = http.request(url, 'POST', headers=headers, body=urllib.urlencode(body))

headers = {'Cookie': response['set-cookie']}

url = 'http://www.example.com/home'   
response, content = http.request(url, 'GET', headers=headers)

当我切换到httplib2上，之前的问题再也没有出现过。

rsync命令使用介绍

Sat, 29 Dec 2012 00:00:00 +0000

rsync是Unix下的一款应用软件，它能同步更新两处计算机的文件与目录，并适当利用差分编码以减少数据传输。rsync中一项与其他大部分类似程序或协定中所未见的重要特性是镜像对每个目标只需要一次传送。rsync可拷贝／显示目录属性，以及拷贝文件，并可选择性的压缩以及递归拷贝。

我们先来看看rsync的用法

Usage: rsync [OPTION]... SRC [SRC]... DEST
  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST
  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST
  or   rsync [OPTION]... SRC [SRC]... rsync://[USER@]HOST[:PORT]/DEST
  or   rsync [OPTION]... [USER@]HOST:SRC [DEST]
  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]
  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]
The ':' usages connect via remote shell, while '::' & 'rsync://' usages connect
to an rsync daemon, and require SRC or DEST to start with a module name.

rsync可以使用自己原生的rsync协议通讯，也可以使用ssh协议通讯。

如果使用原生协议通讯需要需要启动rsync server,默认监听TCP端口873,我们可以修改server的配置文件调整监听端口和加入认证功能等。

鉴于配置原生服务比较繁琐（可能是我太懒），一般情况下都会直接使用ssh协议进行通讯。

原生协议

#将本机的me目录同步到192.168.1.100的me目录
rsync -avu /me rsync://admin@192.168.1.100:573/me
#如果是默认端口（573）可以省略不写
rsync -avu /me rsync://admin@192.168.1.100:/me
#另一种写法
rsync -avu /me admin@192.168.1.100::/me

ssh协议

#与原生协议的区别仅在于使用一个冒号
rsync -avu /me admin@192.168.1.100:/me
#如果ssh的端口默认不是22,使用 -e 选项进行设置
rsync -avu -e "ssh -p 8000" /me admin@192.168.1.100:/me

rsync常见用法

备份

rsync -avu /me admin@192.168.2.100:/me
#-a选项等价于 -rlptgoD
#-v显示详细信息
#-u如果目标文件比要备份的文件新则不更新

一般同步大的目录时间会比较长，如果网络断掉那就需要断点续传

1
2

rsync -avP /me admin@192.168.2.100:/me
#注意-u选项不能与-P选项共存

更多选项请使用rsync -h或man rsync查看

python的web框架webpy 六

Sat, 08 Sep 2012 00:00:00 +0000

webpy中获取get和post参数的方式非常简单

args=web.input()  
name=args.get('name')  
age=args.get('age')  
sex=args.get('sex')

需要注意的是上面方法获得的参数的类型全是unicode,所以对于数值需要作相应的类型转换才能使用

获得上传的文件

args=web.input()  
file=args.get('file')#获得文件  
filename=file.filename#获得文件名称  
content=file.read()#读取文件内容

python的web框架webpy【session 和 cookie】五

Sat, 08 Sep 2012 00:00:00 +0000

webpty中使用session非常简单

import web  
web.config.debug = False  
urls = (  
    "/count", "count",  
    "/reset", "reset"  
)  
app = web.application(urls, locals())  
session = web.session.Session(app, web.session.DiskStore('sessions'), initializer={'count': 0})  
  
class count:  
    def GET(self):  
        session.count += 1  
        return str(session.count)  
  
class reset:  
    def GET(self):  
        session.kill()  
        return ""  
  
if __name__ == "__main__":  
    app.run()

initializer 指定session的初始化值

`1`	`web.session.DiskStore('sessions') #设置session的存储方式为磁盘`

我们也可以指定session存储在数据库中

1
2
3

db = web.database(dbn='postgres', db='mydatabase', user='myname', pw='')  
store = web.session.DBStore(db, 'sessions')  
session = web.session.Session(app, store, initializer={'count': 0})

表结构

create table sessions (  
    session_id char(128) UNIQUE NOT NULL,  
    atime timestamp NOT NULL default current_timestamp,  
    data text  
);

我们可以通过web.config对session进行一些可选设置

web.config.session_parameters['cookie_name'] = 'webpy_session_id'  
web.config.session_parameters['cookie_domain'] = None  
web.config.session_parameters['timeout'] = 86400, #24 * 60 * 60, # 24 hours   in seconds  
web.config.session_parameters['ignore_expiry'] = True  
web.config.session_parameters['ignore_change_ip'] = True  
web.config.session_parameters['secret_key'] = 'fLjUfxqXtfNoIldA0A0J'  
web.config.session_parameters['expired_message'] = 'Session expired'

webpy中使用cookie

setcookie(name, value, expires="", domain=None, secure=False):   
  
cookie_name - session id 存储在cookie中的名称  
cookie_domain - cookie的domain  
timeout - session 过期时间，单位为秒  
ignore_expiry -如果设置为True则忽略过期时间  
ignore_change_ip - 如果为False则来自同一ip则session才有效  
secret_key - session id的hash值  
expired_message - session 失效后显示的信息

设置cookie

`1`	`web.setcookie('age', i.age, 3600)`

读取cookie

`1`	`web.cookies().get(cookieName)`

shell中判断变量为null

Sat, 08 Sep 2012 00:00:00 +0000

方法一

if [ $x ];then  
    echo 'not null'  
else  
    echo 'is null'  
fi

方法二

if [ -z "$x" ];  
    echo 'is null'  
else  
    echo 'not null'  
fi

shell中给变量设置默认值

Sat, 08 Sep 2012 00:00:00 +0000

通常shell中我们需要给变量设置默认值，可能会写出如下代码

#!/bin/bash  
if [ ! $1 ]; then  
       $1='default'  
fi

显然这种方式在变量少的时候没啥问题，一旦变量多起来，我们可能就有大量的重复劳动(if判断)

有没有比较优雅的方式，不用写一大堆if判断，显然答案是有的

变量为null时

1
2

#当变量a为null时则var=b  
var=${a-b}

变量为null且为空字符串的时候

1
2

#当变量a为null或为空字符串时则var=b  
var=${a:-b}

处理shell中未赋值变量造成的灾难

Sat, 08 Sep 2012 00:00:00 +0000

在编写shell的时候我们都需要万分小心，尤其是给root执行的脚本

#!/bin/bash  
....  
rm -rf $1/$2/bin/  
....

假设上述脚本我执行的时候没有传递参数，造成的后果是相当恐怖的。

有没有好的办法解决这个问题，答案是有的

#!/bin/bash  
....  
if [ ! $1 ];then
   echo '$1 is null'  
   exit 1  
fi  
if [ ! $2 ];then 
   echo '$1 is null'  
   exit 1  
fi 
rm -rf $1/$2/bin  
....

难道我们在使用变量之前，都要判断是否为null，这样太繁琐了，有没有更好的解决办法，答案依然是有的

#!/bin/bash  
set -u  
....  
rm -rf $1/$2/bin  
....

当设置set -u 后，使用未赋值的变量时shell将自动退出

python的web框架webpy(一)

Wed, 08 Aug 2012 00:00:00 +0000

python的web框架是一个百花齐放的世界，完全列表请看这里。

面对如此众多的框架我们要如何选择！它们都有各自的优缺点，你不可能找到一款完美的，其实只需要选择适合的即可！

这里介绍webpy,进入官方首页你可以看到右边有一个hello word的例子

import web  
          
urls = (  
    '/(.*)', 'hello'  
)  
app = web.application(urls, globals())  
  
class hello:          
    def GET(self, name):  
        if not name:   
            name = 'World'  
        return 'Hello, ' + name + '!'  
  
if __name__ == "__main__":  
    app.run()

没错就是这么简单，相信你也会喜欢上他

下载安装包，点击这里下载（我这里下载的是web.py-0.37.tar.gz）。

安装webpy

1
2
3

# tar xzvf web.py-0.37.tar.gz  
# cd web.py-0.37  
# python setup.py install

写一个自己的程序

创建一名为server.py的文件，内容如下

# coding:utf-8  
import web  
  
urls=(  
    '/','index'  
)  
  
app=web.application(urls,globals())  
  
class index:  
    def GET(self):  
        return 'hello webpy!'  
  
if __name__=='__main__':  
    app.run()

在终端运行

# python server.py

浏览器打开http://localhost:8080,你可以在页面上看到hello webpy!

你可以在启动的时候设置监听的端口，改变默认的8080端口

# python server.py 80

python的web框架webpy(二)

Wed, 08 Aug 2012 00:00:00 +0000

之前介绍了webpy，还写了一个自己的web程序，下面我们就来分析下代码。

# coding:utf-8  
import web  
  
urls=(  
      '/','index'  
)  
  
app=web.application(urls,globals())  
  
class index:  
    def GET(self):  
        return 'hello webpy!'  
  
if __name__=='__main__':  
    app.run()

`1`	`import web #导入webpy的模块`

#这里声明了路由规则，它是一个tuple,由url匹配规则和处理类组成  
#url匹配规则是用正则表达式书写的  
urls=(  
      '/','index' #所有匹配上/的url都交由index类来处理  
)  
#可以声明多条路由规则，每一条都是由url匹配规则和处理类组成  
urls=(  
      '/','index',  
      '/user','user',  
      '/topic','topic'  
)

1
2

#初始化webapp  
app=web.application(urls,globals())

#处理类index，它需要实现GET或POST方法  
#return 可以返回你的处理结果到用户浏览器  
class index:  
    def GET(self):  
        return 'hello webpy!'

1
2
3

#启动webapp  
if __name__=='__main__':  
    app.run()

python的web框架webpy【Templetor】（四）

Wed, 08 Aug 2012 00:00:00 +0000

之前我们讲的都是简单的返回文本到浏览器，例如下面将会返回hello word到浏览器

# coding:utf-8  
import web  
  
urls=(  
      '/','index'  
)  
  
app=web.application(urls,globals())  
  
class index:  
    def GET(self):  
        return 'hello word!'  
  
if __name__ == '__main__':  
    app.run()

当然我们也可以返回html到浏览器，例如

# coding:utf-8  
import web  
  
urls=(  
      '/','index'  
)  
  
app=web.application(urls,globals())  
  
class index:  
    def GET(self):  
        return ''''' 
            <html> 
                <head> 
                    <title>hello word</title> 
                </head> 
                <body> 
                    <p>hello word!</p> 
                </body> 
            </html> 
        '''  
  
if __name__ == '__main__':  
    app.run()

显然我们不可能用上述方法来开发web应用，那有没有更加优雅的方法。

所有的web框架都提供有template技术来实现复杂的web页面webpy也不例外。

在工程目录下建立templates目录（你也可以叫其他名字），这个目录用于存储我们所有的模板文件，我们在下面建立一个叫做index.html文件内容如下

$def with (name) #这里定义传递进来的参数，后面会提到  
<!DOCTYPE html>  
<html>  
    <head>  
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
        <title>hello word</title>  
    </head>  
    <body>  
        <p>hello word!$name</p>  
    </body>  
</html>

现在我们就可以使用这个模板了

# coding:utf-8  
import web  
  
urls=(  
      '/','index'  
)  
  
app=web.application(urls,globals())  
render=web.template.render('templates')#模板目录  
  
class index:  
    def GET(self):  
        return render.index('webpy')#使用index.html模板，传递参数'webpy'（这里会查找templates下第一个匹配上index.*的文件，所以我们的模板文件其实可以使用任何扩展名结尾）  
  
if __name__ == '__main__':  
    app.run()

我们也可以指定具体的模板文件

1
2

index = web.template.frender('templates/index.html')  
return index('webpy')

我们也可以直接使用字符串为模板

template = ''''' 
    $def with (name) 
    <!DOCTYPE html> 
    <html> 
        <head> 
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
            <title>hello word</title> 
        </head> 
        <body> 
            <p>hello word!$name</p> 
        </body> 
    </html> 
'''  
index = web.template.Template(template)  
return index('webpy')

模板种允许使用python表达式,所有表达式都要以$符号开头

Look, a $string.   
Hark, an ${arbitrary + expression}.   
Gawk, a $dictionary[key].function('argument').   
Cool, a $(limit)ing.

还可以声明变量

$ bug = get_bug(id)  
<h1>$bug.title</h1>  
<div>  
    $bug.description  
<div>

若想不被转义则需要在$后面加行：号

$str='1 < 2'  
<p>$:str</p>  
输出则为：  
<p>1 < 2</p>

所有表达式都要以$开头那么要出$就需要用$$

1
2
3

$$50  
输出为  
$50

模板种注释为$#开头

1
2

$#我是注释  
<p>hello word</p>

控制结构

$for i in range(10):   
    I like $i  
  
$for i in range(10): I like $i  
  
$while a:  
    hello $a.pop()  
  
$if times > max:   
    Stop! In the name of love.   
$else:   
    Keep on, you can do it.

在循环中可以访问的一些内置变量

loop.index: the iteration of the loop (1-indexed)  
loop.index0: the iteration of the loop (0-indexed)  
loop.first: True if first iteration  
loop.last: True if last iteration  
loop.odd: True if an odd iteration  
loop.even: True if an even iteration  
loop.parity: "odd" or "even" depending on which is true  
loop.parent: the loop above this in nested loops

例如下面

<table>  
$for c in ["a", "b", "c", "d"]:  
    <tr class="$loop.parity">  
        <td>$loop.index</td>  
        <td>$c</td>  
    </tr>  
</table>

你还可以定义方法

$def say_hello(name='world'):  
    Hello $name!  
  
$say_hello('web.py')  
$say_hello()

还可以植入python代码，使用$code

$code:  
    x = "you can write any python code here"  
    y = x.title()  
    z = len(x + y)  
  
    def limit(s, width=10):  
        """limits a string to the given width"""  
        if len(s) >= width:  
            return s[:width] + "..."  
        else:  
            return s  
  
And we are back to template.  
The variables defined in the code block can be used here.  
For example, $limit(x)

当然也可以使用layout

`1`	`render = web.template.render('templates/', base='layout')`

上面会使用 templates/layout.html 作为 layout

layout.html内容：

$def with (content)  
<html>  
<head>  
    <title>Foo</title>  
</head>  
<body>  
$:content  
</body>  
</html>

python的web框架webpy【路由规则】（三）

Wed, 08 Aug 2012 00:00:00 +0000

今天重点说下webpy的路由规则。

#这里声明了三条路由规则，它是一个tuple,由url匹配规则和处理类组成  
#url匹配规则是用正则表达式书写的  
#可以声明多条路由规则，每一条都是由url匹配规则和处理类组成  
urls=(  
      '/','index',  
      '/user','user',  
      '/topic','topic'  
)

既然url匹配规则是正则表达式那我们就可以灵活的写出各种表达式

urls=(  
      '/','index',  
      '/(user|member)','user', #匹配 http://example.com/user和http://example.com/member  
      '/topic/?','topic',#匹配 http://example.com/topic和http://example.com/topic/  
      '/blog/(\d+)','blog',#匹配 http://example.com/blog/123  
      '/news/(\d+)/(\w+)','news'#匹配 http://example.com/news/123/abc  
)

正则表达式里的分组可以在后面的处理类中使用，例如

'/news/(\d+)','news'  
#如果url为http://example.com/news/123456  
  
class news:  
    #这里的id就是上面分组里匹配上的值(123456)  
    def GET(self,id):  
        return 'id:%s' % id

注意：url匹配只匹配url路径不包括参数，例如：

’/news/create?title=(.+)’

它不会匹配上http://example.com/news/create?title=hello

linux下安装mysql

Tue, 07 Aug 2012 00:00:00 +0000

首先下载mysql源码包，我这里下载MySQL Community Server 5.5。
检查机器是否装有cmake,直接输入cmake显示帮助信息表示已安装 >现在mysql编译都需要用cmake生成makefile文件，关于cmake更多可以点击这里。如果你的机器上没有cmake请先行安装cmake。
1 2 3

$ yum install cmake 或者 $ sudo apt-get install cmake
解压mysql并编译
1 2 3 4 5

$ tar xzvf mysql-5.5.27.tar.gz $ cd mysql-5.5.27 $ cmake -DCMAKE_INSTALL_PREFIX=/path/to/mysql $ make -j4 $ make install
cmake这里可能出错，一般都是没有安装gcc或gcc-c++
cmake的时候可以设置许多编译参数，cmake -L 查看可以设置的参数
注意:如果cmake出错一定要删除目录下生成的CMakeCache.txt文件才能再次cmake
创建mysql用户

$ useradd -r mysql

上面命令将创建一个名为mysql的系统账号

将mysql安装目录所有者更改为mysql用户并初始化数据库

1
2
3

$ chown -R mysql:mysql mysql  
$ cd mysql  
$ scripts/mysql_install_db --user=mysql

拷贝mysql配置文件到/etc下

$ cp support-files/my-innodb-heavy-4G.cnf /etc/my.cnf

support-files下有针对不同需求的配置文件，你可以根据自己的实际情况选取

设置mysql服务(开机自启动)

1
2

$ cp support-files/mysql.server /etc/init.d/mysql  
$ chkconfig --add mysql

如果你的机器上没有chkconfig命令那么你可能需要安装

1
2
3

$ yum install chkconfig  
或者  
$ sudo apt-get install chkconfig

你就可以通过

1
2
3

service mysql start  #启动mysql
service mysql stop  #停止mysql
service mysql restart #重启mysql

python修改图片尺寸

Tue, 07 Aug 2012 00:00:00 +0000

python对图片的操作需要使用到(Python Imaging Library)PIL库，PIL可以处理几乎所有的图片类型，了解更多请点击这里。

下载PIL并安装 >windows：直接下载对应的安装包

linux：

$ yum install python-imaging  
或  
$ sudo apt-get install python-imaging  
或  
直接通过源码安装

使用

import Image  
img = Image.open('example.jpg')  
new_img= img.resize((w, h),Image.ANTIALIAS) # w代表宽度，h代表高度，最后一个参数指   定采用的算法  
nwe_img.save('example-new.jpg',quality=100)

python操作mysql数据库

Tue, 07 Aug 2012 00:00:00 +0000

python操作mysql需要用到MySQLdb这个库。

下载MySQLdb，点击这里下载

使用

import MySQLdb  
try:  
    con = MySQLdb.connect(host='192.168.1.100', user='myuser', passwd='123456', port='3306', db='mydb',charset='utf8')  
    c = con.cursor()  
    c.execute('select * from user');  
    rows=c.fetchall() #一次读取所有数据,返回的数据结构[(?,?,...),(?,?,..),..]  
    for row in rows:  
        for column in row:  
            print column  
except Exception,e:  
    print e  
finally:  
    c.close()  
    con.close()

import MySQLdb  
try:  
    con = MySQLdb.connect(host='192.168.1.100', user='myuser', passwd='123456', port='3306', db='mydb',charset='utf8')  
    c = con.cursor()  
    #使用占位符传递参数，参数是一个tuple  
    c.execute('select * from user where user=%s',('root'));  
    rows=c.fetchall() #一次读取所有数据,返回的数据结构[(?,?,...),(?,?,..),..]  
    for row in rows:  
        for column in row:  
            print column  
except Exception,e:  
    print e  
finally:  
    c.close()  
    con.close()

import MySQLdb  
try:  
    con = MySQLdb.connect(host='192.168.1.100', user='myuser', passwd='123456', port='3306', db='mydb',charset='utf8')  
    c = con.cursor()  
    #使用占位符传递参数，参数是一个tuple  
    c.execute('update user set host=%s where user=%s',('root','192.168.1.200'));  
    con.commit() #更新操作记得提交事物，否则更改不会生效  
except Exception,e:  
    print e  
finally:  
    c.close()  
    con.close()

import MySQLdb  
try:  
    con = MySQLdb.connect(host='192.168.1.100', user='myuser', passwd='123456', port='3306', db='mydb',charset='utf8')  
    c = con.cursor()  
    vs=[]  
    vs.append(('root','192.168.1.100'))  
    vs.append(('db','192.168.1.101'))  
    vs.append(('pdb','192.168.1.101'))  
    #使用占位符传递参数，参数是一个list tuple  
    c.executemany('insert into user(user,host)values(%s,%s)',vs);  
    con.commit() #更新操作记得提交事物，否则更改不会生效  
except Exception,e:  
    print e  
finally:  
    c.close()  
    con.close()

注意事项

咋看一下其中占位符和字符串格式化差不多，天真的以为数字用%d,浮点数用%f,字符串用%s,那你可以就要悲剧了

事实上这里的占位符只能是%s

varnish安装及配置（三）

Wed, 11 Jan 2012 00:00:00 +0000

varnish通过几个辅助命令行工具观察varnish的工作情况

varnishlog:

varnish的日志是写入共享内存的，可以使用varnishlog命令行工具读取

[admin@localhost ~]$ varnishlog -c //上面的命令将输出客户端的请求信息

195 RxRequest    c GET  
195 RxURL        c /BD/310x85-2.jpg  
195 RxProtocol   c HTTP/1.1  
195 RxHeader     c Accept: */*  
195 RxHeader     c Referer: http://www.example.com/index.html  
195 RxHeader     c Accept-Language: zh-cn  
195 RxHeader     c Accept-Encoding: gzip, deflate  
195 RxHeader     c User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 679)  
195 RxHeader     c Host: www.example.com  
195 RxHeader     c Connection: Keep-Alive  
195 VCL_call     c recv lookup  
195 VCL_call     c hash  
195 Hash         c /BD/310x85-2.jpg  
195 Hash         c www.explame.com  
195 VCL_return   c hash  
195 Hit          c 1071138920  
195 VCL_call     c hit deliver  
195 VCL_call     c deliver deliver  
195 TxProtocol   c HTTP/1.1  
195 TxStatus     c 200  
195 TxResponse c OK  
195 TxHeader     c Content-Type: image/jpeg  
195 TxHeader     c Last-Modified: Sat, 31 Dec 2011 09:26:44 GMT  
195 TxHeader     c Expires: Wed, 11 Jan 2012 14:19:50 GMT  
195 TxHeader     c Cache-Control: max-age=3600  
195 TxHeader     c Server: lighttpd/1.4.20  
195 TxHeader     c Content-Length: 22214  
195 TxHeader     c Accept-Ranges: bytes  
195 TxHeader     c Date: Wed, 11 Jan 2012 14:02:55 GMT  
195 TxHeader     c Age: 2585  
195 TxHeader     c Connection: keep-alive  
195 TxHeader     c X-Cache: 27238  
195 Length       c 22214  
195 ReqEnd       c 1071326704 1326290575.867818117 1326290575.867902040 1.986548185 0.000028849 0.000055075

[admin@localhost ~]$ varnishlog -b //显示varnish请求后端的信息，和上面的现实相似

[admin@localhost ~]$ varnishlog -i RxURL //显示出所有请求的url的信息，-i 参数指定了具体要显示的项目，项目名称就是上面显示信息中

还有很多有用的参数，大家可以通过varnishlog -h 查看其他参数的作用，或者参考：https://www.varnish-cache.org/docs/3.0/reference/varnishlog.html

varnishncsa:

此命令输出的日志类似apache 形式的日志，大部分参数和varnishlog 类似，其中有好多参数使用时会提示-x is not valid for varnishncsa //x代表具体参数估计是bug

varnishstat:

这个命令可能是我们用的最多的也是最有用的命令，它可以统计varnish的很多信息，包括缓存命中次数，未命中次数，请求数，缓存大小等。

[admin@localhost ~]$ varnishstat

下面介绍各个数据的含义：

第一行显示的是varnish自启动到现在运行了多长时间，上面显示的27天7小时30分17秒
第二行显示的是启动这个命令的时间，这个三数字最终会变为10，100，1000；分别代表10秒，100秒，1000秒
第三行显示的是命中率，分别对象上面的时间，分别是10秒内的命中率，100秒内的命中率，1000秒内的命中率

从第四行开始下面的数据就分为4列

第一列为总数值，第二列为每秒中的数值，第三列自命令（varnishstat）启动以来的平均值，第四列是描述

其中几个比较重要的数据是

cache-hit ：代表缓存命中次数
miss-hit ：代表未命中次数
worker threads ：代表当前工作线程的数量
expired objects ：代表过期对象的个数
LRU nuked objects ：代表缓存可使用的内存以达上线而不得不移除的对象个数
LRU moved objects ：代表LRU策略被移动的对象个数
Total header bytes ：代表缓存的请求头对象的大小
Total body bytes ：代表缓存的请求体对象大小

[admin@localhost ~]$ varnishstat -1 //将显示所有的统计数据

还有一些其他的辅助命令行工具请参考：https://www.varnish-cache.org/docs/3.0/reference/index.html

varnish安装及配置（二）

Tue, 10 Jan 2012 00:00:00 +0000

Varish Configuration Language 简称VCL，通过它我们可以完成一些复杂的逻辑处理。下面将详细介绍：

Backend declarations:

backend www {  
  .host = "www.example.com";  
  .port = "80";  
  .connect_timeout = 1s;  
  .first_byte_timeout = 5s;  
  .between_bytes_timeout = 2s;  
}

或者

backend www {  
  .host = "www.example.com";  
  .port = "80";  
}

.host和.port为必填项

Directors:

varnish支持负载均衡，其中有random,client.hash,round-robin,dns,fallback等算法

director b2 random {//设置调度算法为random  
  .retries = 5;  
  {  
    // 这里可以引用之前定义的backend  
    .backend = b1;  
    .weight  = 7;  
  }  
  {  
    // 也可以直接定义backend  
    .backend  = {  
      .host = "www.example.com";  
      .port="80";  
    }  
   .weight  = 3;  
  }  
}

director b2 round-robin {//设置调度算法为round-robin  
  {  
    .backend = b1;//引用之前定义的backend  
  }  
  {  
    .backend = b2;//引用之前定义的backend  
  }  
}

其他调度算法的设置都大同小异具体可参考官方文档

ACLs：

acl local {  
  "localhost";           
  "192.0.2.0"/24;       
  ! "192.0.2.23";       
}

在vcl子程序中使用(子程序将在下面讲到)

1
2
3

if (client.ip ~ local) {//来源ip符合上面定义则直接访问后端服务器，不缓存  
  return (pass);  
}

Regular Expressions：

vcl中还支持正则表达式

1
2
3

if (req.http.host ~ "(?i)example.com$") {  
        //一些逻辑  
}

Functions：

hash_data(str) //主要用来生成缓存对象的hash key

regsub(str, regex, sub) //替换字符换str中匹配上正则表达式的内容为sub字符串，只替换一次

regsuball(str, regex, sub) //同上，不过这个方法是替换所有匹配的

ban(ban expression) //使符合表达式的对象不被缓存

ban_url(regex) //使符合的url的对象不被缓存

Subroutines：

子程序这个说白了就是方法。我们可以把一个请求分为多个阶段，每个阶段都会调用不同的方法，这样我们只要写出相应阶段的方法，我们的方法就会在相应的阶段被执行，想想这有多么美妙，我们可以干很多事情，我们对请求完全可控！

说白就是方法名称别人定义好了返回类型别人也定义好了你只需要填写你的逻辑就OK了！下面介绍各个阶段的方法

vcl_init

当vcl被load的时候被调用，一般情况下你基本不需要更改这里，当然你有这个需求那就另说
vcl_recv

当请求到达的时候被调用，我们大部分的逻辑都在这里，访问控制，是否需要缓存等
vcl_pipe

管道模式下被调用
vcl_pass

请求直接到后端时被调用
vcl_hash

缓存对象生成hash key时被调用
vcl_hit

缓存命中时调用
vcl_miss

缓存未命中时调用
vcl_fetch

后端请求成功返回时调用
vcl_deliver

缓存对象被传递到客户端前被调用
vcl_error

当其他方法但会error时被调用
vcl_fini

请求结束时调用

从上面几个方法大家可以看出一个请求需要经过好几个阶段，下面的图清晰的说明一个请求在不同的条件下所要经过的阶段，每个阶段都有不同的内置变量可以使用，所有精华都在这张图中！

下面贴几个官方的例子

Example

backend default {  
 .host = "www.example.com";  
 .port = "80";  
}  
  
sub vcl_recv {  
    if (req.restarts == 0) {  
        if (req.http.x-forwarded-for) {  
            set req.http.X-Forwarded-For =  
                req.http.X-Forwarded-For + ", " + client.ip;  
        } else {  
            set req.http.X-Forwarded-For = client.ip;  
        }  
    }  
    if (req.request != "GET" &&  
      req.request != "HEAD" &&  
      req.request != "PUT" &&  
      req.request != "POST" &&  
      req.request != "TRACE" &&  
      req.request != "OPTIONS" &&  
      req.request != "DELETE") {  
        /* Non-RFC2616 or CONNECT which is weird. */  
        return (pipe);  
    }  
    if (req.request != "GET" && req.request != "HEAD") {  
        /* We only deal with GET and HEAD by default */  
        return (pass);  
    }  
    if (req.http.Authorization || req.http.Cookie) {  
        /* Not cacheable by default */  
        return (pass);  
    }  
    return (lookup);  
}  
  
sub vcl_pipe {  
    # Note that only the first request to the backend will have  
    # X-Forwarded-For set.  If you use X-Forwarded-For and want to  
    # have it set for all requests, make sure to have:  
    # set bereq.http.connection = "close";  
    # here.  It is not set by default as it might break some broken web  
    # applications, like IIS with NTLM authentication.  
    return (pipe);  
}  
  
sub vcl_pass {  
    return (pass);  
}  
  
sub vcl_hash {  
    hash_data(req.url);  
    if (req.http.host) {  
        hash_data(req.http.host);  
    } else {  
        hash_data(server.ip);  
    }  
    return (hash);  
}  
  
sub vcl_hit {  
    return (deliver);  
}  
  
sub vcl_miss {  
    return (fetch);  
}  
  
sub vcl_fetch {  
    if (beresp.ttl <= 0s ||  
        beresp.http.Set-Cookie ||  
        beresp.http.Vary == "*") {  
                /* 
                 * Mark as "Hit-For-Pass" for the next 2 minutes 
                 */  
                set beresp.ttl = 120 s;  
                return (hit_for_pass);  
    }  
    return (deliver);  
}  
  
sub vcl_deliver {  
    return (deliver);  
}  
  
sub vcl_error {  
    set obj.http.Content-Type = "text/html; charset=utf-8";  
    set obj.http.Retry-After = "5";  
    synthetic {"  
<?xml version="1.0" encoding="utf-8"?>  
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"  
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">  
<html>  
  <head>  
    <title>"} + obj.status + " " + obj.response + {"</title>  
  </head>  
  <body>  
    <h1>Error "} + obj.status + " " + obj.response + {"</h1>  
    <p>"} + obj.response + {"</p>  
    <h3>Guru Meditation:</h3>  
    <p>XID: "} + req.xid + {"</p>  
    <hr>  
    <p>Varnish cache server</p>  
  </body>  
</html>  
"};  
    return (deliver);  
}  
  
sub vcl_init {  
        return (ok);  
}  
  
sub vcl_fini {  
        return (ok);  
}

Example

backend www {  
  .host = "www.example.com";  
  .port = "80";  
}  
  
backend images {  
  .host = "images.example.com";  
  .port = "80";  
}  
  
sub vcl_recv {  
  if (req.http.host ~ "(?i)^(www.)?example.com$") {  
    set req.http.host = "www.example.com";  
    set req.backend = www;  
  } elsif (req.http.host ~ "(?i)^images.example.com$") {  
    set req.backend = images;  
  } else {  
    error 404 "Unknown virtual host";  
  }  
}  
  
The following snippet demonstrates how to force a minimum TTL for  
all documents.  Note that this is not the same as setting the  
default_ttl run-time parameter, as that only affects document for  
which the backend did not specify a TTL:::  
  
import std; # needed for std.log  
  
sub vcl_fetch {  
  if (beresp.ttl < 120s) {  
    std.log("Adjusting TTL");  
    set beresp.ttl = 120s;  
  }  
}

Example

acl purge {  
  "localhost";  
  "192.0.2.1"/24;  
}  
  
sub vcl_recv {  
  if (req.request == "PURGE") {  
    if (!client.ip ~ purge) {  
      error 405 "Not allowed.";  
    }  
    return(lookup);  
  }  
}  
  
sub vcl_hit {  
  if (req.request == "PURGE") {  
    purge;  
    error 200 "Purged.";  
  }  
}  
  
sub vcl_miss {  
  if (req.request == "PURGE") {  
    purge;  
    error 200 "Purged.";  
  }  
}

官方参考文档：https://www.varnish-cache.org/docs/3.0/reference/vcl.html

varnish安装及配置（一）

Mon, 09 Jan 2012 00:00:00 +0000

varnish是一款高性能的开源HTTP加速器，用来缓存静态文件（图片,js,css）以减少后端服务器压力,性能要比squid高很多。

下载varnish,https://www.varnish-cache.org/ #建议下载最新稳定版
编译安装

tar xzvf varnish-3.0.2.tar.gz
cd varnish
sh autogen.sh
sh configure  #一些可选参数
make
make install

启动varnish,通过varnishd命令来启动varnish服务

varnishd -a 0.0.0.0:80 -s malloc,10g -t 2592000 -w 200,4000,300 -h classic,300000 -p thread_pools=10 -p session_linger=100 -p listen_depth=4096 -p lru_interval=3600 -p sess_workspace=9437184 -p http_resp_size=4194304 -p thread_pool_workspace=9437184 -u admin -g admin -f /path/varnish.vcl

下面分析下上面主要的几个参数：

-a 0.0.0.0:80	#设置varnish监听本机80端口的请求

-s malloc,10g	#分配10G的内存用于缓存

-t 2592000	#设置缓存对象过期时间为30天

-w 200,4000,300	#设置线程池中最小线程和最大线程数及线程空闲时间

-h classic,300000	#设置hash算法classic,bucket推荐为缓存对象数的10倍默认为16383,simple_list算法不推荐生产环境使用,critbit算法是一个几乎无锁的树

-p thread_pools=10	#设置线程池大小

-p session_linger=100	#让session重用的时间,重用session可提高性能，这个值设的太大如果没有重用就浪费资源，如果太小重用率太低（大家自己权衡设置）

-p listen_depth=4096	#监听队列的深度

-p sess_workspace=9437184	#session工作内存的大小，vcl操作中需要用到这些内存

-p http_resp_size=4194304	#后端请响应允许的最大字节数，这个的内存就是从上面的sess_workspace分配的

-p thread_pool_workspace=9437184	#设置线程池内存大小，vcl中处理请求和响应将用到

-u admin	#以admin用户运行varnish服务

-g admin	#以admin组运行varnish服务

-f /path/varnish.vcl	#指定vcl配置

上述的性能参数大家可根据自己的实际情况调整，性能相关参数请参考

https://www.varnish-cache.org/docs/3.0/reference/varnishd.html