早期地下采煤的时候，矿井中的金丝雀常常拥有短暂而有价值的一生。因为它们对于甲烷和一氧化碳等致命毒气特别敏感，从栖木上掉下来的金丝雀是一个明显的信号，告诉矿工是时候离开了。过一段时间之后，假如 新换上的金丝雀安然无恙，矿工们又可以安全地重返矿井。
　　您的软件项目也可以有自己的矿井金丝雀。假如 您在运用 CruiseControl 之类的持续集成工具，那么很可能熟悉当构建失败时发送给团队的电子邮件消息。这是一个信号，说明项目代码中有些地点 须要 马上改正。但是，当收件箱中还有很多其他邮件时，这些消息有时候会被忽略。然后，在知晓 消息之前，我已经从有疑问 的储存库中更新了本地副本，或者直接回家了，让团队中的其他人直抱怨。
　　这时须要 某种高度可视的东西，就像金丝雀一样，高速 一瞥后就能发觉 持续构建流程 的状态。我的金丝雀是一种新的来自 Sun Microsystems 的开源技能 ，它的名称是 Sun Small Programmable Object Technology（SPOT）。本文推荐 SPOT，并展示如何 建立用于监视 CruiseControl 的构建监视器。
什么是 SPOT？
　　SPOT（见 图 1）是运行 Java™ 程序的小型无线装备。SPOT 载有很多传感器，用于监视它的环境，还有一组多彩 LED 用于与外部通信，以及两个用于提供基本反馈的按钮。我运用 LED 来显示构建的状态。可以通过一条 USB 线将一些 SPOT 连接起来，作为一个基站，其他 SPOT 可以通过这个基站访问工作站上的资源，例如数据库或 Web 运用 程序。 

图 1. Sun SPOT
取得 SPOT
　　假如 要取得 一些 SPOT，以便组成自己的构建监视器，那么可以通过 Sun SPOT World购买工具包。在工具包中，有两个 SPOT 和一个基站，一些 USB 线缆，以及放在 CD 中的 SDK。这种工具包有时候会脱销（而且仍然比较贵），但是不要因此而耽误进程。随 SDK 还附带了一个名为 Solarium 的模拟器，这意味着可以在虚拟 SPOT 上马上开始工作。
　　安装 SDK 后，可以探索示例运用 程序、开发人员指南、技能 规范、源代码和一些项目描述，例如运用 SPOT 控制 Web 相机。
　　SPOT 由以下硬件元件组成：
　　主处理器是一个 180MHz Atmel AT91RM9200 系统芯片（system-on-chip）。
每个 SPOT 有 4MB Flash RAM 和 512K 伪静态 RAM。
　　电力由内部充电电池（圆柱形锂电池）、外接电源或 USB 主机提供。
　　电池充电后可无间断运用 大约 3 小时。当无事发生时，它执行 休眠，从而延长运用 寿命。
　　演示子板包含温度和光传感器、一个三轴加快 计、8 个三色 LED 以及两个按钮开关。必要时，还可以通过 5 个通用 I/O 插脚和 4 个高电流输出插脚添加 更多的子板。
　　无线通信通过一个遵从 IEEE 802.15.4 的收发器完成，该收发器采用 2.4GHz-to-2.4835GHz 免授权频段。 
　　在这样的硬件上，SPOT 运行一个名为 Squawk 的小型 JVM，这个 JVM 几乎完全是用 Java 语言编写的。Squawk 遵从 Connected Limited Device Configuration（CLDC）1.1 Java Micro Edition（Java ME）配置。它无需底层操作系统便可运行 — 也就是所谓的 “在裸机上运行”。
计算物理系统
　　SPOT 是计算物理系统的一个例子。计算物理系统中有一些嵌入的装备，这些装备运行可感知环境并作出反应的软件和通信协议。
　　用于 SPOT 的运用 程序是根据 Java ME MIDlet 编程模型编写的。这意味着每个 SPOT 上的 JVM 以类似于 Java EE 下维护 servlet 和 Enterprise JavaBeans（EJBs）的方式来维护 MIDlet 的生命周期。但是，由于 MIDlet 运行环境的限定 ，CLDC 以 JDK 1.3.1 作为开始的基础，剥离所有不必要的部分。因此，SPOT 程序无法访问文件流；没有反射，没有串行化，没有本地法，没有正则表达式，没有 Swing，只有有限的数据类型。独一可用的集合数据结构是向量栈、枚举和 hash 表。有些特定于 CLDC 的连接类被添加到这个子集中，但是编程流程中仍然要受很多限定 。
为SPOT 编写、构建和部署代码
　　为SPOT 编写、构建和部署代码特别基本 ，可以运用自己挑选的IDE。例如，若要在 Eclipse 中执行 开发：
　　建立一个规则的 Java 项目，删除默认的JRE。
　　将SPOT SDK的 lib文件夹中的以下 JAR 添加到 classpath： 
　　transducer_device.jar
　　multihop_common.jar
　　spotlib_device.jar 

spotlib_common.jar
　　squawk_device.jar
　　在 resources/META-INF 目录中建立一个MANIFEST.MF文件。该文件包含 Squawk VM用于运行程序的信息。例如，清单1是我的构建监视器的manifest文件： 
清单 1. resources/META-INF/MANIFEST.MF 文件的内容
MIDlet-Name:　BuildCanary　
MIDlet-Version:　1.0.0　
MIDlet-Vendor:　Craig　Caulfield　
MIDlet-1:　Build　Canary,　,　speck.buildmonitor.BuildCanary　
MicroEdition-Profile:　IMP-1.0　
MicroEdition-Configuration:　CLDC-1.1　
BaseStationAddress:　0014.4F01.0000.3A3C　
PortNumber:　100　
　　清单1中最首要的一行是：
MIDlet-1:　Build　Canary,　,speck.buildmonitor.BuildCanary
　　第一个参数是运用 程序的名称，第三个参数是运用 程序主类的完全限定类名。
　　可以在该文件中添加自己的属性，并在运行时读取这些属性，例如：
String　baseStationAddress　=　getAppProperty("BaseStationAddress");
　　建立 一个扩展 javax.microedition.midlet.MIDlet 的类，然后开始开发运用 程序。
　　当准备好部署代码时，将代码打包到一个 JAR 中，通过无线的方式将它发送到 SPOT： 
　　运用 USB 线将一个基站 SPOT 连接到工作站。
　　执行 SPOT SDK 安装目录中的 ant startbasestation，启动基站。
　　执行以下命令部署 JAR：
ant　-DremoteId=0014.4F01.0000.3A19　deploy 
　　下载中提供了 build-canary 运用 程序的 Eclipse 项目，可以以此为基础。
运用程序概述
　　图 2 中的部署图展示我如何 配置 构建监视器，以监视 CruiseControl 构建。

图 2. 构建监视器的部署图

CruiseControl 循环构建在一个构建服务器上运行，该构建服务器有一个通过 USB 线连接的 SPOT 基站。每当构建的当前状态（SUCCESS、FAILED 或 RUNNING）改动时，构建服务器上都会调用一个基本的Java SE运行程序 — CanaryHandler。然后，通过基站 SPOT 将一条无线消息发送到BuildCanary— 远程 SPOT 上运行的一个MIDlet—以更新该SPOT的LED，从而反映构建的新状态。
CanaryHandler 代码
　　为了让 CanaryHandler 程序有一个良好的开端，我运用 Apache Commons CLI 分析 命令行参数。CLI 负责收集和验证参数，并提供方便的帮助功能。例如，假如输入java CanaryHandler --help，可以看到清单 2 中的输出：
清单 2. CanaryHandler 的帮助文本
usage:java　CanaryHandler　(--running　　--failed　　--success)　--spot　　"0014.4F01.xxxx.yyyy"　--port　100　--serial　COM4　This　program　connects　with　a　remote　Sun　SPOT　to　set　a　colour　to　denote　the　current　state　of　the　Continuous　Integration　build　process.　
　-a,--spot　<spot>　　The　IEEE　wireless　address　(like　　0014.4F01.0000.30E0)　of　the　SPOT　(enclose　in　double　quotes).　
　-c,--serial　<serial>The　serial　port　(e.g.　COM4)　to　which　the　SPOT　base station　is　attached.　
　-f,--failed　　The　build　has　failed.　
　-h,--help Print　this　usage　information.　
　-p,--port　<port>　　The　port　address　(range　32　to　255)　to　be　used　for　communicating　with　the　SPOT.　
　-r,--running The　building　is　running　
　-s,--success　The　building　was　successful.　
For more instructions see the Javadoc　in　the　docs/api　directory.　
从 清单 2 中可以看到，CanaryHandler 接受 4 个参数：
　　构建的当前状态，可能的值有： 
　　Running（SPOT 的 LED 中显示蓝色流光）。
　　Failed（SPOT 的 LED 闪烁红色）。
　　Successful（SPOT 的 LED 显示为不动的绿条）。
　　一个远程 SPOT 的地址。每个 SPOT 由一个 64 位的 IEEE 无线地址标识，该地址以 0014.4F01 开头，后面再加上两个四位字节，从而惟一地标识 SPOT。
　　一个端口号，惟一地标识基站与远程 SPOT 之间的连接。
　　一个串行端口，标识构建服务器上与基站连接的串行端口。
　　分析 命令行参数后，CanaryHandler 打开与远程 SPOT 的 radiostream 连接，如清单 3 所示：
清单 3. CanaryHandler 中的 main() 要领 
/**　
　*　Respond　to　the　state　a　continuous　build　process　by　setting　the　LEDs　on　a　
　*　remote　SPOT　accordingly.　This　is　done　by　writing　a　simple　message　to　an　
　*　output　stream,　on　the　end　of　which　is　a　SPOT　waiting　to　read.　
　*　
　*　@param　args　the　command　line　arguments.　See　the　printUsage　
　*　method　further　down　for　a　full　description　of　the　parameters.　
　*/　
public　static　void　main(String[]　args)　throws　IOException　{　
　
　　createCommandLineParser();　
　　StreamConnection　connection　=　null;　
　　DataOutputStream　dos　=　null;　
　　DataInputStream　dis　=　null;　　
　　try　{　　
　　　　CommandLine　commandLine　=　parser.parse(options,　args);　
　　　　String　spotAddress　=　commandLine.getOptionValue("spot");　
　　　　String　port　=　commandLine.getOptionValue("port");　
　　　　String　spotConnection　=　"radiostream://"　+　spotAddress　+　':'　+　port;　
          System.setProperty("SERIAL_PORT",　commandLine.getOptionValue("serial"));　
　　　　　log.info("Setting　address　to　"　+　spotConnection);　　
　　connection= (StreamConnection)　Connector.open(spotConnection);　
　　　　dos　=　connection.openDataOutputStream();　
　　　　dis　=　connection.openDataInputStream();　
　　　　if　(commandLine.hasOption("running"))　{　　
　　　　　　log.info("Setting　build　state　to　RUN.");　
　　　　　　dos.writeUTF("RUN");　
　　　　　　dos.flush();　
　　　　　　log.info("SPOT　responded　with:　"　+　dis.readUTF());　　
　　　　}　else　if　(commandLine.hasOption("failed"))　{　　
　　　　　　log.info("Setting　build　state　to　FAIL.");　
　　　　　　dos.writeUTF("FAIL");　
　　　　　　dos.flush();　
　　　　　　log.info("SPOT　responded　with　"　+　dis.readUTF());　　
　　　　}　else　if　(commandLine.hasOption("success"))　{　　
　　　　　　log.info("Setting　build　state　to　SUCCESS.");　
　　　　　　dos.writeUTF("SUCCESS");　
　　　　　　dos.flush();　
　　　　　　log.info("SPOT　responded　with　"　+　dis.readUTF());　　
　　　　}　else　{　　
　　　　　　printUsage(options);　
　　　　　　System.exit(1);　　
　　　　}　　
　　}　catch　(ParseException　e)　{　　
　　　　//　This　will　be　thrown　if　the　command　line　arguments　are　malformed.　
　　　　printUsage(options);　
　　　　System.exit(1);　
　　}　catch　(NoRouteException　nre)　{　　
　　　　log.severe("Couldn't　get　a　connection　to　the　remote　SPOT.");　
　　　　nre.printStackTrace();　
　　　　System.exit(1);　　
　　}　finally　{　　
　　　　if　(connection　!=　null)　{　
　　　　　　connection.close();　
　　　　}　　
　　　　System.exit(0);　
　　}　
}　 
radiostream 协议类似于点对点套接字连接，它为基站与远程 SPOT 之间提供可靠、有缓冲的基于流的 I/O。另外，还打开数据输入和输出流。然后，一条关于构建的基本 的消息被写到输出流，远程 SPOT 读取该消息，然后返回一条简短的确认消息。接着 CanaryHandler 结束，等待下一次构建状态改动 时再次被调用。
BuildCanary 代码
　　当 CanaryHandler 打开一个 radiostream 连接并发送一条关于构建的基本 消息时，连接的另一端是 BuildCanary，它是部署在远程 SPOT 上的一个 Java ME MIDlet。MIDlet 与 servlet 和 EJB 类似，也是实现一个专门的接口，运行时环境负责在它的生命周期中的某些时候调用某些要领 。
　　例如，MIDlet 的典型的入口点是 startApp() 要领 。在 BuildCanary 中，startApp() 委托给另一个要领 ，后者又产生一个线程，以侦听来自 CanaryHandler 的消息。清单 4 显示 BuildCanary 的入口点的代码：
清单 4. BuildCanary 的入口点
/**　
　*　MIDlet　call　to　start　our　application.　
　*/　
protected　void　startApp()　throws　MIDletStateChangeException　{　
　　run();　
}　　
/**　
　*　Main　application　run　loop　which　spawns　a　thread　to　listen　for　updates　
　*　about　the　build　status　from　the　host.　
　*/　
private　void　run()　{　　
　　//　Spawn　a　thread　to　listen　for　messages　from　the　host.　
　　new　Thread()　{　　
　　　　public　void　run()　{　
　　　　　　try　{　　
　　　　　　　　updateBuildStatus();　　
　　　　　　}　catch　(IOException　ex)　{　　
　　　　　　　　try　{　
　　　　　　　　　　if　(connection　!=　null)　{　
　　　　　　　　　　　　connection.close();　
　　　　　　　　　　}　　
　　　　　　　　　　if　(dos　!=　null)　{　
　　　　　　　　　　　　dos.close();　　　　　　　　　　　}　　
　　　　　　　　　　if　(dis　!=　null)　{　
　　　　　　　　　　　　dis.close();　
　　　　　　　　　　}　　
　　　　　　　　　　ex.printStackTrace();　
　　　　　　　　}　catch　(IOException　ex1)　{　
　　　　　　　　　　//　Can't　do　much　now.　
　　　　　　　　　　ex1.printStackTrace();　
　　　　　　　　}　
　　　　　　}　
　　　　}　
　　}.start();　
}
updateBuildStatus() 要领 处理 MIDlet 的首要 工作，如清单 5 所示：
清单 5. 侦听 CanaryHandler 发送的消息的要领 
/**　
　*　Reflect　the　status　of　the　continuous　build　process　taking　place　on　the　
　*　host　PC　by　setting　the　colours　of　the　SPOT's　LEDs　appropriately.　
　*/　
private　void　updateBuildStatus()　throws　IOException　{　　
　　setColour(LEDColor.WHITE,　"");　　
　　String baseStationAddress=getAppProperty("BaseStationAddress");　
　　String　portNumber　=　getAppProperty("PortNumber");　
　　String　connectionString="radiostream://"　+　baseStationAddress　+　':'　+　portNumber;　　
　　//　Open　a　connection　to　the　base　station.　
 connection=(RadiostreamConnection)　Connector.open(connectionString);　
　　dis　=　connection.openDataInputStream();　
　　dos　=　connection.openDataOutputStream();　
　　　while　(true)　{　　
　　　　//　dis　will　block　here　forever　until　it　has　something　from　the　host　
　　　　//　to　read.　
　　　　String　buildStatus　=　dis.readUTF();　　
　　　　if　(buildStatus.equals("RUN"))　{　　
　　　　　　setColour(LEDColor.BLUE,　buildStatus);　　
　　　　}　else　if　(buildStatus.equals("SUCCESS"))　{　　
　　　　　　setColour(LEDColor.GREEN,　buildStatus);　　
　　　　}　else　if　(buildStatus.equals("FAIL"))　{　　
　　　　　　setColour(LEDColor.RED,　buildStatus);　　
　　　　}　else　{　
　　　　　　throw　new　IllegalArgumentException("The　build　status　of　"　+　buildStatus　+　"　isn't　recognised.");　
　　　　}　　
　　　　dos.writeUTF("Build　status　updated　to　"　+　buildStatus);　
　　　　dos.flush();　
　　}　
}　 
该要领 最先 将所有 LED 变成白色，示意 SPOT 就绪。然后，与 CanaryHandler 类似，它打开一个 radiostream 连接以及数据输入和输出流。但是，在这里，它最先 尝试从输入流读一条消息，并阻塞直到收到消息。
　　如清单 6 所示，当收到一条消息时，setColour() 要领 产生另一个线程，以更新 SPOT 上的 LED 的颜色。然后，BuildCanary 回到 while 循环的顶端，等待下一条消息。
清单 6. 产生一个配置 颜色的新线程
/**　
　*　Set　a　colour　for　the　LEDs　to　display.　
　*　
　*　@param　colour　an　LEDColor　value.　
　*　@param　buildStatus　the　current　status　if　the　build.　
　*/　
private　void　setColour(final　LEDColor　colour,　final　String　buildStatus)　{　　
　　if　(colourThread　!=　null)　{　　
　　　　colourThread.interrupt();　　
　　}　　
　　setColour　=　new　SetColour(colour,　buildStatus);　
　　colourThread　=　new　Thread(setColour);　
　　colourThread.start();　
}　
　　与此同时，真实 操作 LED 是在 SetColour 类中，如清单 7 所示：
清单 7. 操作 LED 的内部类
/**　
　*　An　inner　class　to　handle　the　colour　and　behaviour　(flashing,　solid,　
　*　running)　of　the　LEDs　of　a　SPOT.　
　*/　
public　class　SetColour　implements　Runnable　{　　
　　/***　A　reference　to　the　SPOTs　LEDs　so　they　can　be　set　according　to　the　
　　　*　state　of　the　build.　
　　　*/　
　　private ITriColorLED[] leds　=　EDemoBoard.getInstance().getLEDs();　　
　　/**　
　　　*　The　RGB　colour　to　set　the　LEDs　to.　
　　　*/　
　　private　LEDColor　colour;　　
　　/**　
　　　*　The　current　status　of　the　build.　This　will　be　used　to　set　the　behaviour　of　the　LEDs　(flashing,　solid,　running).　
　　　*/　
　　private　String　buildStatus;　　
　　public　SetColour(LEDColor　colour,　final　String　buildStatus)　{　
　　　　this.colour　=　colour;　
　　　　this.buildStatus　=　buildStatus;　
　　}　　
　　public　void　run()　{　　
　　　　try　{　　
　　　　　　if　(buildStatus.equals("RUN"))　{　　
　　　　　//　Display　running　LEDs.　
　　　　　　　　while　(true)　{　　
　　　　　　　　　　for　(int　i　=　0;　i　<　8;　i++)　{　　
　　　　　　　　　　　　leds[i].setColor(colour);　
　　　　　　　　　　　　leds[i].setOn();　
　　　　　　　　　　　　Thread.sleep(200);　
　　　　　　　　　　　　leds[i].setOff();　
　　　　　　　　　　}　
　　　　　　　　}　　
　　　　　　}　else　if　(buildStatus.equals("FAIL"))　{　　
　　　　　//　Flash　the　LEDs　on　and　off.　
　　　　　　　　while　(true)　{　　
　　　　　　　　　　for　(int　i　=　0;　i　<　8;　i++　)　{　
　　　　　　　　　　　　leds[i].setColor(colour);　
　　　　　　　　　　　　leds[i].setOn();　
　　　　　　　　　　　}　　
　　　　　　　　　　Thread.sleep(250);　　
　　　　　　　　　　　for　(int　i　=　0;　i　<　8;　i++　)　{　
　　　　　　　　　　　　leds[i].setOff();　　
　　　　　　　　　　　}　　
　　　　　　　　　　Thread.sleep(250);　
　　　　　　　　}　　
　　　　　　}　else　{　　
　　　　　//　Display　the　LEDs　as　a　solid　bar.　
　　　　　　　　for　(int　i　=　0;　i　<　8;　i++)　{　
　　　　　　　　　　leds[i].setColor(colour);　
　　　　　　　　　　leds[i].setOn();　
　　　　　　　　}　
　　　　　　}　　
　　　　}　catch　(InterruptedException　ie)　{　
　　　　//　Do nothing. Just bail　out　so　we　can　set　the　LEDs　to　another　colour.　
　　　　}　
　　}　
}
清单7 为 SPOT 的8 个LED 分别配置 颜色，并根据构建的状态打开或关上 这些 LED。
　　下一步是将构建监视器附加到持续构建流程 。 
CruiseControl 配置
　　当 CruiseControl 开始时，它在一个连续循环中运行，周期性地检验源代码库，例如 Subversion，然后从头开始构建和测试项目。然后，CruiseControl 可以将构建成功或失败的状态揭晓 到站点 上，供所有人查看，并发出各种不同的消息。
　　CruiseControl 循环的行为由一个 XML 配置文件 config.xml 示意 ，如清单 8 所示：
清单 8. CruiseControl 配置文件
<cruisecontrol>　　
　　<property　environment="env"/>　
　<property name="local.directory"　value="C:/data/skills/development/builds"/>　
　　<property　name="repository"　value="http://kimba/svn"/>　
　<property name="javaExecutable"　value="C:/applications/java/jdk1.6.0_14/bin/java.exe"/>　
　<property name="workingDirectory"　value="C:/data/skills/development/java/micro/netbeans/sunspots/CanaryHandler/dist"/>　
               <property name="libraryPath"　value="-Djava.library.path=C:/applications/Sun/　SunSPOT/sdk-red-090706/lib"/>　
　　<property　name="commonArguments"　value="${libraryPath}　-jar　
　　　　　　　　　　　　${workingDirectory}/CanaryHandler.jar　
　　　　　　　　　　　　--spot　"0014.4F01.0000.3A19"　
　　　　　　　　　　　　--port　100　
　　　　　　　　　　　　--serial　COM4"/>　　
　　<plugin　name="log"　dir="${logdir}"/>　
　　<plugin　name="svn"　classname="net.sourceforge.cruisecontrol.sourcecontrols.SVN"　
　　　　　　　　　　　username="cruise"　
　　　　　　　　　　　password="catbert"/>　　
　　<project　name="developer-ci-build"　buildafterfailed="false">　　
<!--　Defines　where　CruiseControl　looks　for　changes　to　decide　whether　to　run　the　build.　-->　
　　　<modificationset　quietperiod="30">　<svn　localWorkingCopy="${local.directory}/checkout/SunDeveloper"　　　　　　　　　　repositoryLocation="${repository}/DEVELOPER/trunk/SunDeveloper"/>　
　　　</modificationset>　　
<!--　Check　for　modifications　every　60　seconds　-->　
　　　<schedule　interval="60">　
　　　　　<composite>　
　　　　　<exec　command="${javaExecutable}"　args="${commonArguments}　　--running"/>　
　　　　　<maven2 mvnhome="${env.MAVEN_HOME}"　pomfile="${local.directory}/checkout/SunDeveloper/pom.xml"　
　　　goal="clean　　scm:update　　compile"/>　
　　　　　</composite>　
　　　</schedule>　　
　　　<listeners>　
　<currentbuildstatuslistener　  file="${local.directory}/logs/${project.name}/buildstatus.txt"/>　
　　　</listeners>　　
<!--　The　publishers　are　run　when　a　build　completes　one　way　or　another.　-->　
　　　<publishers>　
　　　　　<onsuccess>　
　　　　　　<execute　command="${javaExecutable}　${commonArguments}　--success"/>　
　　　　　</onsuccess>　
　　　　　<onfailure>　
　　　　　　<execute　command="${javaExecutable}　${commonArguments}　--failed"/>　
　　　　　</onfailure>　
　　　</publishers>　
　　</project>　　
</cruisecontrol>