function rsse_add_related_posts($PostBody) {
  if (!rsse_verify_feed()) { return $PostBody; }
  if (function_exists('yarpp_related')) {
    $PostBody .= yarpp_related(array('post'),array(),false,false,'rss');
  }
  return $PostBody;
}
 
add_filter('the_content', 'rsse_add_related_posts', 252);

This code used a function of another plugin to attach a ‘related posts‘ section at the end of the full content of each feed entry. As soon as I commented out the above filter and started attaching the related-posts section to the feed content through the YARPP plugin’s administration interface, everything was normal again. No more php-cgi processes timing-out or over-consuming the CPU cycles.

The following graph shows clearly the problematic period:

php-cgi processes consuming the CPU

The httpd error_log included many errors like the following:

[...]
Allowed memory size of 33554432 bytes exhausted (tried to allocate 18893 bytes)
[...]
mod_fcgid: process ... exit(communication error), terminated by calling exit(), return code: 1
[...]
[warn] (104)Connection reset by peer: mod_fcgid: read data from fastcgi server error.
[...]
[warn] mod_fcgid: stderr: PHP Fatal error:  Allowed memory size of 33554432 bytes exhausted (tried to allocate 4864 bytes)
[...]
Premature end of script headers: index.php
[...]

Note that these errors might appear in several occasions.

In my case, finding that faulty piece of code was a huge relief, I can tell you.

Related Articles

• WordPress 2.0.6 – Feed Issues Resolved
• G-Loaded Feeds
• Redmine deployment delayed
• Issue addressed: Author feeds deliver full content
• Status of content availability via feeds

mysqldump -u wpuser -p --opt --databases mywpdb > mywpdb.sql

After the database has been dumped, those backslash pairs in your posts’ data would appear as four (4) backslashes in the MySQL database dump. This is because this file contains the raw strings of your data.

To get an idea about what a raw string is, launch the python interpreter and test the following:

>>> "string with escaped backslash \\"
'string with escaped backslash \\'
>>> r"raw string with escaped backslash \\"
'raw string with escaped backslash \\\\'

All the above python-thing is not required at all, but it is good to know what really happens. As you can see, the escaped backslash is represented by four backslashes in the raw string and this is how it has been written by mysqldump in the mywpdb.sql file.

All you have to do in order to repair all that code, while leaving all non-escaped backslashes in place, is to use a good text-stream editor, like sed in the way presented below.

Assuming that you have kept a backup of the dump, use sed to repair it in-place:

sed -i 's/\\\\/\\/g' mywpdb.sql

You can now import the repaired dump back into the MySQL server and replace your data with the corrected one.

mysql -u wpuser -p mywpdb < mywpdb.sql

Your previously escaped backslashes should now appear as single backslashes in your posts, but displayed correctly by WordPress.

I haven’t noticed any problems after performing the above operation. It might not work for you though. Use at your own risk.

If I miss anything, please let me know.

Related Articles

• How to fix the WordPress database’s character-set issue
• Modifying Your Name In The WordPress Comments
• Add-Meta-Tags and WordPress 2.3
• Add-Meta-Tags WordPress Plugin
• WordPress Meta Tags plugin stable release

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
• Epiphany Browser Review
• Use Python to get the web page data in Epiphany
• Smart Bookmarks 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

• rsapiget downloads files using the new Rapidshare API
• Check Server HTTP Headers with CURL
• Mass download
• Partition images with Partimage and Partimaged
• Script for Apache Error Report

Add the necessary code

The code that needs to be added to the user menu is the following:

+ t r & ! t t
d       Diff against file of same name in other directory
        if [ "%d" = "%D" ]; then
          echo "The two directores must be different"
          exit 1
        fi
        if [ -f %D/%f ]; then        # if two of them, then
          diff -up %f %D/%f | sed -e 's/\(^-.*\)/\x1b[1;31m\1\x1b[0m/g' \
                                  -e 's/\(^\+.*\)/\x1b[1;32m\1\x1b[0m/g' \
                                  -e 's/\(^@.*\)/\x1b[36m\1\x1b[0m/g' | less -R
        else
          echo %f: No copy in %D/%f
        fi
D       Diff current directory against other directory
        if [ "%d" = "%D" ]; then
          echo "The two directores must be different"
          exit 1
        fi
        diff -up %d %D | sed -e 's/\(^-.*\)/\x1b[1;31m\1\x1b[0m/g' \
                             -e 's/\(^\+.*\)/\x1b[1;32m\1\x1b[0m/g' \
                             -e 's/\(^@.*\)/\x1b[36m\1\x1b[0m/g' | less -R
        fi

The code snippet is a contribution by James Ogley to this OpenSUSE wiki page about Midnight Commander and is released under the GFDL 1.2 license.

Here are the instructions on how to add this code to the user menu:

1. Having launched Midnight Commander, press F9
2. Go to the Command menu and hit the Edit menu file
3. MC lets you customize the user menu for the current directory [Local], current user [Home] or make the modification system-wide. You will need to be root to change the latter. Most probably the Home choice is what you need.
4. You can now paste the code block between two other user-defined commands.

How to use these actions

In order to show the differences between two versions of the same file, browse to the directories that contain each version, so that the directory in panel A contains the A version of some.file and the directory in panel B contains the B version of some.file. Then press F2 and lowercase d.

In order to show the differences between the contents of the directories in the two panels, just press F2 and then uppercase D.

Related Articles

• SPEC File Directory
• Meld…
• Making a directory writable by the webserver
• Use wget or curl to download from RapidShare Premium
• Send a text file as SMS with a Sony-Ericsson mobile

1. Study the license’s legal code; not just read it, study it. It contains the terms under which your software will be released. Never let trends interfere with the selection of the license and, of course, make sure you do not choose a license just because you think you cannot find a more suitable one. Note that, when it comes to software licenses, the point of no return is the release of the software. If you change your mind about the license after a version of the software has been released, then it is impossible to invalidate previously released versions. Anyone, who has obtained a copy of the software with the old license, will be able to use it according to the terms of that license.
2. Include a copy of the license inside the distribution package of your software. Also, keep a local copy of the license on a web site that you fully control and link to it when necessary. If you have to link to the license’s original web page, make sure you use a URI that includes at least the name and version of the license, eg .../gpl-v2.html. Avoid linking to URLs that might be redirected to different documents over time. For example, a URI like .../gpl.html will probably be redirected to the latest version of the license whenever the latter is released, so it might bring confusion to the users of your software or to developers who wish to use the code. If the organization that issues the license has taken care, so that the license URI contains the license name, version and the general rights – like it happens with the Creative Commons version 3 licenses -, then I guess it is safe enough to use such URLs for linking.
3. Keep in mind that you, the developer of the software, are the one who will decide the terms under which the software will be released. If one of the existing licenses is satisfactory enough, then it is highly recommended that you use it. Otherwise, feel free to modify one of those licenses by adding or removing conditions in order to create a license that suits your software’s needs.
4. It is highly recommended that you remove any statements that expressly state or imply the automatic renewal of the license when a new version of it is released. Such statements can lead to serious trouble and confusion. Automatic license renewal is irrational when it comes to computer software. [Update: it is suggested to include a notice which indicates the removal of such statements inside the software's distribution.]
5. Software that is released under the General Public License (GPL) is free open-source software. On the other hand, software does not have to be released under the GPL in order to be FS/OSS. If your software is meant to be FS/OSS, there are numerous licenses that can be used in order to give your users the necessary rights to use, copy, distribute, build on it etc. See the OSI approved licenses by category.

This list may not be complete, but it outlines some general rules that can be followed in order to avoid getting into trouble with your software’s license.

Related Articles

• Forking Apache-licensed software on Github and Bitbucket
• GPLv3 is out – The G-Loaded.eu views
• Software that detects violations of open source licenses
• Free Software Inc.
• Microsoft releases part of Web Sandbox code under the Apache License

First, I do not remember being warned about running out of free space. GNOME is supposed to do this, but, in my case, either it did not raise that warning message or I was too focused on my work so I didn’t notice it. I’d bet that the latter is what actually happened.

Second, I have setup several profiles in firefox and I have adjusted its launcher in the GNOME menu to start the profile manager each time I want to use the browser. Firefox keeps the profile information in the ~/.mozilla/firefox/profiles.ini file. Under the “no free space” conditions, something had caused the file to be re-created as a zero-size file, losing all of my profile information. Fortunately, this was the only file that was affected. My profile directories were in tact, so it was rather easy to recover from this situation by setting my profiles again with the profile manager.

The third observation has to do with the FTP client, gftp. As I have mentioned earlier I was also working with this client when I run out of free space. It is strange to me how some things happen sometimes, but at that moment I was adding some ftp sites to the gftp bookmarks. Well, it seems that if you happen to save your bookmarks or settings in gftp while there is no free space in the partition that holds gftp’s config files, you are LOST! All the files in ~/.gftp/ are replaced with zero-size files and all your settings and bookmarks are lost, unless you have a recent backup of them. Well, I didn’t have one and that’s why I was angry (against myself). This was fixed – but not my bookmarks :-( – by completely removing the ~/.gftp/ directory and getting it recreated when launching gftp.

After this incident, I kept wondering if there were more configuration files in my user account’s home that were affected. I guess it is impossible to know in advance. Time will show.

An application which acted absolutely professionally and actually was the one that made me realize that there was something wrong with the free space is Evolution. It displayed proper warning messages about not being able to write the newly fetched email and news messages to the disk and, generally, the problematic situation had absolutely no effect on it. I take my hat off to Evolution (v2.8.3).

This incident made me think if software developers ever test how their software would behave if there is no free space available, especially if its usage involves reading/writing/appending from/to files. I would bet that other programs might have problems under such conditions too, but I guess these situations are rare. On the other hand, if it happens and the software is not designed to work well, then your personal data could be at risk. At this point, I am rather happy I was not running my password manager at that critical period of time! ;-)

Anyway, as I have already written earlier, I blame noone. Unfortunately, I do not have the required free time or will to reproduce those errors in a test environment, but I guess I will do this at some later time. All the above might just be wrong conclusions and something else might was the cause of the problem. I really do not know, but I felt like writing about that experience.

Related Articles

• Featured Epiphany Plugins
• Descramble Passwords from gftp Bookmarks using Python
• Testing gnome-blog-poster…
• Epiphany Browser Review
• Access gvfs mounts from the command line

Before proceeding, make sure you have backed up your current non-optimized style-sheet. CSSTidy will not touch your original file, but taking some precautions is a good habit.

Launch csstidy without arguments for a rather short description of the command line switches:

csstidy

Although it is possible to define each parameter individually, some pre-defined templates are what you will most probably use. These include: low|high|highest. The higher the optimization level, the smaller the CSS filesize. More on templates here.

I tried the high and highest templates. The latter produces a style sheet that contains all code in a single line, but that file would not validate, so I used the high template:

csstidy style.css --template=high style.css.out

The compression ratio for my file was 34.86% which was quite satisfactory. Also, the final file validated properly.

CSSTidy does a good job either you want to optimize the stylesheet for readability or for filesize. On the other hand, the CLI interface does not provide enough information about each of the CLI switches. They are pretty self-explanatory, but I guess a little description for each one of them wouldn’t hurt anyone. Also, I could not make the “--remove_last_;” option to work.

The only difference I could notice in my stylesheets between the high and the highest templates was that the whole code was squeezed in a single line when highest was used. Probably, this template performs some more optimizations than just deleting the line-feed characters, but it seems that there was nothing else that could be optimized in my CSS file.

Apart from this command line utility, there are also a lot of online CSS optimizers. I didn’t have the time to try them all, but I think I can recommend the following:

• Clean CSS – this seems to be the PHP version of CSSTidy. Everything seems to work as expected and the results are the same as before.
• Icey CSS Compressor – This is another web-based CSS optimizer which performs very well. By using the default settings you get a single line with highly optimized CSS code. The compression ratio is similar to CSSTidy’s. In order to separate each selector with a line-feed character, so that the final CSS validates, you can pass the optimized CSS through sed:

  sed -i 's/}/}\n/g' style.css.out

If anyone knows about any other utility I would be very glad to know about.

Related Articles

• Use mod_deflate to Compress Web Content delivered by Apache
• VeriTAR – Verify checksums of files within a TAR archive
• How to annotate PDF files in Linux using Xournal
• Creative-Commons-Configurator WordPress Plugin
• WordPress 2.2.1 bugs

Requirements

The following software is required so that this backend functions correctly:

1. Python (http://www.python.org)
2. CUPS server (http://www.cups.org/)
3. Ghostscript (http://www.cs.wisc.edu/~ghost/)
4. a postscript printer’s PPD file. (see Installation section)
5. Email server, on which usernames from the LAN workstations either match the users on the email server or proper mappings (aliases) have been set.

Installation

Put the “pdf2email” file in /usr/lib/cups/backend/ and set the executable bit:

chmod +x /usr/lib/cups/backend/pdf2email

Configuration

Open the script in a text editor and set a couple of settings:

1. Set the email server’s hostname:

SMTP_Server = "mail.example.org"

2. Set the email address of the sender as it will appear in the email:

print_admin = "admin@example.org"

3. (Optional) Set the path to a text file that contains PDFmarks. If you don’t know what PDFmarks are, you should leave this variable empty. (see some more info in the PDFmarks section):

pdfmarks_file = ""

Configure a CUPS Printer

This section describes in brief all the required actions in order to add a printer that uses this backend to CUPS.

• Decide the printer’s name, eg “TestPDFprinter”.
• Decide the directory, where the PDF files are saved temporarily. This directory must be writable by the users. Usually, /tmp is perfect for this. Note, that no PDF files are left in this directory. This piece of information is used in the Device URI of your CUPS printer. For example, provided that the /tmp directory will be used, the Device URI would be: pdf2email:/tmp
• Get a postscript printer’s PPD file. You can find such files at:
  • Your printer manufacturer‘s web site.
  • Linux Printing
  • Adobe’s download center

WARNING: It is your exclusive responsibility to examine the printer driver’s license prior to using the PPD file. NO PPD FILES ARE SHIPPED WITH THE pdf2email BACKEND.

Finally, add a new printer that uses this backend, either by using lpadmin from the command line or by using the web-based administration interface of CUPS or by using any other CUPS Server management software.

Using lpadmin from the shell

As root issue the following command:

lpadmin -p TestPDFprinter -E -v pdf2email:/tmp -P /path/to/myprinter.ppd

Using CUPS web-based interface or other software

Use the provided “Add Printer” facility. Some notes that might be useful:

• In the device dropdown box, select the following:
  Direct PDF Printing/Delivery to user email
• In the device URI box use the writable directory, eg:
  pdf2email:/tmp
• If asked about the type of the print queue, use “RAW“.

USAGE

Make this printer available to the LAN through the IPP, SAMBA or any other protocol and add it to your printer list in your client machines. Whatever you send to that printer will be converted to a PDF document and will be emailed to your user’s email address.

Trouble?

If any error occurs during the PDF creation process, there will be a failure notice in your inbox and a message in syslog (/var/log/messages).

In case you receive no email after requesting a print, check syslog for any error messages. If there aren’t any, the check CUPS error log.

Finally, note that if you use a security layer like SELinux, then you might need to further adjust it so it lets 3rd party CUPS backends to function. This is beyond the scope of this document.

PDFmarks

If you do not know what pdfmarks are, please do a web search about them. This backend can include PDFmarks in the final PDF document. Do not expect anything spectacular, as this script cannot process the document for bookmarks, links etc. What it can do is to add pre-defined pdfmarks to all PDF documents.

For example, if, for example, you want to fill some of the document properties, save the following in a file:

[/Title ()
/Author ()
/Subject (blah blah)
/Keywords (keyword1, keyword2, blah)
/DOCINFO pdfmark

By default the author’s property is filled with the username that requested the print.

Finally, add the path to the pdfmarks file in the configuration section of the backend, as described in the configuration section:

pdfmarks_file = "/path/to/pdfmarks.file"

This feature has not been tested thoroughly.

License

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

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.

Related Articles

• Print to CUPS printer instances
• Using a CUPS printer from command line
• Print a Man Page
• Viceo Backend for SANE with libusb support
• How to create a single file of Sphinx based documentation

We will need the epiphany module, so import it:

import epiphany

Next we assign the active tab and its respective embed to variables:

tab = window.get_active_tab()
embed = tab.get_embed()

And now the critical part of getting the page’s HTML code:

persist = epiphany.ephy_embed_factory_new_object( epiphany.EmbedPersist )
persist.set_flags( epiphany.EMBED_PERSIST_NO_VIEW | epiphany.EMBED_PERSIST_COPY_PAGE )
persist.set_embed( embed )
page = persist.to_string()

Then, you can just print the page code in the console, save it to files or filter it to get the info you want.

Related Articles

• Epiphany Python Console – Open New Tab
• Epiphany Python Console – Documentation
• Tab Session Management extension for Epiphany
• A Note About The Epiphany Extensions on Fedora
• Tab Links extension for the Epiphany browser