Free external site catalog 1.2 software for linux

ExternalSiteCatalog allows you to index and search external sites in a Plone site.

ExternalSiteCatalog is a web crawler that can index external sites and make them searchable in Plone. You can specify the sites to index in a Plone Configlet, and directly index them from Plone, or let a scheduler do the job. Have a look at some of the screenshot in the doc folder of the product to get a first impression of what it looks like. Searching the external sites is done in a special portlet that is installed with ExternalSiteCatalog. External sites are not searchable in the normal Plone catalog, but are only available in a separate catalog in the portal_externalcatalog tool.

Direct indexing

All external sites are configured in the ExternalSiteCatalog configlet.
If you want to index external sites immediately, you can do so after
defining all the parameters, selecting your site, and clicking on
the "index" button in the configlet.

Crawling external sites regularly

If you want external sites to be crawled regularly every day or month,
youll have to do some extra work. Make sure to install PloneMaintenance
starting from version 1.3. Make sure that you are also regularly calling
PloneMaintenance from cron or one of the Zope schedulers.

Follow the installation instructions in PloneMaintenance!

Have a look at the portal_maintenance tool in the Zope Management
interface! It contains a lot of useful information!

Console indexing utility

The console indexing utility is a bit more complicated than doing everything
from Plone. In many cases you dont have the resources to administrate an
external utility, but if you can afford it, this tool gives you the possibility
to decouple the long running work of fetching external sites from Zope.
Basically, you can be sure that there is no Zope thread blocked with
crawling external sites for a long time. Zope is only called from the external
tool when it should index a page, so there is still some load on the
Zope server!

Please note that this external tool is not making use of the information
entered in the Plone configlet. It is completely independent! It also does
not make use of PloneMaintenance, and it is up to you to configure and
call it with a scheduler like cron.

Enhancements: Feb 21 2009

• German translation
• Solved bugs regarding utf8 characters

Requirements:

• python-gtk2
• python-pyvorbis
• python-pysqlite2
• python-gnome2
• gtk+

My Network Catalog is an indexing engine that allows Windows shares (or Samba shares) to be bound together over a local network.

My Network Catalog allows an easy centralized search of all the files available over the network.

Contentment::Catalog is a Perl module to provides categorization and indexing features.

SYNOPSIS

# Get a list of the available indexes
my @indexes = $context->catalog->indexes;

for my $index (@indexes) {

# Get a list of avilable terms
my @terms = $index->terms;

for my $term (@terms) {

# Get a list of generators
my @generators = $index->generators;

}

}

One frequently controversial component of a CMS is the categorization system. Contentment attempts to avoid this problem by providing a framework for building categorization systems so that any controversy just leads to the replacement of whatever system someone doesnt like.
That is, rather than create some all encompassing categorization system or some dead-simple one that your grandma who thinks the boogey-man is going to jump out of the her CD-ROM drive can use, you can have either or both or neither depending upon your need. Thus, instead of providing a category or taxonomy system, Contentment provides the indexing system, which allows you to implement whatever category system you prefer.

Libchart is a free chart creation PHP library, that is easy to use.
Main features:
- Bar charts (horizontal or vertical).
- Line charts.
- Pie charts.
- Compatibility with PHP 4 / PHP 5.
- No external dependency, need only PHP compiled with GD and FreeType

xSiteable project consists of all you need for Web site management and creation.
xSiteable is a complete all-you-need package for creating sites that are fully relational, open source, fully templating-enabled, using only XML-based technologies to help you create complex sites on the fly.
It packs such features as topic maps, notation for content, and the fast Sablotron xslt parser.
Main features:
- Topic maps (model and XTM)
- Cross-platform (Windows, Linux, *BSD, Mac OS X)
- Prototyping
- Site-management
- Compiler, not dynamic resource-gulper
- Metadata support : RSS, XFTM, XTM, RDF, DC.
- Blogging / news (w/external database or XML)
- Notational content
- Dynamic designs and site-templates (skins, if you like)
- Wireframe design (IA and prototyping, print-friendly)
- Flexible ontology
- Automatic taxonomy
- Fast and easy
- Open-source and licensed under BSD
Enhancements:
- Import; XML, XTM and delimited text-files.
- Graphviz; create GraphViz maps of your site.
- Added and revised documentation.

Sort::External is a Perl module that can sort huge lists.

SYNOPSIS

my $sortex = Sort::External->new( -mem_threshold => 2**24 );
while ( ) {
$sortex->feed($_);
}
$sortex->finish;
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Problem: You have a list which is too big to sort in-memory.
Solution: "feed, finish, and fetch" with Sort::External, the closest thing to a drop-in replacement for Perls sort() function when dealing with unmanageably large lists.

How it works:

Cache sortable items in memory. Periodically sort the cache and empty it into a temporary sortfile. As sortfiles accumulate, interleave them into larger sortfiles. Complete the sort by sorting the input cache and any existing sortfiles into an output stream.

Note that if Sort::External hasnt yet flushed the cache to disk when finish() is called, the whole operation completes in-memory.

In the CompSci world, "internal sorting" refers to sorting data in RAM, while "external sorting" refers to sorting data which is stored on disk, tape, punchcards, or any storage medium except RAM -- hence, this modules name.

Stringification

Items fed to Sort::External will be returned in stringified form (assuming that the cache gets flushed at least once): $foo = "$foo". Since this is unlikely to be desirable when objects or deep data structures are involved, Sort::External throws an error if you feed it anything other than simple scalars.

Taint and UTF-8 flags

Expert: Sort::External does a little extra bookkeeping to sustain each items taint and UTF-8 flags through the journey to disk and back.

METHODS

new()
my $sortscheme = sub { $Sort::External::b $Sort::External::a };
my $sortex = Sort::External->new(
-mem_threshold => 2**24, # default: 2**20 (1Mb)
-cache_size => 100_000, # default: undef (disabled)
-sortsub => $sortscheme, # default sort: standard lexical
-working_dir => $temp_directory, # default: see below
);

Construct a Sort::External object.

-mem_threshold -- Allow the input cache to consume approximately -mem_threshold bytes before sorting it and flushing to disk. Experience suggests that the optimum setting is somewhere between 2**20 and 2**24: 1-16Mb.
-cache_size -- Specify a hard limit for the input cache in terms of sortable items. If set, overrides -mem_threshold.
-sortsub -- A sorting subroutine. Be advised that you MUST use $Sort::External::a and $Sort::External::b instead of $a and $b in your sub. Before deploying a sortsub, consider using a GRT instead, as described in the Sort::External::Cookbook. Its probably a lot faster.
-working_dir -- The directory where the temporary sortfiles will reside. By default, this directory is created using File::Temps tempdir() command.
feed()

$sortex->feed( @items );

Feed one or more sortable items to your Sort::External object. It is normal for occasional pauses to occur during feeding as caches are flushed and sortfiles are merged.

finish()
# if you intend to call fetch...
$sortex->finish;

# otherwise....
use Fcntl;
$sortex->finish(
-outfile => sorted.txt,
-flags => (O_CREAT | O_WRONLY),
);

Prepare to output items in sorted order.

If you specify the parameter -outfile, Sort::External will attempt to write your sorted list to that location. By default, Sort::External will refuse to overwrite an existing file; if you want to override that behavior, you can pass Fcntl flags to finish() using the optional -flags parameter.

Note that you can either finish() to an -outfile, or finish() then fetch()... but not both.

fetch()
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Fetch the next sorted item.