$ wget http://www.zeromq.org/local--files/area:download/zeromq-2.0.6.tar.gz
$ tar -xzf zeromq-2.0.6.tar.gz
$ cd zeromq-2.0.6
$ ./configure --prefix=/home/app/zeromq
$ make
$ sudo make install
// 重建so文件链接
$ sudo ln -s /home/app/zeromq/lib/libzmq.so.0.0.0  /usr/lib/libzmq.so.0
$ sudo ln -s /home/app/zeromq/lib/libzmq.so.0.0.0  /usr/lib/libzmq.so

- 测试zeromq

// client.c
#include 
#include 
#include 
#include "/home/app/zeromq/include/zmq.h"

int main ()
{
    int rc;
    void *ctx, *s;
    zmq_msg_t query, resultset;
    const char *query_string, *resultset_string = "OK";

    /* Initialise 0MQ context, requesting a single application thread
       and a single I/O thread */
    ctx = zmq_init (1, 1, 0);
    assert (ctx);
    /* Create a ZMQ_REP socket to receive requests and send replies */
    s = zmq_socket (ctx, ZMQ_REP);
    assert (s);
    /* Bind to the TCP transport and port 5555 on the 'lo' interface */
    rc = zmq_bind (s, "tcp://lo:5555");
    assert (rc == 0);

    while (1) {
        /* Allocate an empty message to receive a query into */
        rc = zmq_msg_init (&query);
        assert (rc == 0);

        /* Receive a message, blocks until one is available */
        rc = zmq_recv (s, &query, 0);
        assert (rc == 0);

        /* Process the query */
        query_string = (const char *)zmq_msg_data (&query);
        printf ("Received query: '%s'\n", query_string);
        zmq_msg_close (&query);

        /* Allocate a response message and fill in an example response */
        rc = zmq_msg_init_size (&resultset, strlen (resultset_string) + 1);
        assert (rc == 0);
        memcpy (zmq_msg_data (&resultset),
            resultset_string, strlen (resultset_string) + 1);

        /* Send back our canned response */
        rc = zmq_send (s, &resultset, 0);
        assert (rc == 0);
        zmq_msg_close (&resultset);
    }
}

// server.cpp
#include 
#include "/home/app/zeromq/include/zmq.hpp"

int main ()
{
    try {
        // Initialise 0MQ context with one application and one I/O thread
        zmq::context_t ctx (1, 1);
        // Create a ZMQ_REQ socket to send requests and receive replies
        zmq::socket_t s (ctx, ZMQ_REQ);
        // Connect it to port 5555 on localhost using the TCP transport
        s.connect ("tcp://localhost:5555");

        // Construct an example zmq::message_t with our query
        const char *query_string = "SELECT * FROM mytable";
        zmq::message_t query (strlen (query_string) + 1);
        memcpy (query.data (), query_string, strlen (query_string) + 1);
        // Send the query
        s.send (query);

        // Receive and display the result
        zmq::message_t resultset;
        s.recv (&resultset);
        const char *resultset_string = (const char *)resultset.data ();
        printf ("Received response: '%s'\n", resultset_string);
    }
    catch (std::exception &e) {
        // 0MQ throws standard exceptions just like any other C++ API
        printf ("An error occurred: %s\n", e.what());
        return 1;
    }

    return 0;
}

// 编译
$ gcc `pkg-config --libs --cflags /home/app/zeromq/lib/pkgconfig/libzmq.pc` -o server server.c
$ g++ `pkg-config --libs --cflags /home/app/zeromq/lib/pkgconfig/libzmq.pc` -o client client.cpp

注意：将so链接到usr/lib下 测试程序才运行成功！

- 安装java扩展不成功

configure.in:3: error: Autoconf version 2.61 or higher is required

$ autoreconf --version
autoreconf (GNU Autoconf) 2.59

没有时间细弄了 下次有时间再试吧 准备看下 activemq去

测试：

dl("mcrypt.so");
$string = "test@abc.com";
$stuff="String to enc/enc/dec/dec =,=,";
$key="XiTo74dOO09N48YeUmuvbL0E";
$iv = mcrypt_create_iv (mcrypt_get_block_size (MCRYPT_TripleDES, MCRYPT_MODE_CBC), MCRYPT_DEV_RANDOM);

$iv64=base64_encode($iv);
echo "iv:".base64_encode($iv);
echo "
\n";

$key=base64_decode("U42/zc3r6zC2Ok11BqO+lA==");
$iv=base64_decode("xTXaC2FQEGWOVBqPIipt1A==");
//$enc=mcrypt_cbc (MCRYPT_TripleDES, $key, $string, MCRYPT_ENCRYPT, $iv);
//MCRYPT_RIJNDAEL_128
$enc=mcrypt_cbc (MCRYPT_RIJNDAEL_128, $key, $string, MCRYPT_ENCRYPT, $iv);
$ret=base64_encode($enc);

echo "encrypt:".$ret;
echo "
\n";
$string=$ret;
$string = trim(base64_decode($string));
//$dec = mcrypt_cbc (MCRYPT_TripleDES, $key, $string, MCRYPT_DECRYPT, $iv);
$dec = mcrypt_cbc (MCRYPT_RIJNDAEL_128, $key, $string, MCRYPT_DECRYPT, $iv);

echo "decrypt:".$dec;

————— 英文不好，咱只过代码 ~ O(∩_∩)O ~ ———————-
1. 声明不定长参数个数的方法
这个功能在函数库里经常会用到如printf中参数的个数就是不固定的
样例

// 声明空参数的方法， PHP是动态语言，所以在调用时可以不遵守约定输入任意参数~~
// 如果在java里 需要这样声明 foo(Object ... args)
function foo() {
// 得到所有的传递进来的实际参数值（实参）
$args = func_get_args();
// 将所得到的实参输出
foreach ($args as $k => $v) {
echo "arg".($k+1).": $v\n";
}
}

foo('hello', 'world', 'again');
/* 打印
arg1: hello
arg2: world
arg3: again
*/

这个功能很实用，书写起来也很直观
类似的PHP为我们提供的方法处理函数还有：
– 获取当前方法本次调用时的参数信息
func_get_arg 获取当次方法调用的指定位置的参数
func_get_args 获取当次方法调用的参数列表
func_num_args 获取当次方法调用的参数个数
– 扩展： 通过字面量调用已定义的方法 ， 允许通过变量传递方法名，将调用方和实现方解耦
function_exists 验证方法是否存在
call_user_func 通过方法名调用方法
method_exists 验证成员方法是否存在
forward_static_call 在成员方法中调用外部静态方法

package test.helloworld.cmd;
// fallseir 2010-03-26
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class Cli {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		GnuParser parser=new GnuParser();
		Options opts=getCmdOptions();
		CommandLine line=null;
		try {
			line=parser.parse(opts,args);
		} catch (ParseException e) {
			//e.printStackTrace();
			System.err.println(e.getMessage());
			HelpFormatter helper=new HelpFormatter();
			helper.printHelp("cmdLineSyntax", opts);
		}
		if(line==null) return ;
		if(line.hasOption("h")){
			HelpFormatter helper=new HelpFormatter();
			//helper.printHelp("cmdLineSyntax", opts);
			helper.printHelp(80, "tester", "header", opts, "footer");
			return;
		}
		boolean debug=false;
		if(line.hasOption("debug")){
			debug=true;
			System.out.println("debug is set");
		}
		if(line.hasOption("arg")){
			String arg=line.getOptionValue("arg");
			System.out.println("arg "+arg);
		}
	}

	private static Options getCmdOptions() {
		Options options=new Options();
		Option opt=OptionBuilder.create("debug");
		options.addOption(opt);
		opt=OptionBuilder.isRequired()
					.hasArg()
					.withArgName("arg")
					.withDescription("arg description")
					.withLongOpt("argument")
					.withValueSeparator()
					.create("arg");
		options.addOption(opt);
		options.addOption(new Option("h","help",false,"print help"));
		return options;
	}

}

Signal Shell下基于信号的应用通信
使用 sun.misc.Signal ，但 sun 已经提示Signal将在其后版本剥离
建议使用 socket 进行通信吧

package test.helloworld.cmd;
// fallseir 2010-03-26
import sun.misc.Signal;
import sun.misc.SignalHandler;

public class SignalHandle {
	public static void main(String args[]){
		System.out.println("start");
		SignalHandle cmd=new SignalHandle();
		if(cmd.isLinux()){
			cmd.installSignalHandler("QUIT");
			cmd.installSignalHandler("HUP");
			cmd.installSignalHandler("USR1");
			cmd.installSignalHandler("USR2");
			cmd.installSignalHandler("PIPE");
		}
		cmd.installSignalHandler("TERM");
		cmd.installSignalHandler("ABRT");
		cmd.installSignalHandler("INT");
		try{
			Thread.sleep(1000*10*10);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
	private void handleSignal(String signal){
		System.out.println("handleSignal "+signal);
	}
	private boolean isLinux() {
		return System.getProperty("os.name").indexOf("Linux")>=0;
	}
	private void installSignalHandler(String signal){
		System.out.println("installCheckSignal "+signal);
		SimpleSignalHandler shandler=new SimpleSignalHandler();
		try{
			SignalHandler old = Signal.handle( new Signal( signal ), shandler);
			shandler.setOld(old);
		}catch(Exception e){
			System.err.println("installShutdownSignal "+signal+" "+e);
		}
	}
	class SimpleSignalHandler implements SignalHandler{
		SignalHandler old=null;
		public SimpleSignalHandler() {
		}
		public void handle( Signal sig ) {
			try{
				System.out.println("Handle Signal "+sig.getName() );
				handSignal(sig);
				if( old != null && old != SIG_DFL && old != SIG_IGN ) {  //chain back to previous handler if one exists
					old.handle( sig );
				}
			}
			catch( Throwable t ) {
				System.out.println(String.format("ShutdownSignalHandler.handle %s : %s",sig.getName(),t.getMessage())+t);
			}
		}
		protected void handSignal(Signal sig) {
			handleSignal(sig.getName());
		}
		public void setOld(SignalHandler old){
			this.old=old;
		}
	}
}

package test.helloworld.cmd;
// by fallseir 2010-03-26
public class ShutdownHook {
	public static void main(String args[]){
		System.out.println("start");
		ShutdownHook cmd=new ShutdownHook();
		cmd.installShutdownHook();
		try{
			Thread.sleep(1000*10*10);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
	private void shutdown(){
		System.out.println("shutdown");
	}
	private void installShutdownHook(){
		Runtime.getRuntime().addShutdownHook(new Thread(){
			public void run(){
				shutdown();
			}
		});
	}
}

sh 代码：

#!/bin/sh
# -----------------------------------------------------------------------------
# fallseir 2010-03-26
# Start/Stop Script for the test.helloworld.cmd.ShutdownHook system
# run.sh start|stop|check
#
base="."
lib="$base/lib"
log="$base/log"

app="run"
mainCls="test.helloworld.cmd.ShutdownHook"
pid="$app"".pid"

cp=""
#cp="$cp:$lib/log4j-1.2.13.jar"

cmd="java -cp $cp $mainCls $args"

ARG=$1
if [ "x$ARG" = "x" ] ; then
  ARG="start"
else
  shift
fi

if [ ! -d "$log" ] ; then
  mkdir "$log"
fi

if [ "$ARG" = "start" ] ; then
  AppErr="$log/$app.err"
  AppOut="$log/$app.out"
  # 备份历史日志
  if [ -f "$AppErr" ] ; then
    mv "$AppErr" "$AppErr".`date +%Y%m%d`"."$$
  fi
  if [ -f "$AppOut" ] ; then
    mv "$AppOut" "$AppOut".`date +%Y%m%d`"."$$
  fi
  # 在后台启动应用
  echo "$cmd $@ > $AppOut 2> $AppErr"
  $cmd "$@" > "$AppOut" 2> "$AppOut" &
  # 记录进程ID
  if [ ! -z "$pid" ] ; then
    echo $! > $pid
  fi
# 使用USR2 进行简单通信
#elif [ "$ARG" = "check" ] ; then
#  if [ ! -z "$pid" ]; then
#    echo "check: `cat $pid`"
#    kill -USR2 `cat $pid`
#  else
#    echo "Kill failed: \$pid not set"
#  fi
elif [ "$ARG" = "stop" ] ; then
  # kill 应用进程
  if [ ! -z "$pid" ]; then
    echo "Killing: `cat $pid`"
    kill -15 `cat $pid`
    rm $pid
  else
    echo "Kill failed: \$pid not set"
  fi
fi

<project>
    <!-- SDK properties -->
    <property name="SDK_HOME" value="D:\Program Files\Adobe\AdobeAIRSDK"/>
    <property name="ADL" value="${SDK_HOME}/bin/adl.exe"/>
    <property name="ADT.JAR" value="${SDK_HOME}/lib/adt.jar"/> 

    <!-- Project properties -->
    <property name="PROJ_ROOT_DIR" value="."/>
    <property name="APP_NAME" value="helloworld"/>
    <property name="APP_ROOT_DIR" value="${PROJ_ROOT_DIR}/src/html"/>
    <property name="APP_ROOT_FILE" value="${APP_NAME}.html"/>
    <property name="APP_DESCRIPTOR" value="${PROJ_ROOT_DIR}/${APP_NAME}-app.xml"/>
    <property name="AIR_NAME" value="${APP_NAME}.air"/>
    <property name="release"  location="${PROJ_ROOT_DIR}/release"/>
    <property name="assets"  location="${PROJ_ROOT_DIR}/src/assets"/>
    <property name="STORETYPE" value="pkcs12"/>
    <property name="KEYSTORE" value="sampleCert.p12"/> 

    <target name="init" depends="clean">
        <mkdir dir="${release}"/>
    </target> 

    <target name="test">
        <exec executable="${ADL}">
            <arg value="${APP_DESCRIPTOR}"/>
            <arg value="${APP_ROOT_DIR}"/>
        </exec>
    </target> 

    <target name="keystore" depends="init">
        <java jar="${ADT.JAR}" fork="true" failonerror="true">
            <arg value="-certificate"/>
            <arg value="-cn"/>
            <arg value="SelfSigned"/>
            <arg value="1024-RSA"/>
            <arg value="sampleCert.p12"/>
            <arg value="samplePassword"/>
        </java>
    </target> 

    <target name="package" depends="init">
        <java jar="${ADT.JAR}" fork="true" failonerror="true">
            <arg value="-package"/>
            <arg value="-storetype"/>
            <arg value="${STORETYPE}"/>
            <arg value="-keystore"/>
            <arg value="${KEYSTORE}"/>
            <arg value="${release}/${AIR_NAME}"/>
            <arg value="${APP_DESCRIPTOR}"/>
            <arg value="-C"/>
            <arg value="${APP_ROOT_DIR}"/>
            <arg value="${APP_ROOT_FILE}"/>
            <arg value="-C"/>
            <arg value="${assets}"/>
            <arg value="icons"/>
        </java>
    </target> 

    <target name="clean" description="clean up">
        <delete dir="${release}"/>
    </target> 

</project>

== 安装ant ==
1)、 下载最新版本的ant
2)、 安装ant
* 将ant安装包解压到安装目录
本文使用ant版本为 apache-ant-1.8.0
安装位置为 D:\Program Files\apache-ant-1.8.0
* 配置环境变量
添加变量 ANT_HOME = D:\Program Files\apache-ant-1.8.0
更新变量 PATH 在原有值后面添加 ;%ANT_HOME%\bin
* 测试
在命令行下输入 ant -v 查看ant版本
== 运行 Helloworld for java ==
* 编写 Helloworld.java
位置 E:\learn\ant\helloworld\src\oata\Helloworld.java

package oata;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

* 编译并运行HelloWorld程序

# 创建目标路径
> mkdir \a build\classes
# 编译java源文件
> javac -sourcepath src -d build\classes src\oata\HelloWorld.java
# 执行helloworld程序
> java -cp build\classes oata.HelloWorld
# 构建 jar 文件
## 创建 jar 描述文件
> echo Main-Class: oata.HelloWorld>myManifest
## 打包jar文件
> mkdir build\jar
> jar cvfm build\jar\HelloWorld.jar myManifest -C build\classes .
## 通过jar 文件运行 helloworld 程序
> java -cp build\jar\HelloWorld.jar oata.HelloWorld

== 使用 ant 脚本 编译并执行 helloworld 程序 ==
- E:\learn\ant\helloworld\build.xml

<project>
    <target name="clean">
        <delete dir="build"/>
    </target>
    <target name="compile">
        <mkdir dir="build/classes"/>
        <javac srcdir="src" destdir="build/classes"/>
    </target>
    <target name="jar">
        <mkdir dir="build/jar"/>
        <jar destfile="build/jar/HelloWorld.jar" basedir="build/classes">
            <manifest>
                <attribute name="Main-Class" value="oata.HelloWorld"/>
            </manifest>
        </jar>
    </target>
    <target name="run">
        <java jar="build/jar/HelloWorld.jar" fork="true"/>
    </target>
</project>

* 执行Ant脚本

# 执行ant脚本，编译打包并运行helloworld程序
> ant compile jar run
# 查看Ant项目中可用的Target
> ant -p

—————-
== 优化后的Ant脚本 ==

<project name="HelloWorld" basedir="." default="main">
    <property name="src.dir"     value="src"/>
    <property name="build.dir"   value="build"/>
    <property name="classes.dir" value="${build.dir}/classes"/>
    <property name="jar.dir"     value="${build.dir}/jar"/>
    <property name="main-class"  value="oata.HelloWorld"/>
    <target name="clean">
        <delete dir="${build.dir}"/>
    </target>
    <target name="compile">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}"/>
    </target>
    <target name="jar" depends="compile">
        <mkdir dir="${jar.dir}"/>
        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
            <manifest>
                <attribute name="Main-Class" value="${main-class}"/>
            </manifest>
        </jar>
    </target>
    <target name="run" depends="jar">
        <java jar="${jar.dir}/${ant.project.name}.jar" fork="true"/>
    </target>
    <target name="clean-build" depends="clean,jar"/>
    <target name="main" depends="clean,run"/>
</project>

参考:Hello World with Ant

关键步骤：
1、安装AIR环境
2、安装SDK
3、构建Helloworld项目
4、安装并测试Helloworld项目
==========================================
具体细节：
1、安装AIR环境
* 到Adobe下载AIR环境
* 安装AIR环境 ，本文使用的是 Adobe AIR 1.5.3.9130 版本
————————————————–
2、安装SDK
* 到Adobe下载SDK
* 将下载到的SDK包解压并放置到运行目录
本文下载的SDK版本为 adt version “1.5.3.9120″
本文SDK安装目录为 D:\Program Files\Adobe\AdobeAIRSDK
* 配置环境变量 将AIR SDK的工作路径添加到 PATH 变量中，（使adt和adl可以在任意目录以短路径方式启动）
PATH = [... 保持原有的PATH值不变];D:\Program Files\Adobe\AdobeAIRSDK\bin
————————————————–
3、构建Helloworld项目
* 创佳Helloworld项目
1)、创建Helloworld目录
本文全路径为 e:\learn\AIR\Helloworld
进入 Helloworld ，开始构建 helloworld 应用
除非明确说明 否则之后描述的文件和路径都是相对于此路径开始
2)、创建项目描述文件 HelloWorld-app.xml

<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://ns.adobe.com/air/application/1.5">
    <id>examples.html.HelloWorld</id>
    <version>0.1</version>
    <filename>HelloWorld</filename>
    <initialWindow>
        <content>HelloWorld.html</content>
        <visible>true</visible>
        <width>400</width>
        <height>200</height>
    </initialWindow>
</application>

3)、创建应用界面 HelloWorld.html

<html>
<head>
    <title>Hello World</title>
    <script type="text/javascript" src="AIRAliases.js"></script>
    <script type="text/javascript">
        function appLoad(){
            air.trace("Hello World");
        }
    </script> 

</head>
<body onLoad="appLoad()">
    <h1>Hello World</h1>
</body>
</html>

4)、测试应用
* 打开 cmd 并 cd 进入应用目录
* 运行命令 adl HelloWorld-app.xml
* > 系统将调用AIR运行时，启动一个400×200的窗口应用并呈现Helloworld字符
* > 系统在控制台输出 Hello World 字符
————————————————–
4、安装并测试Helloworld项目
1)、生成自签名证书和密钥对
* 运行命令 adt –certificate -cn SelfSigned 1024-RSA sampleCert.pfx samplePassword
* 系统将在当前目录生成密钥文件 sampleCert.pfx
2)、创建 AIR 安装文件
* 运行命令 adt -package -storetype pkcs12 -keystore sampleCert.pfx HelloWorld.air
HelloWorld-app.xml HelloWorld.html AIRAliases.js
* 根据系统提示输入密钥文件的密码 samplePassword
* 系统将根据 helloworld-app.xml 的描述生成AIR应用程序，并将helloworld.html 和 airaliases.js 当作附加资源嵌入AIR应用程序中
3)、安装 Helloworld 应用
* 双击 helloworld.air 或在命令行下执行 hellowrold.air 命令
* 系统调用本地的air运行时环境解释helloworld.air并开始应用安装
* 根据系统提示进行安装
4)、当安装完成后，通过双击helloworld的快捷方式或到安装目录打开helloworld.exe 即可运行helloworld应用
————————————————–
参考：
* 使用 AIR SDK 创建第一个基于 HTML 的 AIR 应用程序http://help.adobe.com/zh_CN/AIR/1.5/devappshtml/WS5b3ccc516d4fbf351e63e3d118666ade46-7ecc.html
——————————————
资源：
* 使用 HTML 和 Ajax 开发 Adobe AIR 1.5 应用程序
* 针对 HTML 开发人员的 AIR 语言参考
* Flex 3.2 语言参考
* Adobe AIR 开发人员中心

一、什么是CRM
CRM（Customer Relationship Management）客户关系管理
CRM 是一个围绕客户为中心的，通过IT手段，来增进客户沟通，提升客户关怀，从而影响客
户决策，并最终达到创利目的的企业经营策略。
其中的IT手段，通常指通过CRM系统来收集、分析和反馈客户行为数据，来更便利的实现同客户
的沟通和更有效的进行客户行为分析。

二、CRM 的组成
通常的CRM系统包含客户交互和行为分析两大部分。
1、客户交互
用于收集客户信息，记录客户行为日志，及对进行客户关怀和解答客户提问；
客户交互系统由电话呼叫中心(CTI)、短信(SMS)、邮件(EMAIL)、线上应用(WEB Site)、
及即时通讯(IM)等一切可能的方式整合在一起来实现同用户的交互，并收集用户行为。

2、行为分析
结合业务逻辑对客户行为日志进行分析，来为客户提供更具针对性的客户关怀；
通过对客户群体的行为日志进行统计，来评估往期的业务效果和指导未来的产品决策。

三、CRM 系统的成本
1、系统支持的交互平台、方式和规模
不同的交互平台（CTI、SMS、EMail、WEB Site、IM、…）及平台上的不同的实现方式（
人工客服、自助服务、主题活动、客户交流、客户关怀、…） 会有不同的效果的成本。
例如，一个极端的例子是一部电话通过全人工实现的电话客服和通过CTI实现的带有自助服务的
电话呼叫中心都被称作客服电话，用于进行客户服务和客户关怀。
2、系统支持的行为分析策略、数量和数据量级
分析策略需要根据不同的业务逻辑和客户行为数据进行定制，策略的个数和分析的行为数据量级
会对严重的影响到系统的结构和组织方式。
比如，从100条售后客户行为中找到来自北京的有跨地域维修记录的用户要比从1,000,000条客户
行为中分析更容易（大数据量的查找需要进行预处理才能达到可以接受的速度）。

四、CRM 系统的实施的前提
1、了解当前业务环境，分析业务领域并确认需求方向，规模
2、客观描述当前IT环境，以便系统可以尽可能的整合现有IT资源
3、确认需求和远景，确定必要的需求和可能的需求（圈地和画饼）

简单来说 CRM 就是通过同客户的交互对客户信息进行收集，并围绕对客户行为分析进行经营的策略。
CRM系统只是用于完成CRM的一个工具，前端的界面只是表象，卖点也许应该更直接的围绕这个工具
能直接或间接的为企业带来多少利润和加强了多少客户体验。

开启用户的su权限，使用su命令的用户必须存在与wheel组中
# pw groupmod wheel -m username
检查用户是否正确的添加到组中
# pw groupshow wheel

mount cdrom 映射光驱
# ll /dev/acd*
> acd0t01
# cd /cdrom
# touch CDROM-NOT-mounted-mcd.txt
# mount -t cd9660 /dev/acd0t01 /cdrom

- python
安装python
# cd /cdrom/packages
# pkg_add -p/home/app/python25 /cdrom/packages/python/python25-2.5.4_1.tbz
映射命令
# ln -s /home/app/python25/bin/python /usr/local/bin/python
– require
bsddb databases/py-bsddb
gdbm databases/py-gdbm
sqlite3 databases/py-sqlite3
tkinter x11-toolkits/py-tkinter

# pkg_add -p/home/app/sqlite3 /cdrom/packages/databases/sqlite3-3.6.11.tbz
映射错误的链接库
# ln -s /home/app/sqlite3/lib/libsqlite3.so.8 /usr/local/lib/libsqlite3.so.8
# cd /usr/local/lib/
# ln -s libsqlite3.so.8 libsqlite3.so
映射命令
# ln -s /home/app/sqlite3/bin/sqlite3 /usr/local/bin/sqlite3

- emacs 安装emacs编辑器
# pkg_add -p/home/app/emacs /cdrom/packages/editors/emacs-22.3.tbz
# ln -s /home/app/emacs/bin/emacs /usr/local/bin/emacs

解除绑定的光驱
#umount /cdrom

注：通过pkg_add 自动获取安装包
# pkg_add -r python
-r 选项将导致pkg程序自动从配置的packages网络镜像获取指定应用最新的安装包

[:p] –飞扬.轻狂 [fallseir.lee]

http://fallseir.livejournal.com

http://feed.feedsky.com/fallseir