Free archived obituaries software for linux

Archive::Builder is a file generation and archiving framework.

SYNOPSIS

# Make a builder with one section, and some files
my $Builder = Archive::Builder->new;
my $Section = $Builder->new_section( html );
$Section->add_file( one.html, string, qq~
Hello World!
~ );
$Section->add_file( two.html, file, ./source/file.html );
$Section->add_file( three.html, Custom::function, @args );

# Generate and save to disk
$Builder->save( ./somewhere );

# Create an zip file from it and save it.
my $Archive = $Builder->archive( zip ).
$Archive->save( foo.zip );

# Create a tar.gz file of just one section
my $Tar = $Section->archive( tar.gz );

Perl is often used for applications that generate large numbers of files, and Archive::Builder is designed to assist in these sorts of tasks.

It provides a framework for defining a set of files, and how they will be generated, and a series of methods for turning them into an Archive of varying types, or saving directly to disk.

archive2iso application takes a directory tree and randomizes the files in the tree to stripe the files across several ISO files that can be archived or burned off to a CD.

The intended use is to stripe files across multiple CD/DVD randomly so if one disc is damaged all the images that were in the same directory will not be lost since files are spread across multiple disks. The actual files themselves are not split, all files remain in their original state.

An example of an intended use is where you have a series of valuable vacation photos that could span 6 CD for all your photos in your collection. archive2iso would spread them out across the 6 CDs so if 1 of the 6 cds is lost, you only loose 1/6th of your images. Which is better than loosing all of them!

SYNTAX: ./archive2iso

EXAMPLE:

Enter Directory: /absolute/path - Files to archive = 910 - Estimated total Size = 632 MBEnter Max megabyte Size for the ISO/CD/DVD (1-4700): 100 - Estimated Num Disks = 7 /usr/tmp/disk_1.iso - 139 files at 99.6 MB /usr/tmp/disk_2.iso - 128 files at 99.8 MB /usr/tmp/disk_3.iso - 144 files at 99.9 MB /usr/tmp/disk_4.iso - 164 files at 99.7 MB /usr/tmp/disk_5.iso - 136 files at 99.9 MB /usr/tmp/disk_6.iso - 159 files at 99.9 MB /usr/tmp/disk_7.iso - 40 files at 32.8 MB Is the above disk configuration okay?Answer y or n: yNOTE: If the Disks do not look balanced then answer "n" and it will re-randomize. - Building ISO images

Archive sort is a bash script that sorts directories into manageable 4.4GB directories for the purpose of archiving onto DVDs.

It is useful if you have several tens or hundreds of GBs of data to archive. It can also be configured to sort into 700MB directories for archiving onto CDs.

Usage: ./archive-sort [-h] [-s SIZE] [-t] [-v] SOURCE DEST

Archive files from directory DEST to new directory SOURCE in 4.4GB chunks,
or any SIZE specified by the user.

This script has not been tested extensively, so it is recommended that you make a copy of the directory you want to archive, then run the script on that directory. Always use the -t (test) option first and carefully read the output before using the script.

Optional arguments.

-h Print this help message.
-s Size of the archive media (default 4.4 GB)
-t Test run with verbose messages.
-v Verbose

Examples:

First cd to directory containing directories to be archived:

cd /home/user/archive
archive-sort . ../disc01

This is useful if you have several large directories under /home/user/archive, but no files. The archive directory will not be included in disc01.

If you have a directory full of lots of files, then cd to the parent directory of the directory that needs to be archived:

cd /home/user
archive-sort archive disc01

Archive::Tyd is a Perl extension for simple file archiving.

SYNOPSIS

use Archive::Tyd;

my $tyd = new Archive::Tyd (password => secret password);

# Load an archive.
$tyd->openArchive ("./archive.tyd");

# Add a file.
$tyd->addFile ("./secret image.jpg");

# Write the archive.
$tyd->writeArchive ("./archive.tyd");

# Read the secret rules.
my $rules = $tyd->readFile ("rules.txt");

Tyd is a simple archiving algorith for merging multiple files together and encrypting the results, hence a password-protected archive.

Tyd Does: Reading and writing of encrypted Tyd archives and file operations within.

Tyd Does: Load all files into memory. Tyd is not good as a storage device for a large quanitity of large files. Tyd is best for keeping small text files and graphics together (maybe to keep a spriteset and definitions for a game?)

Tyd Does Not: support directories within the archive, compression of files, and many other things that WinZip and GZip support.

Archive::Ar is a Perl interface for manipulating ar archives.

SYNOPSIS

use Archive::Ar;

my $ar = new Archive::Ar("./foo.ar");

$ar->add_data("newfile.txt","Some contents", $properties);

$ar->add_files("./bar.tar.gz", "bat.pl")
$ar->add_files(["./again.gz"]);

$ar->remove("file1", "file2");
$ar->remove(["file1", "file2");

my $filedata = $ar->get_content("bar.tar.gz");

my @files = $ar->list_files();
$ar->read("foo.deb");

$ar->write("outbound.ar");

$ar->DEBUG();

Archive::Ar is a pure-perl way to handle standard ar archives.

This is useful if you have those types of old archives on the system, but it is also useful because .deb packages for the Debian GNU/Linux distribution are ar archives. This is one building block in a future chain of modules to build, manipulate, extract, and test debian modules with no platform or architecture dependence.

You may notice that the API to Archive::Ar is similar to Archive::Tar, and this was done intentionally to keep similarity between the Archive::* modules

Class Methods
new()
new($filename)
new(*GLOB,$debug)

Returns a new Archive::Ar object. Without a filename or glob, it returns an empty object. If passed a filename as a scalar or in a GLOB, it will attempt to populate from either of those sources. If it fails, you will receive undef, instead of an object reference.

This also can take a second optional debugging parameter. This acts exactly as if DEBUG() is called on the object before it is returned. If you have a new() that keeps failing, this should help.
read($filename)
read(*GLOB);

This reads a new file into the object, removing any ar archive already represented in the object. Any calls to DEBUG() are not lost by reading in a new file. Returns the number of bytes read, undef on failure.

read_memory($data)

This read information from the first parameter, and attempts to parse and treat it like an ar archive. Like read(), it will wipe out whatever you have in the object and replace it with the contents of the new archive, even if it fails. Returns the number of bytes read (processed) if successful, undef otherwise.

list_files()
This lists the files contained inside of the archive by filename, as an array.
add_files("filename1", "filename2")
add_files(["filename1", "filename2"])

Takes an array or an arrayref of filenames to add to the ar archive, in order. The filenames can be paths to files, in which case the path information is stripped off. Filenames longer than 16 characters are truncated when written to disk in the format, so keep that in mind when adding files.

Due to the nature of the ar archive format, add_files() will store the uid, gid, mode, size, and creation date of the file as returned by stat();

add_files() returns the number of files successfully added, or undef on failure.
add_data("filename", $filedata)

Takes an filename and a set of data to represent it. Unlike add_files, add_data is a virtual add, and does not require data on disk to be present. The data is a hash that looks like:

$filedata = {
"data" => $data,
"uid" => $uid, #defaults to zero
"gid" => $gid, #defaults to zero
"date" => $date, #date in epoch seconds. Defaults to now.
"mode" => $mode, #defaults to "100644";
}

You cannot add_data over another file however. This returns the file length in bytes if it is successful, undef otherwise.

write()
write("filename.ar")

This method will return the data as an .ar archive, or will write to the filename present if specified. If given a filename, write() will return the length of the file written, in bytes, or undef on failure. If the filename already exists, it will overwrite that file.
get_content("filename")

This returns a hash with the file content in it, including the data that the file would naturally contain. If the file does not exist or no filename is given, this returns undef. On success, a hash is returned with the following keys:

name - The file name
date - The file date (in epoch seconds)
uid - The uid of the file
gid - The gid of the file
mode - The mode permissions
size - The size (in bytes) of the file
data - The contained data
remove("filename1", "filename2")
remove(["filename1", "filename2"])

The remove method takes a filenames as a list or as an arrayref, and removes them, one at a time, from the Archive::Ar object. This returns the number of files successfully removed from the archive.

DEBUG()

This method turns on debugging. Optionally this can be done by passing in a value as the second parameter to new. While verbosity is enabled, Archive::Ar will toss a warn() if there is a suspicious condition or other problem while proceeding. This should help iron out any problems you have while using the module.

Archive::Chm is a Perl module that performs some read-only operations on HTML help (.chm) files. Range of operations includes enumerating contents, extracting contents and getting information about one certain part of the archive.

The module supersedes Text::Chm written by Domenico Delle Side. The method get_filelist() and all its dependencies are taken nearly "as-is" from Text::Chm as written by Domenico.

SYNOPSIS

my $test = Archive::Chm->new("TestPrj.chm");

#make the module log its activity
$test->set_verbose(1);
$test->set_logfile("chmfile.log");

#set the auto-overwrite function to off
$test->set_overwrite(0);

#enumerate the contents of the archive
$test->enum_files("listing.txt", 1);

#extract all items in a certain directory
$test->extract_all("./out");

#extract a single item from the archive
$item = $test->("/Secret of Monkey Island Solution.html";

#or just get the length of the item
$test->get_item_length("/Secret of Monkey Island Solution.html");

#get complete information about the chm archive
@content = $test->get_filelist();
foreach (@content) {
print $_->{title} . "n" if defined $_->{title};
print $_->{path} . "n";
print $_->{size} . "n";
}

#p.s. There are ways to check for errors, just look up each method and see. :)

Archive::Chm is a module that provides access to Microsoft Compiled HTML Help files (chm files). A lot of todays software ships with documentation in .chm format. However Microsoft only provides viewing tools for their own OS and the company doesnt disclose the format specification.

Unofficial specs can be found at Matthew T. Russottos site: http://www.speakeasy.org/~russotto/chm/chmformat.html

The module is basically a wrapper of Jed Wings chmlib, a C library that provides access to all ITSS archives, though .chm is the only ITSS type file in use today. To use this module you need chmlib installed on your system. You can get it at: http://66.93.236.84/~jedwin/projects/chmlib/

Currently access to .chm files is read-only and this will change over time if Jed Wing upgrades his library. Supported operations are getting a listing of the contents, extracting one or all items in the archive and retrieving an items length.

Archive::Zip is a Perl module which provides an interface to ZIP archive files.

SYNOPSIS

# Create a Zip file
use Archive::Zip qw( :ERROR_CODES :CONSTANTS );
my $zip = Archive::Zip->new();

# Add a directory
my $dir_member = $zip->addDirectory( dirname/ );

# Add a file from a string with compression
my $string_member = $zip->addString( This is a test, stringMember.txt );
$string_member->desiredCompressionMethod( COMPRESSION_DEFLATED );

# Add a file from disk
my $file_member = $zip->addFile( xyz.pl, AnotherName.pl );

# Save the Zip file
unless ( $zip->writeToFileNamed(someZip.zip) == AZ_OK ) {
die write error;
}

# Read a Zip file
my $somezip = Archive::Zip->new();
unless ( $somezip->read( someZip.zip ) == AZ_OK ) {
die read error;
}

# Change the compression type for a file in the Zip
my $member = $somezip->memberNamed( stringMember.txt );
$member->desiredCompressionMethod( COMPRESSION_STORED );
unless ( $zip->writeToFileNamed( someOtherZip.zip ) == AZ_OK ) {
die write error;
}

The Archive::Zip module allows a Perl program to create, manipulate, read, and write Zip archive files.

Zip archives can be created, or you can read from existing zip files.
Once created, they can be written to files, streams, or strings. Members can be added, removed, extracted, replaced, rearranged, and enumerated. They can also be renamed or have their dates, comments, or other attributes queried or modified. Their data can be compressed or uncompressed as needed.
Members can be created from members in existing Zip files, or from existing directories, files, or strings.

This module uses the Compress::Zlib library to read and write the compressed streams inside the files.

News::Archive is a Usenet news archiving package for downloading and later accessing news articles in bulk.

It can load articles laid out in INN format, retrieve them from a running news server, or just take articles one-by-one. News::Archive module is compatible with News::Web and Net::NNTP::Server, so the articles can be shared either via the Web or via NNTP.

SYNOPSIS

use News::Archive;
my $archive = new News::Archive
( basedir => /home/tskirvin/kiboze );

# Get a news article
my $article = News::Article->new(*STDIN);
my $msgid = article->header(message-id);

die "Already processed $msgidn"
if ($archive->article( $messageid ));

# Get the list of groups were supposed to be saving the article into
my @groups = split(s*,s*, $article->header(newsgroups) );
map { s/s+//g } @groups;

# Make sure were subscribed to these groups
foreach (@groups) { $archive->subscribe($_) }

# Actually save the article.
my $ret = $archive->save_article(
[ @{$article->rawheaders}, , @{$article->body} ], @groups );
$ret ? print "Accepted article $messageidn"
: print "Couldnt save article $messageidn";

News::Archive keeps several files to keep track of its archives:

active file

Keeps track of all newsgroups we are "subscribed" to and all of the information that changes regularly - the number of articles we have archived, the current first and last article numbers, etc.

Watched over with News::Active.

history database

A simple database keeping track of articles by Message-ID. Makes access by ID easy, and ensures that we dont save the same article twice. The database chosen to maintain these is user-determined.

newsgroup file

Keeps track of more static information about the newsgroups we are subscribed to - descriptions, creation dates, etc.

Watched over with News::GroupInfo.

archive directory

Directory structure of all articles, with each article saved as a single textfile within a directory structure laid out at one section of the group name per directory, such as "rec/games/mecha". Crossposts are hardlinked to other directory structures.

Articles are actually divided into sub-directories containing up to 500 articles, to avoid Unix directory size performance limitations. Individual files are thus stored in a file such as "rec/games/mecha/1.500/1".

Each newsgroup also contains overview information, watched over with
News::Overview. This overview file goes in the top of the structure,
such as "rec/games/mecha/.overview".

You may note that these files are very similar to how INN does its work. This is intentional - this package is meant to act in many ways like a lighter-weight INN.

Usage:

Global Variables

The following variables are set within News::Archive, and are global throughout all invocations.

$News::Active::DEBUG
Default value for "debug()" in new objects.

$News::Active::HOSTNAME
Default value for "hostname()" in new objects. Obtained using
"Sys::Hostname::hostname()".

$News::Active::HASH
The number of articles to keep in each directory. Default is 500;
change this at your own peril, since things may get screwed up later
if you change it after archiving any articles!