- Added /node/detail/node_id screen that shows details from the specific run (linked as a click-thru from the specific run on main pages (see picture).

Bunraku Detail page

- Added /node/node.example.com screen that shows all runs from that node
- Now uses Redis hashes instead of storing JSON
- The overall code has been refactored and cleaned up in a lot of places
- The report processor is much cleaned up and simpler to understand

The unfortunate piece is that to upgrade you’ll need to flush your existing Redis data (I promise I won’t do this to you again … the refactor to make this a lot better involved me slapping my head at my previously stupid approach) and start again.

As always hope it’s useful to someone and patches and input welcomed.

One of the recent prototypes I’ve built is a very simple Puppet status panel. It uses a Puppet report processor to post the time, name of the host and status of Puppet runs to a Sinatra app with a Redis back-end. I’ve called it Bunraku (the word refers to a form of traditional Japanese puppetry). You can query successful (changed), unchanged and failed reports. It refreshes every 5 seconds and displays a maximum of 100 previous runs (all other data is stored in Redis but not displayed).

Bunraku screenshot

I hope it proves a useful example for someone and improvements and patches most welcome to it. I have some ideas on how to extend it beyond the very MVP v0.0.1 prototype it is now.

To use it install the `dogapi` gem on your Puppet master

$ sudo gem install dogapi

Then install puppet-datadog as a module in your Puppet master’s modulepath and update the `datadog_api_key` variable in the `datadog.yaml` file with your Datadog API key and copy the file to `/etc/puppet/`.

Enable pluginsync and reports on your master and clients in `puppet.conf`

        [master]
        report = true
        reports = datadog
        pluginsync = true
        [agent]
        report = true
        pluginsync = true

Finally run the Puppet client and sync the report as a plugin.

P.S. Also available is a DataDog Puppet module to install the Datadog agent.

The Zendesk report processor is easy to install:

1. Install the `httparty` and `json` gems on your Puppet master

$ sudo gem install httparty json

2. Install puppet-zendesk as a module in your Puppet master’s module path.

3. Update the zendesk_site, zendesk_user and zendesk_password variables in the zendesk.yaml file. The user you specify will become the author of any tickets created the report processor. Copy the file to /etc/puppet/. An example file is included.

4. Enable pluginsync and reports on your master and clients in `puppet.conf`

[master]
report = true
reports = zendesk
pluginsync = true
[agent]
report = true
pluginsync = true

5. Run the Puppet client and sync the report as a plugin

Now when Puppet runs fail then a Zendesk ticket will be created with the output of the failed run as the description of the ticket.

Currently Puppet Faces are only supported in Puppet 2.7.0 and later (2.7.0 is currently an RC but will hopefully be out soon!) and distributing them requires placing them into Puppet’s load path. They’ll shortly be distributable as Puppet modules using pluginsync.

So to install the GitHub face for now clone the git repository:

$ git clone git://github.com/jamtur01/puppet-ticket-face.git

Copy the relevant files into your Puppet master’s path (for example on Debian/Ubuntu into a source-based install).

$ cp -R lib/puppet/* /usr/local/lib/site_ruby/1.8/puppet

You can then see if the GitHub Face is installed like so:

$ puppet help

You should see the GitHub face listed in the available Puppet commands and you can now use it to query or create tickets. For example to list a ticket specify its ticket number:

$ puppet ticket list --ticket 1234

To create a ticket specify the create directive and the --token flag with your Redmine user API token (you can see it here).

$ puppet ticket create --token 123456789ABC

Hope someone finds this useful!

Puppet HipChat

Puppet HipChat  is a report processor that notifies a HipChat room of a failed Puppet run with the name of the host that failed and the date.

It requires the hipchat gem to be installed on your Puppet master:

$ sudo gem install hipchat

You can then install puppet-hipcat as a module in your Puppet master’s modulepath. Create a HipChat API key with a type of Admin.  Record the API key that is generated. Next, update the `hipchat_api` and `hipchat_room` variables in the `hipchat.yaml` file with your HipChat connection details and the room you wish to notify.  Then copy the file to `/etc/puppet/`. An option to notify users in the room `hipchat_notify` defaults to `false`. An example file is included.

Now enable pluginsync and reports on your master and clients in puppet.conf including specifying the hipchat report processor.

[master]
report = true
reports = hipchat
pluginsync = true
[agent]
report = true
pluginsync = true

Finally, run the Puppet client and sync the report as a plugin and your failed Puppet runs will be now be sent to the requested HipChat room.

Puppet Twilio

The Puppet Twilio report processor sends an SMS using Twilio notifying of failed Puppet runs with the name of the host that failed and the date. It’s easy to install and configure.

1. Install the `twiliolib` gem on your Puppet master

$ sudo gem install twiliolib

2. Install puppet-twilio as a module in your Puppet master’s module path.

3. Update the `sid`, `token`, `to` (the number you want to send to), `from` (one of your Twilio numbers) variables in the file `twilio.yaml` and copy the file to `/etc/puppet/`.

4. Enable pluginsync and reports on your master and clients in `puppet.conf`

[master]
report = true
reports = twilio
pluginsync = true
[agent]
report = true
pluginsync = true

5. Run the Puppet client and sync the report as a plugin

Puppet Growl

which sends failed reports as Growl notifications to a Growl server.  Firstly, install the `ruby-growl` gem on your Puppet master:

$ sudo gem install ruby-growl

Then install puppet-growl as a module in your Puppet master’s module path. Update the `growl_server` variables in the `growl.yaml` file with the IP address of the host to receive the Growl notification and copy the file to `/etc/puppet/`. An example file is included.

On your Growl host enable the “Listen for incoming connections” and “Allow remote application registration” options in your Growl    configuration.  Ensure UDP port 9887 is open on the host and on any firewalls in between the Puppet master and the host.

Lastly, enable pluginsync and reports on your master and clients in `puppet.conf`:

[master]
report = true
reports = growl
pluginsync = true
[agent]
report = true
pluginsync = true

And run the Puppet client and sync the report as a plugin. Your Puppet master should now send Growl notifications to your target host whenever a Puppet run fails.

It requires the xmpp4r gem to be installed on your Puppet master:

$ sudo gem install xmpp4r

You can then install puppet-xmpp as a module in your Puppet master’s modulepath. Update the `xmpp_jid`, `xmpp_passowrd`, and `xmpp_target` variables in the `xmpp.yaml` file and copy it to `/etc/puppet`. An example file is included in the repository.

Now enable pluginsync and reports on your master and clients in puppet.conf including specifying the xmpp report processor.

[master]
report = true
reports = xmpp
pluginsync = true
[agent]
report = true
pluginsync = true

Finally, run the Puppet client and sync the report as a plugin and your failed Puppet runs will be now be sent to the requested Jabber/XMPP user.

The PagerDuty report processor is easy to install:

1. Install the `rest-client` and `json` gems on your Puppet master

$ sudo gem install rest-client json

2. Install puppet-pagerduty as a module in your Puppet master’s module path.

3. Update the `pagerduty_api` variable in a file called `/etc/puppet/pagerduty.yaml` file with the PagerDuty API key for your Puppet service. An example file is included. You will also need to create a Puppet specific service that uses the Generic API in PagerDuty.

4. Enable pluginsync and reports on your master and clients in `puppet.conf`

[master]
report = true
reports = pagerduty
pluginsync = true
[agent]
report = true
pluginsync = true

5. Run the Puppet client and sync the report as a plugin

And you’re off with Puppet and PagerDuty integration!

1. Install the oauth and twitter gems on your Puppet master

$ sudo gem install oauth twitter

2. Create a new Twitter app here. For Application Type specify Client and for Default Access Type specify Read & Write. Make a note of the consumer key and consumer secret. You’re going to need them in Step 3.

3. Run the poauth.rb script (you’ll find it in the repository) and provide the consumer key and secret from the Twitter application you created in Step 2. Go to the URL provided by the script and authorise the Twitter user you wish to tweet your reports with to use this application. You will be provided with a PIN number. Paste it into the script where you are prompted. This will create a file called twitter.yaml in your current directory:

$ ruby poauth.rb
Set up your application at https://twitter.com/apps/ (as a 'Client' app),
then enter your 'Consumer key' and 'Consumer secret':
 
Consumer key:
d26cebWimPohUXxXFBMl0Q
Consumer secret:
ZI4E5QDt15iplUn3QTJyLATNO6deMwCLeZOHN3WPd0g
Visit http://api.twitter.com//oauth/authorize?oauth_token=sd4HGcFSpK7vI in your browser to authorize the app,
then enter the PIN you are given:
3300514

4. Copy the twitter.yaml file you created in Step 3. into your /etc/puppet/ directory.

5. Install puppet-twitter as a module in your Puppet master’s module path.

6. Enable pluginsync and reports on your master and clients in puppet.conf

[master]
report = true
reports = twitter
pluginsync = true
[agent]
report = true
pluginsync = true

7. Run the Puppet client and sync the report as a plugin

And bingo your Puppet server will tweet when Puppet runs fail! Of course this may annoy a lot of the free world so YMMV on the usefulness of this. You could also tweak the code pretty simply to send you and others DMs, for example by editing:

Twitter.update("Puppet run for #{self.host} #{self.status}")

to:

Twitter.direct_message_create("user_to_receive_DM", "Puppet run for #{self.host} #{self.status}")