#! /usr/bin/perl
 
use strict;
use warnings;
use 5.010;
 
my $dump_file = $ARGV[0];
&usage() if !$dump_file;
 
say "using ".$dump_file;
 
my ($line, $table,@query, $file_number,$file_name);
my $line_number = 1;
my $find_count = 0;
 
open(DUMP_IN, "< $dump_file");
        while(<DUMP_IN>){
                my $line = $_;
                if (/^USE\s.(\w+)./){
                        say "changing db: ".$1;
                        $file_name = &make_file_name("USE_$1", "$find_count");
                        &write_USE($file_name, $line);
                        $find_count++;
                }elsif (/^-- Table structure for table .(.+)./){
			## If the current line is the beginning of a table definition
			## and @query is defined, then @query must be full of the previous
			## table, so we want to process it now:
                        if (@query){
                        $file_name = &make_file_name("$table", "$find_count");
                                open(OUTPUT, ">$file_name");
                                        foreach(@query){
                                                print OUTPUT $_;
                                        }
                                close OUTPUT;
                                undef @query;
                        }
                        $table = $1;
                        $find_count++;
                }
                next unless $table;
                push @query, $line;
 
                $line_number++;
        }
close DUMP_IN;
say $line_number;
 
## Subroutines!
sub write_USE() {
        my($filename, $line) = @_[0,1];
        open (OUTPUT, ">$filename");
        print OUTPUT $line;
        close OUTPUT;
}
 
sub make_file_name() {
        my ($type, $number) = @_[0,1];
        $number = sprintf("%05d", $number);
        $file_name=$number."_".$type.".sql";
        return $file_name;
}
 
sub usage() {
        say "Error: missing arguments.";
	say "Usage:";
	say "$0 [MYSQL_DUMP]";
        exit 1;
}
 

A small downside is that this replaces my 2.5Gb file with about 1800 smaller ones. A scripted importer is to follow.

The changes are to give the <pre> tags a grey (#EEE) background colour, and to make the posts individual white boxes on grey, rather than an all-white page.

 
avi@avi:whiteasmilk_1.8$ diff style.css style.css.original
18,35d17
< /* Added to make the code blocks pretty. Stupid CSS implementations mean this will break
<    any form of validity in order to actually make it work. Stupid browser people.
<    I can't remember where I got this from, but if you reckon I might've found it on your site
<    let me know and if I believe you I'll stick a URL here
< */
< pre {
< 	border 0
< 	padding: 0.2em 0.5em;
< 	background-color:#EEE;
< 	white-space:pre-wrap;
< 	white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
< 	white-space: -pre-wrap;      /* Opera 4-6 */
< 	white-space: -o-pre-wrap;    /* Opera 7 */
< 	word-wrap: break-word;       /* Internet Explorer 5.5+ */
< }
<
<
<
40c22
<   body {background-color:#c9c9c9;}
---
>   body {background-color:white;}
323,326c305
< border-bottom:15px solid #c9c9c9;
<   padding-left:10px;
<   padding-right:10px;
<   background-color:#fff;
---
>   border-bottom:1px solid #999;

 
#! /usr/bin/perl
 
use strict;
use warnings;
use XML::Simple;
my $HOME = $ENV{ HOME };
 
my $bookmarks_file = "$HOME/.local/share/vinagre/vinagre-bookmarks.xml";
my $menu_file = "$HOME/.fluxbox/vnc_menu";
 
my $xml = new XML::Simple (KeyAttr=>[]);
my $data = $xml->XMLin("$bookmarks_file");
 
open(MENU, ">$menu_file") || die "Error opening \$menu_file: $menu_file $0";
 
print MENU "[begin]\n";
 
foreach my $b(@{$data->{"item"}}){
	print MENU "[exec] ($b->{name}) {vinagre $b->{host}:$b->{port}}\n";
}
print MENU "[end]\n";
close MENU;
 

#! /usr/bin/perl
 
use strict;
use warnings;
 
die "$0\n\tGet warranty info from dell.\nUsage\n$0 [SERVICE TAG]\n" if !$ARGV[0];
 
my $service_tag = $ARGV[0];
 
use LWP::Simple;
use HTML::TableExtract; # Is in the CPAN, and exists in the debian repositories as libhtml-tableextract-perl
 
## Make a URL:
my $url_base = "http://support.euro.dell.com/support/topics/topic.aspx/emea/shared/support/my_systems_info/en/details";
my $url_params = "?c=uk&cs=ukbsdt1&l=en&s=gen";
my $url = $url_base.$url_params."&servicetag=".$service_tag;
my $content = get($url);
 
# Tell HTML::TableExtract to pick out the table(s) whose class is 'contract_table':
my $table = HTML::TableExtract->new( attribs => { class => "contract_table" } );
$table->parse($content);
 
## Gimme infos!
foreach my $ts ($table->tables) {
	foreach my $row ($ts->rows) {
		print "", join("\t", @$row), "\n";
	}
}

To use it, you pass a hash of valid options to GetOptions, where the keys are options and the values are the references to variables in which to put their arguments.
The name of the option dictates what value(s) it can hold: the final character indicates type (i - integer, f - float, s - string), and the penultimate whether it is optional or not (= - required, : - optional). Flags are indicated by not following this pattern - they're just given a name with no symbols.

Getopt::Long allows for the shortest unambiguous switch to be used, doesn't distinguish between -o and --o, and allows for the negation of flags (if -flag sets a flag to 1, -noflag will set it to 0). It also doesn't touch @ARGV when it's done getting its flags out of it.

Here's a brief script hopefully helping explain the above:

#!/usr/bin/perl
use strict;
use warnings;
use Getopt::Long;
 
# This is only neccesary when using strict. Which is always.
my ($flag, $compulsory_string, $optional_string, $compulsory_integer, $optional_integer, $compulsory_
 
GetOptions(
        "o"=>\$flag,
        "cfloat=f"=>\$compulsory_float,
        "cint=i"=>\$compulsory_integer,
        "cstring=s"=>\$compulsory_string,
        "ofloat:f"=>\$optional_float,
        "oint:i"=>\$optional_integer,
        "ostring:s"=>\$optional_string,
);
 
print "flag set\n" if $flag;
print $compulsory_float."\n" if $compulsory_float;
print $compulsory_integer."\n" if $compulsory_integer;
print $compulsory_string."\n" if $compulsory_string;
print $optional_float."\n" if $optional_float;
print $optional_integer."\n" if $optional_integer;
print $optional_string."\n" if $optional_string;

Fatal error: Non-static method _PearDbPassUser::_PearDbPassUser() cannot be called statically, assuming $this from incompatible context in /usr/share/phpwiki.bak.d/lib/WikiUserNew.php on line 1118

The problem appears to be that, as of PHP 5.something, you're not allowed to have a function with the same name as a class. Apparently it's been a failure in E_STRICT mode for a while.

Anyway, the solution is to rename _PearDbPassUser() to something else, and then replace all calls to it with this new name.

I've done this and, so far, everything appears to work.

The function is defined in /usr/share/lib/phpwiki/lib/WikiUser/PearDb.php:

 
jup-linux2:/usr/share$ diff phpwiki.bak.d/lib/WikiUser/PearDb.php phpwiki/lib/WikiUser/PearDb.php
18c18
< function _PearDbPassUser($UserName='',$prefs=false) {
---
>     function _PearDbPassUserFoo($UserName='',$prefs=false) {
 

and is called in /usr/share/WikiUserNew.php:

 
jup-linux2:/usr/share$ diff phpwiki.bak.d/lib/WikiUserNew.php phpwiki/lib/WikiUserNew.php
1118c1118
< _PearDbPassUser::_PearDbPassUser($this->_userid, $this->_prefs);
---
>                 _PearDbPassUser::_PearDbPassUserFoo($this->_userid, $this->_prefs);
1157c1157
< _PearDbPassUser::_PearDbPassUser($this->_userid, $prefs);
---
>                 _PearDbPassUser::_PearDbPassUserFoo($this->_userid, $prefs);
2120c2120
< function PearDbUserPreferences ($saved_prefs = false) {
---
>     function PearDbUserPreferencesFoo ($saved_prefs = false) {
 

My plugin is mostly useless - it graphs the value returned by /dev/urandom, and the random constants from debian and dilbert. Current graph is here and the code is as follows:

#! /bin/bash
 
case $1 in
        config)
        cat < < EOF
graph_category amusement
graph_title Random numbers
graph_vlabel value
debian.label debian
dilbert.label dilbert
urandom.label /dev/urandom
graph_scale no
EOF
        exit 0
esac
 
urandom=$(cat /dev/urandom | tr -dc '0-9' | head -c2)
 
echo "urandom.value " $urandom
echo "debian.value 4"
echo "dilbert.value 9"
 

Munin's plugins live in /etc/munin/plugins/, most of which are symlinks to scripts in /usr/share/plugins/. On restart, munin-node rechecks the plugins directory and loads any new plugins.
For a plugin called foo, munin-node will run foo configure first to get the configuration of the graph (which is passed to munin-graph), and then foo. For information as to graph configuration, see here.
It takes about 15 mins of collection for it to start making a graph, and you'll get more data every 5mins thereafter.

The script itself is mostly self-explanatory, except for:

- The values and the labels are linked by what occurs before the dot. If you define foo.label in the config output, that is what will be used to label the number that comes after foo.value in the 'normal' output. The munin tutorial sort-of hints at this, but only uses one variable.

- Munin doesn't care what order the variables come out in, it uses the labels to determine who's who. Similarly, it doesn't seem particularly fussed as to which flavour of horizontal whitespace is used.

#! /usr/bin/perl
 
use strict;
use warnings;
 
## Let the browser know what we're sending it
print "content-type: text/html\n\n";
 
## Spew some HTML since we're not going to get away with plain text formatting
print "<html>\n\t<head>";
print "\t\t<title>Passwords!</title>";
print "\t</head>";
print "<body>\n\t
<h1>Avi's Magical Password Generator</h1>
 
";
 
## Define two sets of data. The first is the lengths of password we want
## to produce, the second is the allowed characters. Each space-separated
my $lengths="1 4 8 10 20 30 50 80 100";
my $characters="A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 0 ! $ % ^ & _ + = : ; @ # ~ , . ? ";
 
## Split the above by space into arrays
my @chars=split(/ /, $characters);
my @lens=split(/ /, $lengths);
 
## Work out how many characters we are allowed, so that when we
## come to pick one at random we can use this number as the maximum.
my $chars_count = @chars;
 
## Spew out some html for pretty formatting:
print "
<table>\n";
print "\t
<tr>
<td>length</td>
<td></td>
</tr>
 
";
 
## The loop!
foreach (@lens){
	my $length=$_;
	my $count;
	## The first cell of the row, containing the length:
	print "\n\t
<tr>
<td>".$_."</td>
<td>";
	for ($count = 1; $count < = $length; $count++){
		## Working backwards, $chars_count is the above-defined
                ## number of characters we have to play with,
                ## rand($chars_count) picks a random number between 0 and
                ## $chars_count, and int(rand($chars_count)) makes sure
                ## it's an integer. This in the square brackets after $chars
                ## means we're picking a random element out of the array
                ## @chars, which is effectively picking a random character
                ## out of the list of allowed ones.
		print $chars[int(rand($chars_count))];
	}
	print "</td>
</td>
</tr>
 
\t\t\n";
}
print "</table>
 
\n\n";
 
print "<a href=./password.txt>sauce</a> <a href=..>home</a>";
print "</body>";</html>

There are enough comments, hopefully, to make it reasonably easy to modify this script for similar uses in future. In short, it reads the csv file as plain-text line-by-line and uses a regexp to pick out the DN. It writes the whole line to the array, at the element numbered the same as the DN. (if the same DN appears twice, the last one encountered survives, the rest don't). It then prints _every_ line of the array to a CSV file, including null ones, such that even if $array[285] is the first non-null element, it is still the 285th line printed to the file.

To use it, stick the csv file you want processed and the script in the same directory, and run the script. It will produce 'out.csv' which is the processed script. It always operates on the alphabetically first *.csv file it finds (except out.csv) and will silently overwrite out.csv if it exists. If it has problems, it writes 'errors.txt' which contains the output. It's mostly run on Windows boxen outside of a terminal

#! /usr/bin/perl
 
use strict;
 
##	Most Recent Changes:
##
##	Added dupe checking. Before writing to array, checks whether that element exists or not.
##	If it does, writes message to error array and carries on. At the end of the run, if the
##	error array contains messages it dumps them to a new errors file, and exits. It does not
##	create the output csv.
##
##	Also writes more general errors to the file, including if it finds no csv files.
##
##	Might support filenames with spaces.
##
##
 
my $output_file = './out.csv';
 
my $error_file = "./errors.txt";
my @error_array = ();
 
# Open the current directory and read its full contents to a new array called @files.
# Then go through @files and, if the file does not begin with a dot, ends with `csv`
# and is not `out.csv` add it to an array.  We then sort the array and pick the first
# file and presume that is our input file.
opendir(DIR, ".") || die("Error opening working dir");
my @files=readdir(DIR);
my @csvs;
foreach my $f (@files){
	if (($f !~ /^\./) && ($f =~ /csv$/) && ($f !~ /^out\.csv$/)){
		push( @csvs, $f);
	}
}
if (@csvs < 1){
	print "no csvs";
	push (@error_array, "Can find no csv files. Check it's not saved as xls");
}
 
@files=sort(@csvs);
my $input_file = "./$files[0]";
 
# Handy info for the user
print $input_file."\n";
 
# Initialise an array for the output, and one for error messages.
my @output_array = ();
 
# Go through each element of the array (and therefore line of the file) and,
# if it contains the string 'LO' but not 'Unknown', process it
 
open INPUT_FILE , "< $input_file" || die ("Error opening input file at $input_file");
 
foreach (<INPUT_FILE>){
	my $line = $_;
	## If the line begins with two or more decimal digits, it's probably one of
        ## those funny bungay ones
	if ($line =~ /^\d{2}/){
		my $line_number = (split /,/, $_)[0];
		$line_number--;
		## If the line we want to write to is non-empty (i.e. it has
                ## digits in it), then error
		if ($output_array[$line_number] =~ /\d/){
			my $repeat_count = 0;
			foreach (
<input_file>){
				if ((split /,/, $_)[0] =~ m/$line_number/){
					$repeat_count++;
				}
			}
			$error_array[$line_number] = $line_number." exists about ".$repeat_count." times.";
		}
 
		$output_array[$line_number]=$line;
	## If it doesn't, carry on as normal.
	}elsif ($line =~ /LO/ ){
		if ($line !~ /Unknown/){
			# Pick out where the TN is in the line (in the third /-separated
			# group of the third comma-separated group).
			# Then write the entire line to the element of the array that is one
			# less than the TN. Chop() gets rid of the last character of the string
			# which here is a "
			# (remember that the first element of an array is 0, but the first
			# line of a file is 1; element 0 will become line 1)
			my @cur_line = split (/,/, $_);
			my @tn_string = split (/\//, $cur_line[2]);
			my $tn = $tn_string[2];
			$tn--;
			$output_array[$tn] = $line;
		}
	}
}
close INPUT_FILE;
 
foreach (@error_array){print;}
 
# If the error array contains records (i.e. its length is greater than zero),
# create an error log file
if (@error_array > 0){
	open ERROR_FILE , "> $error_file" || die ("Error opening error log at $error_file. You're fucked.");
		print ERROR_FILE "Errors encountered processing ".$input_file.":\n";
		print STDERR "Errors encountered processing ".$input_file.":\n";
		foreach my $error (@error_array){
			print ERROR_FILE $error;
			print STDERR "\t".$error;
		}
	close ERROR_FILE;
	print "\n";
}
 
# Open the output file, and write the contents of the output array to file.
# Remember that Perl will append a \n to each non-null element of the array, but we want one
# on the end of every element, including null. So we chomp each line to remove the /n from
# those that have it, and re-add it to _every_ array.
 
open OUTPUT_FILE, "> $output_file" || die ("Error opening output file at $output_file");
	my $output_line;
	foreach $output_line (@output_array){
		chomp $output_line;
			print OUTPUT_FILE $output_line. "\n";
	#print $_, "\n";
	}
close OUTPUT_FILE;
print "\n";
</input_file>