The question is how to do it in a usable way…

The above picture shows how a view might look like. The view is showing both the Lint warnings collected by the Warnings plugin and C++ Test warnings collected using the Cpptest plugin.

So what is needed to accomplish this?

First a more competent view plugin is needed, the Sectioned View Plugin, found here.

This could enough since there is a section called Job Graphs Section, it can display some types of graphs.

So what is needed to display the graphs in a more suitable format?

Collect all the image links for the graphs to be displayed in the view, this is done by:

• Finding the graph image in the jobs
• Fetching the links to the graphs image for each of the graphs, it is something like
  http://example.com/job/Job1/Cpptest/trendGraph/png
• Optionally strip the domain from the url so it would look something like this:
  /job/Job1/Cpptest/trendGraph/png
  /job/Job1/warnings/trendGraph/png

To include the graphs in the view a Text Section is used. In the text html code can be used, so it is possible to create some fancy layout here.

This is the code used to display the two graphs, it creates a table with two columns, and displays a graph in each:

<table>
  <tr>
    <td width="50%"><strong>C++Test</strong></td>
    <td width="50%"><strong>Lint</strong></td>
  </tr>
  <tr>
    <td width="50%">
      <a href="/job/Job1/lastBuild/">
        <img width="375px" height="150px" src="/job/Job1/Cpptest/trendGraph/png" />
      </a>
    </td>
    <td width="50%">
      <a href="/job/Job2/lastBuild/">
        <img width="375px" height="150px" src="/job/Job2/warnings/trendGraph/png" />
      </a>
    </td>
  </tr>
</table>

The possibilities are limitless (or at least limited to what html can handle).

After some searching i found an Eclipse plug-in called ShellEd

The installation process below:

Prerequisites:
* Dynamic Languages Toolkit – Core Frameworks version 3.0.0.0, available in the Indigo repository.
* Man page viewer – update site http://download.eclipse.org/technology/linuxtools/updates-nightly/

After the prerequisites have been installed the plug-in can be added. There is a link to an unofficial update site here and more information about the installation can be found here.

After a restart i can now open bash files with syntax highlighting.

After a bit of searching I found a great guide here.

The original post is much more detailed, here is a short summary.

Finding the button code on the mouse
Step one is to install the needed applications

> sudo apt-get install xvkbd xbindkeys x11-utils

Next find the mouse button codes. This is done by starting the xev application and check which button codes are used by clicking in the popup window.

> xev | grep ', button'
    state 0x0, button 6, same_screen YES
    state 0x0, button 6, same_screen YES
    state 0x0, button 7, same_screen YES
    state 0x0, button 7, same_screen YES

From this output I can see that button 6 should be back and 7 forward.

Adding the button binding
Now that we have the button codes, we add them to the binding file

> gedit ~/.xbindkeysrc

And connect the back to ALT-Left and forward to ALT-Right

"/usr/bin/xvkbd -xsendevent -text "\[Alt_L]\[Left]""
  m:0x0 + b:6
"/usr/bin/xvkbd -xsendevent -text "\[Alt_L]\[Right]""
  m:0x0 + b:7

Test the new bindings by starting the xbindkeys application

> xbindkeys

Make it work after a restart
To make the xbindkeys application to start at login add an entry in System > Preferences > Startup Applications.

For detailed instructions and explanations read the original post at http://chrisjean.com

If you don’t know what continuous integration is read more here

Basically a CI tool can perform the same action on a trigger. This trigger can be time 00:00 each night. Except for doing builds and tests of the software I develop at home I use Jenkins-CI to monitor the disk space usage on my server.

In this example I uses a bash script executing df and the Plot plugin

On my server I have two disks that I want to monitor, /nas/data and /nas/share. To be able to plot the available disk space I query the system for available disk space in GB and put the output value into java properties files, using a bash script. See below:

#!/bin/bash
echo "YVALUE="`df -B 1073741824 | grep /nas/share | awk -- '{print $3}' | tr -d %` > disk-used_share.properties
echo "YVALUE="`df -B 1073741824 | grep /nas/data | awk -- '{print $3}' | tr -d %` > disk-used_data.properties
cat disk-used_share.properties
cat disk-used_data.properties

To trigger this script I use the Build trigger -> Build periodically set to @daily (once a day)

For visualization I provide the above created files to the plot plugin, and are using the following settings:

• Plot group – Name for the plot group
• Plot title – Any good name for the plot
• Number of builds to include – ~50 (use something appropriate here)
• Plot y-axis label – GB
• Plot style – line

Series 1:

• Data series file – disk-used_share.properties
• Data series legend label – Share

Series 2:

• Data series file – disk-used_data.properties
• Data series legend label – Data

On my test server I get the following plot, which indicates if anything is wrong:

As I believe it is a mean to perform a task in the same way every time something changes. The trigger for a change can be a check-in of some code into a Configuration Management (CM) system like svn, git, or Serena Dimensions or something completely different like a time based trigger.

CI is starting to get a foothold in the software development community since it saves development time, which is the same as money. CI can be automated or manual, below I will have focus on an automated process using a tool.

Before CI
Think of the following scenario (which is quite normal):

• A team of 5 developers are developing their own modules for a product which is due to be released 3 months from now.
• Each member of the development team perform a check-in actions into the CM system once a week.
• After two months the systems integrator fetches the code from the CM system and tries to build it for a first test – he/she gets an avalanche of build errors and warnings, the components don’t fit together at all, interfaces are wrong, return codes are note tested, etc.
• Now a pain-staking process to sync the interfaces together starts, it might even go as bad as starting a “blame-game” whose fault it is, or who made the mistakes.
• The product is finished after 5 months.

When CI has been introduced

• The same team is going to develop the same modules as above.
• Since there is a CI system available, the build process is the first thing that is decided (and developed).
• The CI system is configured to build and integrate (even run tests when they are available) on each check-in of new code into the CM system.
• Each developer is told to do a check-in as soon as the code compiles.
• During the first two months the CI system checks-out the code from the CM system in each check-in (commit in svn), builds it and run available tests. This is now occurring several times a day (as soon as a developer feel confident with a change).
• When the CI system finds an error it reports it, could be that one of the developers mistakenly changed an interface. If an error is found the developer is alerted and are able to fix the problem directly.
• Now two months has gone by, and since the product code has been built and tested each time a check-in into the CM system has been performed, the systems integrator has an easier job to integrate everything. The first checkout probably will build and get PASSED on all the tests.
• The product can even be finished after 2,5 months.

Why is this, why might the development time be shorter?
The advantage of doing a development process automated using a CI tool, is that when a problem arises. The developer that might have done a mistake, forgotten an interface change, or any other programming issue, will be notified directly after the check-in. This quick feedback on a problem comes when the recent changes, which broke the build, are fresh, so the effort for fixing the problem is a lot less when it is found than after 3 weeks.

A more professional explanation of CI can be found on the CI Wikipedia page.

Currently I’m using a tool for continuous integration both for my home development and for the development I do at work. The tool I use is Jenkins, read more here

The setup I use at home is:

• Ubuntu NAS server – is running the Plex Media Server for Linux serving media to all my clients
• Mac Mini Media Client – connected to the TV and running Plex Client
• A MacBook Pro – where the Plex Client is installed
• I also have an iPad and an iPhone running the Plex iOS client

Everything works fine when I’m connected on the same network as the Plex Media Server, but sometimes I’m traveling and still wants access to my media. After a bit of searching I found a perfect solution.

I found the solution here on the plex wiki.

By simply issuing two command line commands I’m able to access my home media from wherever I am.

The commands are:

dns-sd -R PMS _plexmediasvr._tcp . 32400 &
ssh -N -L 32400:localhost:32400 x.x.x.x -l username -p 22

These two line does the following:

• The dns-sd command adds a dns entry to the local domain on the port which Plex searches
• The ssh line opens a connection to your server, running Plex Media Server, over ssh and tunneling the previously add port to that computer

For a more detailed description of the commands see the Plex Wiki.

Instead of having to view every jobs result it would be good to get a quick summary plot of all the jobs.

In this example we will be working with the following build jobs:

• build_component1
• build_component2
• build_component3

To create a summary plot we need a summary job which runs after the build jobs have executed. This job consists of a shell execute script and a plot plugin evaluation.

Shell execute script

#!/bin/bash
 
cat > ./get_summary.pl <<END
#!/usr/bin/perl
use LWP::Simple qw(\$ua get);
use LWP::Protocol::http;
use URI::Escape;
 
# Configuration part, add projects to search
@projects = ('component1', 'component2', 'component3');
\$local_ip = "1.2.3.4";
\$job_prefix = "build_";
\$output_file = "summary.xml";
 
# Open the output file
open (MYFILE, '>'.\$output_file);
print MYFILE "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n"; 
print MYFILE "<warnings>\n";
 
# Set up which IP to use on an multi-interface server
@LWP::Protocol::http::EXTRA_SOCK_OPTS = (LocalAddr => "\$local_ip");
 
# Fake a user agent
\$ua->agent('Mozilla/5.0');
 
# Collect all the results from selected projects
foreach (@projects) {
        my \$project = \$_;
        print "Scanning project: \$project\n";
        my \$url = "$JENKINS_URL/job/" . uri_escape(\$job_prefix) . uri_escape(\$project) . "/lastSuccessfulBuild/warningsResult/api/xml?depth=0";
        my \$response = \$ua->get(\$url);
        \$project =~ s/\s+/_/g;
        if (\$response->is_success) {
                my \$content = \$response->decoded_content;
                print "Got response from server:\n\$content\n";
                if (\$content =~ m/<numberOfWarnings>(\d+)<\/numberOfWarnings>/g) {
                        print MYFILE "   <\$project type=\"project\">\$1</\$project>\n";
                        print "Found \$1 warnings for this project\n";
                } else {
                        print "Error: Did not find any warnings for this project\n";
                }
        } else {
                print MYFILE "   <\$project type=\"project\">0</\$project>\n";
                print "Error: Connection error\n";
        }
}
 
print MYFILE "</warnings>\n";
close (MYFILE);
END
 
# Exec
perl get_summary.pl

This bash script creates a perl script on the server. The perl script queries the Jenkins server for the build result of each of the jobs and adds them to a XML-file. To use the bash script above, change the 4 configurable variables to adapt them to the environment.

The output the execution should be a XML-file looking like this:

<?xml version="1.0" encoding="UTF-8"?>
 
<warnings>
   <component1 type="project">6</component1>
   <component2 type="project">2</component2>
   <component3 type="project">10</component3>
</warnings>

Plot Evaluation
Now that we have the XML-file with the results we pass it to the plot plugin where the following settings are used:
Data series file: summary.xml
XPath Result type: Nodeset
XPath expression: /warnings/*[@type='project']

Now it is just build the job and view the summary plot.

Pros:

• It is very easy to set this up, just point port 22 in the router to Computer A and we are done.
• Only one entry point exposed to the outside.

Cons:

• When doing more advance tunneling it soon will become very complex, and hard to remember.

Solution 2: Multiple entry points.
Make the router point; port 2222 to Computer A, port 2223 to Computer B and port 2224 to Computer C. If A, B and C is configured correctly the will each listen to their port.

Pros:

• Each of the computers can be access directly from the outside, which makes tunneling easier

Cons:

• All computers are exposed to the outside
• Ports could be blocked by the ISP

How it is done:

The Linux distribution I’m using is Ubuntu (currently version 10.04).

First configure the router to forward a non-standard port, e.g. 2222 to one of the computers.

SSH into that computer and edit /etc/ssh/sshd_config

$ sudo nano /etc/ssh/sshd_config

Find the line in the beginning of the config file that says:

Port 22

Below that add the ports you want the ssh server to listen to, and you will get something like:

Port 22
Port 2222
Port 22222

Save the file and restart the SSH server

$ sudo service ssh restart

And you are done.

To connect to the different computers use the following command

$ ssh user@hostA -p 2222
$ ssh user@hostB -p 2223
$ ssh user@hostC -p 2224