All SensorInstaller subclasses should provide a constructor that accepts a SensorDescriber as an argument and calls the superclass constructor. This enables HackyInstaller to initialize itself correctly. This code is quite simple and has the following form in the case of SimpleSensor:

 public SimpleSensorInstaller(SensorDescriber sensor) throws ModelException {
    super(sensor);
  }

The install() method is called by HackyInstaller when the user requests that the sensor be installed. The SimpleSensor implementation of install() is:

  public void install () throws InstallerException, ModelException {
    try {
      // make sure paths are correct before installing sensor to the directory
      super.validateAllSensorPaths();
      Path path = super.pathManager.getPath("SIMPLESENSOR_HOME");

      // download sensor and set the new version number
      super.downloadToTempDir();
      super.removeOldSensor(path.getLocation());
      super.moveSensorFile(this.getSensorJarfileName(), path.getLocation());
      super.sensor.setVersion(Version.getServerVersion());

      // Write new information to hackyinstaller.xml.
      ConfigPersistor.getInstance().write(); 
    }
    catch (IOException e) {
      throw new InstallerException("Error contacting server for sensor files.", e);
    }
    catch (SAXException e) {
      throw new InstallerException("Could not retrieve version of sensor downloaded.", e);
    }
    catch (Exception e) {
      throw new InstallerException(e.getMessage(), e);
    }
    finally {
      Directory.deleteDir(this.sensorTempDir); // cleans up temporary directory
    }
  }

This code is also quite straightforward and uses a number of methods inherited from the super class. The validateAllSensorPaths() method ensures that any paths defined by the user are valid. Next, the downloadToTempDir() method finds the sensor.simplesensor.jar file on the Hackystat server and places it into a local temp directory. Next, any old versions of the SimpleSensor are removed, and the downloaded file is then placed into the directory. Finally, the Hackystat server version associated with this downloaded code is saved locally. This is used by HackyInstaller to detect whether an updated version exists at the server. The last step is to update the hackyinstaller.xml file with the updated sensor version information.

Note that in most cases, sensors can use this code almost unchanged, simply substituting you own HOME path variable for the one in this example.

The update() method is called from HackyInstaller when the user requests that the system download and install a new version of the sensor, if and only if the Hackystat server contains a more recent release. The code quite straightforward and looks like the following:

  public void update () throws ModelException, InstallerException {
    super.validateAllSensorPaths();
    if (!super.hasLatestVersion()) {
      this.install();
    }
  }  

The remove() method is called when the user requests that the sensor be uninstalled. The code checks to be sure that the sensor is installed, then deletes it, then update the hackyInstaller.xml file to indicate the sensor is no longer installed. It throws appropriate error messages as necessary:

  public void remove () throws ModelException, InstallerException {
    Path path = super.pathManager.getPath("SIMPLESENSOR_HOME");
    File simpleSensor = new File(path.getLocation(), super.getSensorJarfileName());

    // Check if sensor exists, throw exception if we can't find it. 
    if (!simpleSensor.exists()) {
      throw new InstallerException("Simple Sensor does not appear to be installed.");
    }
    // Delete sensor, throw exception if it doesn't get deleted.
    if (!simpleSensor.delete()) {
      throw new InstallerException("Error removing Simple Sensor.  File may be in use.");
    }
    // Update hackyinstaller.xml.
    super.sensor.setVersion("");
    ConfigPersistor.getInstance().write();
  }

The isEnabled() method is called by HackyInstaller when displaying the "summary" table in the opening window with the status of each sensor. By convention, each sensor defines a property called ENABLE_<SENSORNAME>_SENSOR that holds a value of true or false and indicates whether the installed sensor will actually run or not. This method simply returns the value of that property as a boolean.

  public boolean isEnabled () {
    PropertyManager properties = super.sensor.getPropertyManager();
    Property property = properties.getProperty("ENABLE_SIMPLESENSOR_SENSOR");
    return Boolean.valueOf(property.getValue()).booleanValue();
  }

The isInstalled() method should return true if the sensor is installed. One way to implement this is by checking to see whether the sensor file has been downloaded or not:

  public boolean isInstalled () throws ModelException {
    Path path = super.pathManager.getPath("SIMPLESENSOR_HOME");
    File buildSensor = new File(path.getLocation(), super.getSensorJarfileName());
    return buildSensor.exists();
  } 

After implementing the Installer XML definition file and SensorInstaller subclass, the next step is to integrate this code into the build. This requires a minor addition to the local.build.xml file, as discussed next.

Since we have made changes to the local.build.xml file, it is important to run AutoConfig so that the build system sees the addition of the pre-sensorshell target:

c:\svn\hackyCore_Build>ant -f autoconfig.build.xml
Buildfile: autoconfig.build.xml

run:
    [mkdir] Created dir: C:\svn\hackyCore_Build\build\autoconfig
     [echo] [AutoConfig] Generated modules.build.xml and sample.hackystat.build.properties.

autoconfig.build.default:

BUILD SUCCESSFUL
Total time: 1 second
c:\svn\hackyCore_Build>

c:\svn\hackyCore_Build>ant -q freshStart all.junit
     [echo] (16:02:01) Completed hackyCore_Build.checkModuleAvailability
     [echo] (16:02:02) Completed hackyCore_Build.hotUndeployHackystat
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
[hackyCore_Build.javac] Note: Some input files use unchecked or unsafe operations.
[hackyCore_Build.javac] Note: Recompile with -Xlint:unchecked for details.
     [echo] (16:02:24) Completed all.compile
     [echo] (16:02:47) Completed all.checkstyle
     [echo] (16:02:54) Completed all.install.pre-sensorshell
     [echo] (16:03:05) Completed hackyCore_Build.unjarSensorShellFiles
     [echo] (16:03:08) Completed hackyCore_Build.installSensorShell
     [echo] (16:03:41) Completed all.install.post-sensorshell
     [echo] (16:03:41) Completed hackyCore_Build.deployTestData
     [echo] (16:03:49) Completed hackyCore_Build.hotDeployHackystat
     [echo] (16:04:02) Completed hackyCore_Kernel.junit.
     [echo] (16:04:09) Completed hackyCore_Installer.junit.
     [echo] (16:04:09) Completed hackyCore_Statistics.junit.
     [echo] (16:04:22) Completed hackyCore_Report.junit.
     [echo] (16:04:32) Completed hackyCore_Common.junit.
     [echo] (16:04:34) Completed hackyCore_Telemetry.junit.
     [echo] (16:04:47) Completed hackySdt_Activity.junit.
     [echo] (16:04:50) Completed hackySdt_FileMetric.junit.
     [echo] (16:04:54) Completed hackySdt_WorkspaceMap.junit.
     [echo] (16:04:56) Completed hackySdt_DevEvent.junit.
     [echo] (16:04:59) Completed hackyDoc_SimpleSensor.junit.
     [echo] (16:04:59) Completed all.junitReport
     [echo] (16:04:59) Completed all.junit

BUILD SUCCESSFUL
Total time: 3 minutes 1 second
Sending build result to Hackystat server... Done!
c:\svn\hackyCore_Build>

To invoke the new HackyInstaller, change directories to hackyCore_Build/build/war/download. You should see a file called "hackyinstaller.jar" (as well as a file called "sensor.simplesensor.jar") in that directory. Either double-click the hackyinstaller.jar file (if your operating system supports that) or run "java -jar hackyinstaller.jar" from the command line. Figure 17.4, “ HackyInstaller main window ” illustrates the Main HackyInstaller window.

Figure 17.4.  HackyInstaller main window

This screen image shows the state of the HackyInstaller main window after we have reset the host to "http://localhost:8080/" (which is where the test server is running) and the key to "testdataset" (which is simply a test user account which we know to be defined after running junit tests). We have already clicked the "Verify Hackystat Host/Key" and the Status Log window indicates that HackyInstaller was able to contact the localhost and login with the user key.

The middle pane shows that SimpleSensor is available within HackyInstaller, but not yet installed locally. Let's fix that.

Figure 17.5, “ SimpleSensor configuration window (initial) ” shows the window that appears after we select SimpleSensor in the Sensor Settings pane and click "Configure Selected Sensor".

Figure 17.5.  SimpleSensor configuration window (initial)

This window shows us several things. First, it shows us the server version and the fact that we have no local version of the sensor (so an update is recommended). Second, we do not have the sensor enabled. Third, we must provide a home directory for the sensor code.

Figure 17.6, “ SimpleSensor configuration window (settings applied) ” illustrates the SimpleSensor configuration window after we have checked the "Enable simple sensor" checkbox, provided a home directory, and clicked on the "Apply" button to save the settings.

Figure 17.6.  SimpleSensor configuration window (settings applied)

Now we are finally ready to download and install the sensor.

Figure 17.7, “ SimpleSensor configuration window (sensor installed) ” illustrates the state of the SimpleSensor configuration window after pressing the "Update" button. You can see that the local version of the sensor now matches the server version.

Figure 17.7.  SimpleSensor configuration window (sensor installed)

Figure 17.8, “ SimpleSensor home directory ” illustrates the contents of our SimpleSensor "home" directory after having installed the sensor. The file sensor.simplesensor.jar is now located in that directory and ready to be used to collect DevEvents.

Figure 17.8.  SimpleSensor home directory

Note that although HackyInstaller was configured to obtain the SimpleSensor jar file from localhost, the SimpleSensor itself is independent from its "point of origin". In other words, if the user now went into HackyInstaller and changed the Hackystat Host property from "http://localhost:8080/" to "http://hackystat.ics.hawaii.edu", the next time SimpleSensor ran, it would retrieve this new host location from the sensor.properties file and send its DevEvent data to http://hackystat.ics.hawaii.edu instead.

	Don't forget to revert your sensor.properties and hackyinstaller.xml files!
	Just a friendly reminder that after playing around with your sensor definition and insuring that it works with HackyInstaller, you should not forget to revert your sensor.properties and hackyinstaller.xml files back to their previous states. Otherwise, you will be sending your development data to your local test server, which is almost certainly not what you want to do!