#! /usr/bin/env bash
#
# Error Report for httpd
#
# Requires:
#   - scanerrlog - http://www.librelogiciel.com/software/ScanErrLog/action_Presentation
#   - jaxml - http://www.librelogiciel.com/software/jaxml/action_Presentation
#
 
cat /var/log/httpd/error_log \
    /var/www/vhosts/*/log/error_log \
    | python /usr/local/bin/scanerrlog.py -f text \
    | /bin/mail -s "`hostname` - Apache Error Report" root@localhost
 
exit 0

Some notes:

1. Make sure that this cronjob runs before log rotation takes place.
2. The above shell script concatenates the error_log files from the main web server and all virtualhosts. Edit the paths to reflect your server configuration and virtualhost layout.
3. Edit the path to scanerrlog.py.

Scanerrlog has some quite nice features that let you further customize the report. Make sure you read the help message.

Related Articles

• SELinux audit reports script
• Strange mod_dav_svn error
• SSL-enabled Name-based Apache Virtual Hosts with mod_gnutls
• How to integrate seaudit-report in logwatch
• When it comes to error messages…

#! /bin/sh

if [ -f /var/lock/noshutdown.lock ] ; then
  logger -t shutdowndog shutdown prevented
  exit 1
fi

/sbin/shutdown "$@"

Then, I created the file that would act as a switch:

touch /var/lock/noshutdown.lock

Then, I initiated the shutdown procedure from the command line:

shutdown -h +0

There was no shutdown! It had worked!

Syslog confirmed that the check had taken place:

Nov 25 19:19:04 galeon shutdowndog: shutdown prevented

I rushed to try to shut down the system from GNOME’s shutdonw panel (Menu System -> Shut Down...), but, after pressing the relevant button, the system went down normally…

It was obvious that GNOME had not used my override, but another mechanism to power-off the system instead. Since I use the GNOME menu to shutdown/reboot/suspend the system, I spent a couple of hours trying to find what was going on in GNOME and finally discovered the file /usr/bin/gnome-power-cmd.sh:

#!/bin/sh
# Copyright (C) 2007 Richard Hughes 
#
# Licensed under the GNU General Public License Version 2
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

#$1 = method name
execute_dbus_method ()
{
        dbus-send --session --dest=org.freedesktop.PowerManagement              \
                  --type=method_call --print-reply --reply-timeout=2000 \
                  /org/freedesktop/PowerManagement                      \
                  org.freedesktop.PowerManagement.$1
        if [ $? -eq 0 ]; then
                echo "Failed"
        fi
}

if [ "$1" = "suspend" ]; then
        echo "Suspending"
        execute_dbus_method "Suspend"
elif [ "$1" = "hibernate" ]; then
        echo "Hibernating"
        execute_dbus_method "Hibernate"
elif [ "$1" = "reboot" ]; then
        echo "Rebooting"
        execute_dbus_method "Reboot"
elif [ "$1" = "shutdown" ]; then
        echo "Shutting down"
        execute_dbus_method "Shutdown"
elif [ "$1" = "" ]; then
        echo "command required: suspend, shutdown, hibernate or reboot"
else
        echo "command '$1' not recognised, only suspend, shutdown, hibernate or reboot are valid"
        exit 1
fi

So, GNOME makes the appropriate calls for power-related events through D-bus. I initially thought that GNOME used /usr/bin/gnome-power-cmd.sh whenever the shutdown/reboot/suspend button was pressed, so I modified it so to check for my switch (/var/lock/noshutdown.lock) and then proceed accordingly. It did not work out…

I had already spent much time on this, so I decided to quit. But, it is crucial for me to make this thing work and I will probably investigate it a bit more and report back at some later time.

Related Articles

• delayed-shutdown initscript
• Using setenforce to switch SELinux mode wisely
• Use the Alternatives System to switch to a custom Firefox release
• Screenshot of a menu under GNOME: ROUND 2
• Print a Man Page

#! /usr/bin/env bash
#
#  Send to Desktop - Create Symlink
#
#  Project: http://www.g-loaded.eu/2008/11/03/send-to-desktop-create-symlink/
#
#  Features:
#      - creates symlinks on the desktop pointing to each of the selected items
#        (files/directories).
#      - Supports paths containing spaces.
#      - Supports multi-selection (warns before creating multiple symlinks)
#
#  Requires:
#      - ln
#      - zenity
#
#  Installation:
#  1) Put the file in ~/.gnome2/nautilus-scripts/
#       cp "Send to Desktop - Create Symlink" ~/.gnome2/nautilus-scripts/
#  2) Set the 'executable' bit:
#       chmod -x ~/.gnome2/nautilus-scripts/"Send to Desktop - Create Symlink"
#  3) Access the script by right clicking and selecting the submenu 'scripts'
#
#  Copyright 2008 George Notaras <gnot [at] g-loaded.eu>, CodeTRAX.org
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
#
 
DESKTOP=~/Desktop
 
if [ $# -lt 1 ] ; then
  zenity --error --text "At least one file or directory must be selected."
elif [ $# -gt 1 ] ; then
  zenity --question --text "Multiple items selected. Proceed?"
fi
 
if [ "$?" = 1 ] ; then
    exit 1
fi
 
for item in "$@"; do
    ln -s "$PWD/$item" "$DESKTOP/$(basename $item)"
done
 
exit 0

Save the code in a file. Assuming that you have saved it as “Send to Desktop – Create Symlink“, follow the instructions below in order to install and use it:

1 – Put the file in ~/.gnome2/nautilus-scripts/

cp "Send to Desktop - Create Symlink" ~/.gnome2/nautilus-scripts/

2 – Set the ‘executable‘ bit:

chmod +x ~/.gnome2/nautilus-scripts/"Send to Desktop - Create Symlink"

3 – Access the script by right clicking and selecting the submenu ‘scripts‘

Enjoy!

Related Articles

• Search for viruses from Nautilus
• Add files to Totem playing list from Nautilus
• Print to CUPS printer instances
• Mass download
• Dictionary Lookups Anywhere

A while ago I had written a script that would automate the WordPress upgrade process. Such a program could have been a simple shell script, just a few lines of code. However, I decided to write a more flexible script in Python instead, which can keep backups, perform a thorough upgrade of the website’s platform, keep the files I need to keep etc. A script that takes good care of everything while upgrading is also a good idea because it minimizes downtime while performing upgrades. Today was the first time to test it. After the upgrade, everything seems to be where it should. The script is in pre-alpha state and despite the fact that I used it on my website, it is not ready for release yet. Below is the output of the upgrade on G-Loaded:

# python wpupgrade.py 2.3.1
info: ++ Performings Tests. Please wait...
info: Initial configuration checks - OK
info: Retrieval of WordPress database settings from wp-config.php - OK
info: Checking existence of mysqldump - OK
info: ++ Starting data backup. Please wait...
info: Database backup - OK
info: Filesystem backup - OK
info: Data backup Complete
info: ++ Downloading wordpress archive. Please wait...
info: Download and Verification Complete
info: ++ Removing old WordPress files and directories. Listing follows:
info: Removed DIR: wp-admin
info: Removed DIR: wp-includes - PRESERVED wp-includes/languages
warning: --> DIR wp-content/cache CANNOT BE REMOVED - NOT CRITICAL - REMOVE MANUALLY IF POSSIBLE
info: Removed FILE: wp-commentsrss2.php
info: Removed FILE: wp-rss.php
info: Removed FILE: wp-rdf.php
info: Removed FILE: wp-login.php
info: Removed FILE: wp-app.php
info: Removed FILE: wp-settings.php
info: Removed FILE: wp-comments-post.php
info: Removed FILE: wp-mail.php
info: Removed FILE: wp-rss2.php
info: Removed FILE: wp-pass.php
info: Removed FILE: wp-blog-header.php
info: Removed FILE: wp-register.php
info: Removed FILE: wp-feed.php
info: Removed FILE: wp-trackback.php
info: Removed FILE: wp-cron.php
info: Removed FILE: wp-links-opml.php
info: Removed FILE: wp-config-sample.php
info: Removed FILE: wp-atom.php
info: Removed FILE: index.php
info: Removed FILE: xmlrpc.php
info: Removed FILE: readme.html
info: Removed FILE: license.txt
info: WordPress files removal complete
info: ++ WordPress Upgrade
info: Writing new files. Please wait...
info: File Upgrade Complete
info: ++ Starting Cleanup
info: Nothing - TODO
info: Finish Upgrade by visiting: http://www.yoursite.org/wp-admin/upgrade.php

Related Articles

• Upgraded to WordPress Coltrane
• Upgraded to WordPress 2
• Highly Exploitable Code Planted into WordPress 2.1.1
• WordPress 2.5 – Plugin Compatibility
• Server upgraded to Fedora 6

1. Select some text with the mouse (easy :P)
2. Trigger a dictionary lookup for the selected text.
3. Get the word’s definitions in a browser window.

After some research on the web, I came up with a decent solution. I discovered that when some text is selected under X, it is temporarily stored in a location called “Primary Clipboard“. The text could be somehow retrieved from that location and could be sent to an online dictionary by pressing a specific keyboard combination. This is totally independent of the application which the text had been selected from. This method also makes dictionary lookups as easy and fast as it can get.

But, this was just in theory. I needed a way of retrieving the selected text from the primary clipboard programmatically. This was the most difficult part, as X or GTK programming is out of my league…

Fortunately, I was told that this exact functionality exists in the deskbar applet. The user can select some text, then press Alt-F3 and the deskbar applet displays a list of pre-defined places (epiphany smart bookmarks included) to search for the selected text, which also includes gnome-dictionary in order to look up the word on a dictionary server.

Using this deskbar applet’s functionality for the dictionary lookups could be the perfect solution. But, on the other hand, being able to specify different key combinations for different dictionaries and not having to pick a search location from the deskbar’s list would be more than perfect. Grepping into deskbar applet’s source code I soon found what I was looking for in the first place: that is the way to programmatically retrieve the selected text from the primary clipboard. Of course, I shamelessly stole that small piece of code :P

Provided that some text has been selected, its retrieval is possible with the following python snippet:

import gtk
clipboard = gtk.clipboard_get(selection = "PRIMARY")
text = clipboard.wait_for_text()
print text

The rest was easy. What was needed was a key combination to trigger the execution of the above script. Unfortunately, a custom command cannot be set in the gnome-keybinding-properties application. So, a workaround was needed even for that!! After some research, it turned out that one can set a custom command and assign a keyboard shortcut for it in GNOME’s window manager, metacity.

So, finally, it worked! Read on for detailed info…

How to set things up

First of all, create a small script:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
 
command = "epiphany -n http://en.wiktionary.org/wiki/%s"
#command = "epiphany -n http://dictionary.reference.com/search?q=%s"
 
import gtk
import os
from urllib import quote
 
clipboard = gtk.clipboard_get(selection = "PRIMARY")
text = clipboard.wait_for_text()
text = text.strip()
if text:
	text = quote(text)	# This is basically for multiword selections
	os.popen(command % text)

Save the script to a directory of your choice. The rest assumes that the script has been saved to:

/home/johndoe/bin/selectionlookup.py

What this does is to retrieve the selected text from the “primary clipboard” and execute the specified command. In this case, the command is actually a system call to the epiphany browser which is instructed to load a page with the possible definitions for the selected text. The English version of Wiktionary or Dictionary.com (whichever is uncommented) is used for the lookup. Note that multiword selections are supported by both the script above and the aforementioned online dictionaries.

Second of all, a global keyboard shortcut needs to be set in metacity for the reasons I explained previously.

First, the custom command needs to be set. Open the gconf-editor and browse to the key:

/apps/metacity/keybinding_commands/command_1

Of course use any command key you wish. Here command_1 is used. Set the following value:

python /home/johndoe/bin/selectionlookup.py

Then set up the keybinding for that command. Browse to the key:

/apps/metacity/global_keybindings/run_command_1

And set the combination (the following is an example):

<control><alt>g

Test it by selecting some text anywhere and by pressing Ctrl-Alt-g. A new tab will appear in the browser window with a page with the selected text’s definitions (if any).

Appendix I: Using a dictionary server

Instead of looking the selected text up on a web-based dictionary, you can retrieve definitions from a dictionary server. Adjust the script accordingly. For example:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
 
command = "echo 'DEFINE * \"%s\"' | nc dict.org 2628 | zenity --text-info --title='Dict Lookup' --width=500 --height=500"
 
import gtk
import os
 
clipboard = gtk.clipboard_get(selection = "PRIMARY")
text = clipboard.wait_for_text()
text = text.strip()
if text:
	os.popen(command % text)

The following happens when the keyboard shortcut is pressed:

1. The following dictionary protocol specific command: DEFINE * “selectedtext” is piped to netcat (see some netcat examples).
2. Netcat opens a connection to the dict.org dictionary server, sends the command and retrieves the results.
3. The results are piped to zenity and are displayed in an information textbox.

Obviously, in order to successfully run the above command you will need netcat (nc) and zenity.

Final Thoughts

A whole dictionary application can be built around the selected text that is stored at the primary clipboard. The above is the fastest and most effective way of retrieving word/phrase definitions from any possible dictionary. It is independent of the application from which the text is selected and no time is wasted in meaningless copy-pasting. If you know a better way of looking up words, please let me know.

Related Articles

• Epiphany Python Console – Open New Tab
• DictExpress
• Taking a screenshot of a menu under GNOME
• Zim – a Desktop Wiki
• Use Python to get the web page data in Epiphany

Theory

Rapidshare uses cookie-based authentication. This means that every time you log into the service, a cookie containing information which identifies you as a registered user is stored in your browser’s cookie cache. Both wget and curl support saving and loading cookies, so before using them to download any files, you should save such a cookie. Having done this, then the only required action in order download from RapidShare is to load the cookie, so that wget or curl can use it to authenticate you on the RapidShare server. This is pretty much the same you would do with a graphical download manager. The difference now is that you do it on the command line.

Below you will find examples about how to perform these actions using both wget and curl.

IMPORTANT: Please note that in order to use these command-line utilities or any other download managers with RapidShare, you will have to check the Direct Downloads option in your account’s options page.

Save your RapidShare Premium Account Cookie

Saving your RapidShare cookie is a procedure that needs to be done once.

The login page is located at:

https://ssl.rapidshare.com/cgi-bin/premiumzone.cgi

The login form requires two fields: login and password. These are pretty self-explanatory.

In the following examples, the RapidShare username is shown as USERNAME and the password as PASSWORD.

Using wget

In order to save your cookie using wget, run the following:

wget \
    --save-cookies ~/.cookies/rapidshare \
    --post-data "login=USERNAME&password=PASSWORD" \
    -O - \
    https://ssl.rapidshare.com/cgi-bin/premiumzone.cgi \
    > /dev/null

–save-cookies : Saves the cookie to a file called rapidshare under the ~/.cookies directory (let’s assume that you store your cookies there)
–post-data : is the POST payload of the request. In other words it contains the data you would enter in the login form.
-O - : downloads the HTML data to the standard output. Since the above command is run only in order to obtain the cookie, this option prints the HTML data to stdout (Standard Output) and then discards it by redirecting stdout to /dev/null. If you don’t do this, wget will save the HTML data in a file called premiumzone.cgi in the current directory. This is just the Rapidshare HTML page, which is absolutely not needed.

Using curl

In order to save your cookie using curl, run the following:

curl \
    --cookie-jar ~/.cookies/rapidshare \
    --data "login=USERNAME&password=PASSWORD" \
    https://ssl.rapidshare.com/cgi-bin/premiumzone.cgi \
    > /dev/null

–cookie-jar : Saves the cookie to a file called rapidshare under the ~/.cookies directory (it has been assumed previously that cookies are stored there)
–data : contains the data you would enter in the login form.
Curl prints the downloaded page data to stdout by default. This is discarded by sending it to /dev/null.

Download files using your RapidShare Premium Account Cookie

Having saved your cookie, downloading files from RapidShare is as easy as telling wget/curl to load the cookie everytime you use them to download a file.

Downloading with wget

In order to download a file with wget, run the following:

wget -c --load-cookies ~/.cookies/rapidshare <URL>

-c : this is used in order to resume downloading of the file if it already exists in the current directory and is incomplete.
–load-cookies : loads your cookie.

Downloading with curl

In the same manner, in order to download a file with curl, run the following:

curl -L -O --cookie ~/.cookies/rapidshare <URL>

-L : Follows all redirections until the final destination page is found. This switch is almost always required as curl won’t follow redirects by default (read about how to check the server http headers with curl).
-O : By using this switch you instruct curl to save the downloaded data to a file in the current directory. The filename of the remote file is used. This switch is also required or else curl will print the data to stdout, which is something you won’t probably like.
–cookie : loads your Rapidshare account’s cookie.

Setting up a Download Server

Although most users would be satisfied with the above, I wouldn’t be surprised if you would want to go a bit further and try to setup a little service for your downloading pleasure. Here is a very primitive implementation of such a service. All you will need is standard command line tools.

This primitive server consists of the following:

1. A named pipe, called “dlbasket“. You will feed the server with URLs through this pipe. Another approach would be to use a listening TCP socket with NetCat.
2. A script, which, among others, contains the main server loop. This loop reads one URL at a time from dlbasket and starts a wget/curl process in order to download the file. If dlbasket is empty, the server should just stay there waiting.

So, in short, the service would be the following:

cat <> dlbasket | ( while ... done )

All credit for the “cat <> dlbasket |” magic goes to Zart, who kindly helped me out at the #fedora IRC channel.

So, let’s create that service. The following assume that a user named “downloader” exists in the system and the home directory is /var/lib/downloader/. Of course you can set this up as you like, but make sure you adjust the following commands and the script’s configuration options accordingly.

First, create the named pipe:

mkfifo -m 0700 /var/lib/downloader/dlbasket

If it does not exist, create a bin directory in the user’s home:

mkdir -p /var/lib/downloader/bin

Also, create a directory where the downloaded files will be saved:

mkdir -p /var/lib/downloader/downloads

The following is a quick and dirty script I wrote which actually implements the service. Save it as rsgetd.sh inside the user’s bin directory:

#! /usr/bin/env bash  
 
#  rsgetd.sh - Download Service
 
#  Version 0.3
 
#  Copyright (C) 2007 George Notaras (http://www.g-loaded.eu/)
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License version 2 as
#  published by the Free Software Foundation.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
 
# Special thanks to 'Zart' from the #fedora channel on FreeNode
 
# v0.3 - Oct 31 2009:
# - corrected error: "./bin/rsgetd.sh: line 37: [: argument expected"
 
# CONFIG START 
HOMEDIR="/var/lib/downloader"
DLBASKET="$HOMEDIR/dlbasket"
DLDIR="$HOMEDIR/downloads/"
LOGFILE="$HOMEDIR/.downloads_log"
CACHEFILE="$HOMEDIR/.downloads_cache"
LIMIT="25k"
WGETBIN="/usr/bin/wget"
# Rapidshare Login Cookie  
RSCOOKIE="$HOMEDIR/cookies/.rapidshare"
# CONFIG END
 
DATETIME="`date '+%Y-%m-%d %H:%M:%S'`"
 
cat <> $DLBASKET | (
        while read url ; do
                # First, check the cache if the file has been already downloaded
                if [ -f "$CACHEFILE" -a -n "$(grep -i $(basename $url) $CACHEFILE)" ] ; then
                       echo "$DATETIME File exists in cache. Already downloaded - Skipping: $url" >> $LOGFILE
                else
                        echo "$DATETIME Starting with rate $LIMIT/s: $url" >> $LOGFILE
                        if [ $(expr match "$url" '[rapidshare.com]') = 1 ] ; then
                                # If it is a Rapidshare.com link, load the RS cookie 
                                echo "RAPIDSHARE LINK"
                                $WGETBIN -c --limit-rate=$LIMIT --directory-prefix=$DLDIR --load-cookies $RSCOOKIE $url
                        else
                                $WGETBIN -c --limit-rate=$LIMIT --directory-prefix=$DLDIR $url
                        fi
                        echo "$DATETIME Finished: $url" >> $LOGFILE
                        echo $url >> $CACHEFILE
                fi
        done )
 
exit 0

As you might have already noticed, two extra files are created inside the home directory: .downloads_cache and .downloads_log. The first contains a list of all the urls that have been downloaded. Each new download is checked against this list, so that the particular URL is not processed if the file has already been downloaded. The latter file is a usual logfile stating the start and end times of each download. Feel free to adjust the script to your needs.

Here is some info about how you should start the service:

-1- You can simply start the script as a background process and then feed URLs to it. For example:

rsgetd.sh &
echo "<URL>" > /var/lib/downloader/dlbasket

-2- Use screen in order to run the script in the background but still be able to see its output by connecting to a screen session. Although this is not a screen howto, here is an example:

Create a new screen session and attach to it:

screen -S rs_downloads

While being in the session, run rsgetd.sh

rsgetd.sh

From another terminal feed the download basket (dlbasket) with urls:

echo "<URL>" > /var/lib/downloader/dlbasket
cat url_list.txt > /var/lib/downloader/dlbasket

Watch the files in the screen window as they are being downloaded.

Detach from the screen session by hitting the following:

Ctrl-a   d

Re-attach to the session by running:

screen -r

Note that you do not need to be attached to the screen session in order to add URLs.

Feeding the basket with URLs remotely

Assuming that a SSH server is running on the machine that runs rsgetd.sh, you can feed URLs to it by running the following from a remote machine:

ssh downloader@server.example.org cat \> /var/lib/downloader/dlbasket

Note that the > needs to be escaped so that it is considered as part of the command that will be executed on the remote server.

Now, feel free to add as many URLs as you like. After you hit the [Enter] key the url will be added to the download queue. When you are finished, just press Ctrl-D to end the URL submission.

Conclusion

This article provides all the information you need in order to use wget or curl to download files from your RapidShare Premium account. Also, information on how to set up a service that will assist you in order to commence downloads on your home server from a remote location has been covered.

The same information applies in all cases that wget and curl need to be used with websites that use cookie-based authentication.

Related Articles

• Check Server HTTP Headers with CURL
• Mass download
• Partition images with Partimage and Partimaged
• HTTP headers
• File and Directory diff in color in Midnight Commander

I’ve been experimenting with the Minimalist for the last days and all I can say is that this software Just Works™ … and I like it when software works! Actually, I liked it so much that I have devoted a significant amount of time in writing a program that acts as a bridge between the Minimalist’s mailing list archives and MHonArc. This program (a MHonArc wrapper actually), which also includes a set of resource files in order to heavily customize MHonArc’s HTML output (in an attempt to be like the popular Mailman web archives), is called BenzinArc (Benzin Archiver) and can be used both as a cron job and as a standalone application. BenzinArc is still work in progress. No code has been released yet. An overview of the HTML version of the CodeTRAX Mailing List Archives is available. Currently, only one read-only mailing list, codetrax-bugs, exists. This is a dedicated list to the bug reports of all projects hosted by CodeTRAX, but it is enough to serve as an example.

All this mailing-list-related stuff has kept me away from working on the 0.7.1 release of the TraxAuth Account System, but I assume all that was absolutely necessary. Although my free time will be very little in the upcoming weeks, I guess I will be able to release a new version of TraxAuth and the first public test release of BenzinArc.

Related Articles

• Organizing Mailing List messages with Evolution
• Next time, come prepared
• TraxAuth
• Mozilla Thunderbird 3 is out!
• Blog Freeze

• Run through cron at predefined intervals. In this case it reads the saved rtorrent session data, creates a summary about the loaded torrent files status and prints the HTML code to stdout, which can then be redirected to a file and thus be made publicly available by a web server.
• Run as a CGI script, which makes it possible to dynamically generate the HTML page on-demand. This method, compared to running rtorstat through cron at short pre-defined intervals, has the advantage of limiting system resource waste by parsing the session data only when a user runs the CGI script through the web browser. Also, depending on your rtorrent settings, the displayed information is usually more current than that of the HTML page generated through cron, unless cron runs the script very often.

rtorstat does not support or will never support any kind of remote rTorrent administration. It is not supposed to be a web-based rtorrent frontend, but, as the title says, a simple status page generator (status web interface).

Requirements

rtorstat is not dependency-free. Here is the list of the required software in order to run rtorstat:

• Python
• rTorrent (configured to save session data – see below)
• The file “bencode.py“, part of the official Bittorrent client (Mainline) distribution, has been included in the rtorstat distribution package, so the Mainline Bittorrent client is no longer a dependency for rtorstat.

rTorrent Configuration

rtorstat needs to read the torrent session data, so rTorrent needs to be configured to save this information to a pre-defined directory. The following shows all the session-data specific configuration rTorrent (.rtorrent.rc) options:

# Sets the directory where session data files are stored
session = /opt/bittorrent/sessiondata

# Keeps session data files even if torrent has finished
session_on_completion = yes

# Not really required, but recommended - see rtorrent(1) man page
session_lock = yes

# Setup A: Run through CRON
# Save session data every 5 mins, with a 4 min offset
schedule = session_save,240,300,session_save=

# Setup B: Run as a CGI
# Save session data every 300 seconds
# (This is an example value. Setting it to a lower value is highly recommended)
#schedule = session_save,300,300,session_save=

The last directive (schedule) instructs rtorrent to save session data at the specified interval.

Usage

rtorstat can be run through cron or as a CGI script. Running it as a CGI is the preferred way of running it as the parsing of the session data and the HTML page generation take place dynamically only when you visit the web page. This leads to wasting less system resources.

Running rtorstat through cron

No special installation is needed as the location of rtorstat.py can be set within the cron job. Just make sure that the file bencode.py exists in the same directory as rtorstat.py.

rtorstat requires one argument; that is the path to the directory where the session data is saved:

$ python rtorstat.py /opt/bittorrent/sessiondata/

Having parsed the session data files and having created the summary, the HTML code is printed to stdout, from where it can be redirected to a html file. For example:

$ python rtorstat.py /opt/bittorrent/sessiondata/ > /var/www/index.html

rtorstat is supposed to be run through cron at regular intervals. In the example configuration above (Setup A), rtorrent saves the session data every 5 minutes (300 sec), so rtorstat needs to be run at the same interval through cron. The 4 min offset (240 sec) that had been set in the rtorrent scheduler serves so that there is good timing between rTorrent saving the session data and rtorstat parsing it.

Such a cron job would be:

*/5 * * * *   root python /path/to/rtorstat.py /opt/bittorrent/sessiondata/ > /var/www/index.html

rtorstat will parse the session data files, for example, at 00:05, 00:10 etc.

Having adjusted the paths according to your configuration, save the above cronjob to a file inside the /etc/cron.d/ directory and you are set.

Running rtorstat as a CGI script

In this case, you need to place 3 files in your cgi-bin: rtorstat.py, rtorstat.cgi and bencode.py.

Apart from the rtorrent configuration, it is required to set the path of the directory where rtorrent saves session data in rtorstat.cgi. So, open rtorstat.cgi in your favourite text editor and fill-in the required information:

session_dir = "/path/to/rtorrent/session/dir/"

Now, you can visit the web page http://yourdomain.example.org/cgi-bin/rtorstat.cgi

Setting up a scriptaliased directory is covered by your web server’s documentation and is outside of the scope of this document.

Security

rtorstat generates a HTML page which is made publicly available through a web server (most probably). Therefore it is your responsibility to secure this location using any of your web server’s access control methods.

License

This project is released under the terms of the Apache License version 2.

Download

All versions of the software, including the latest stable release, are available from the development web site’s download area.

Donate

This software is released as free software. Nevertheless, its development requires time and effort. A small donation, as a sign of appreciation of the effort, is welcome. Please, use the following button to visit the Donations page. Thank you.

Support

This software is released as free software without any warranties or official support. You can still get first class support from the community of users.

Bugs and Feature Requests

Found a bug? Want to suggest a new feature for the upcoming release? Feel free to file your requests in the issue database on the development website.

Things to consider

It has been mentioned before, but here it goes again:

Note that by making the rtorrent status page publicly available through a web server, the world will know what you download at any time. It is your exclusive responsibility to keep this page private, if this is what you really want. This piece of information is of course beyond the scope of this article.

This script was written in a quick and dirty way. If you encounter any bugs, please notify me through the g-loaded forums and I will get back to you when I have the time.

Last, but not least, if you improve the looks, consider contributing back your string template.

Related Articles

• Use Python to get the web page data in Epiphany
• Write A Man Page
• Remove-Generator-Meta-Tag WordPress Plugin
• Print a Man Page
• Mass download

Recently, I had to install the SecureFTP ftp client for linux, but the script errored out with some strange messages like not being able to uncompress the archive or about not being able to verify the archive’s checksum or about wrong command line parameters used in some command calls internally. This had happened in the past too, when I wanted to install the good old game Unreal Tournament (1999) so to revive some good memories. ;-)

Here are some of the weird error messages:

tail: cannot open `+187' for reading: No such file or directory

gunzip: stdin: not in gzip format

Verifying archive integrity...tail: cannot open `+6' for reading: No such file or directory
Error in check sums 1237260170 2341625838

As stated at the makeself website, archives created with Makeself older than v2.1.2 were using an old syntax for the head and tail Unix commands and there are problems uncompressing the included software.

In order to resolve this issue and make the installer “assume” that you use an old GNU/Linux version, you should export the following environment variable before using the installer:

export _POSIX2_VERSION=199209

After you finish installing the software, delete that ENV variable:

unset _POSIX2_VERSION

It took me a significant amount of time to learn about this workaround and, basically, I discovered it while searching for the software that creates these self-installing archives.

Hope this tip helps someone out there.

Related Articles

• When it comes to error messages…
• Script for Apache Error Report
• Email Notifications from a Linux System
• Burning a DVD still an adventure on GNU/Linux
• Mailing List Manager

aureport has a shortcoming. It can only display one report at a time. So, in order to have daily SELinux reports in our inbox aureport needs to be called several times from within a cron job. This is why aureportgen.py was written. It can be configured to execute aureport several times collecting the pre-defined reports for a given period of time and then print a concatenation of these reports to the stdout.

Configuration

Open the aureportgen.py script in a text editor and scroll down to the configuration section. The available options are:

The path to the aureport executable:

aureportpath = "/sbin/aureport"

The list of the reports to collect:

reports = ["a", "mf", "ms", "lf", "ls"]

The line above might be a little cryptic so here is the convention on how to specify the report names:

1. Each report name may consist of up to two letters. The first, which is mandatory, specifies the report type and the second, which is optional, specifies whether a successes or a failures report will be returned.
2. All the aureport command line switches that specify a report type can be used as the first letter.
3. Either the letter “f” or “s” can be used as the second letter to indicate a success-only or failure-only report.
4. If the second letter is omitted, then a report that contains both successful and failed events is returned.

By using the configuration above, the following reports will be returned:

1. AVC denials (successes or failures not applicable to this report)
2. Account modification failures
3. Account modification successes
4. Login failures
5. Login successes

Usage

This script was written in order to be called from within a cron job. It is mandatory to specify the number of days in the past the reports will be generated for. This is done with the –days command line option.

An example daily cron script is listed below:

#! /bin/bash

python /path/to/aureportgen.py --days 1 | mail -s "SELinux Reports by aureport" root

exit 0

The same as a cronjob would be:

0 0 * * *    root    python /path/to/aureportgen.py --days 1 | mail -s "SELinux Reports by aureport" root

This will scan the audit logs and the pre-defined reports will be generated for the last 24 hours. The output will be emailed to root.

WARNING: It should be possible to run this script directly on the CLI and have multiple reports displayed in the standard output, but if the login shell’s locale is different than the crn job’s, then there could be a problem. In such cases, you will still be able to run it from the CLI without errors by setting the extra configuration option fix_date to True:

fix_date = True

License

This project is released under the terms of the GNU General Public License.

Download

You can download this script from the following link:
aureportgen-0.1.tar.gz

Note that this is an alpha version, it is released without any warranties or support.

Related Articles

• How to integrate seaudit-report in logwatch
• Script for Apache Error Report
• Using setenforce to switch SELinux mode wisely
• Get my kernel headers script
• A Useful Script