Free retrieve data software for linux

Apalogretrieve program retrieves data from an Apache logfile with a syntax, that is derived (a subset of) the SQL language.

The idea to make such an implementation came up at 17th of July 2007. I just started it then.

The basic idea of using an SQL-like dialect for logfile-analysis I had many years ago, but as there was no necessity, I didnt started a project like this.

The reason why I started to implement it now is, that the idea about SQL-querying of a logfile was now of interest to me, because I hated the way, how webalizer does it: you have graphical results very easy, but how to make detailed lookups to certain information? And: what about the delay until the (averaging) data can be seen in the graphs, and other problems, when changing a webalizer.conf-file?

So, this was the reason to start it.

As I not every day have the time to implement it, and only do it in a spare time window, it might need some time to make it ready, but reading Apaches common logfile-format as well as parsing simple SQL-like SELECT statements already works (19th of July 2007).

Usage Example:

SELECT host,date FROM "apache-commonlog.log" where size > 2000;
SELECT host,date,client,referrer FROM "apache-commonlog.log" where host = "foobar.host.net";

MP3::Tag::ID3v2-Data can get_frame() data format and supported frames.

SYNOPSIS

$mp3 = MP3::Tag->new($filename);
$mp3->get_tags();
$id3v2 = $mp3->{ID3v2} if exists $mp3->{id3v2};

($info, $long) = $id3v2->get_frame($id); # or

($info, $long) = $id3v2->get_frame($id, raw);

This document describes how to use the results of the get_frame function of MP3::Tag::ID3v2, thus the data format of frames retrieved with MP3::Tag::ID3v2::get_frame().

It contains also a list of all supported ID3v2-Frames.

get_frame()
($info, $long) = $id3v2->get_frame($id); # or

($info, $long) = $id3v2->get_frame($id, raw);

$id has to be a name of a frame like "APIC". See also L .

The names of all frames found in a tag can be retrieved with the L function.

Services_Weather searches for given locations and retrieves current weather data and, dependent on the used service, also forecasts.
Up to now, GlobalWeather from CapeScience, Weather XML from EJSE (US only), a XOAP service from Weather.com and METAR/TAF from NOAA are supported.
Further services will get included, if they become available, have a usable API and are properly documented.
Enhancements:
- Various additions to the METAR/TAF service, including cloud types, pressure tendencies and the US version of ice pellets in the conditions.
- Parsing has been changed for the FMC notations and the wind and cloud related groups.
- EJSE has been fixed to make it work again with the demand for registration.
- Globalweather seems to be back online after more than a year, but apparently the service is broken, because the replies are all invalid; thus it is tagged for removal unless Capescience fixes this.

Apache::Storage is Perl module containing simple functions to store and retrieve information from within the Apache process.

Google::Adwords::Data is base class for the Data modules.

This module is not supposed to be used directly. Use the child data modules.

TV-Browser is a TV guide that is easily extensible using plugins. TVBrowser is designed to look like a paper based TV guide. Included are over 80 German language channels.
At the moment, it only loads data in its own binary format, but its possible to write a plugin that loads XMLTV data.
The tv data are retrieved from multiple sources and can be downloaded from our servers after having been automatically processed.
The whole project - both the client and the server part - is distributed under the GNU GPL.
Currently, we offer only channels in german language but we are highly motivated to extend TV-Browser for other countries.
Enhancements:
- Minor bugfixes.

Metastorage is a PHP data access object generator compiler tool.
Metastorage is an application that automatically generates code for an Object Oriented API to store, retrieve and manipulate the persistent objects of classes described in a high level data model definition.
Metastorage provides a much more efficient development process for medium or large size applications that store and retrieve data from SQL based databases or other types of storage persistence containers, like XML files, flat file databases or LDAP servers.
When storing objects in SQL databases, Metastorage generated code performs efficient object-relational mapping. Metastorage antecipates static storage optimization decisions at compile time, so applications gain in performance, code size and memory usage by avoiding evaluating static decisions at run time.
Main features:
XML definition format
- Easy to write and understand component definition format in XML
Database schemas
- Automatic generation of (database) schema definition of the persistence container
Automatic generation of all classes
- Generates all the code for the data classes, factory class and (database) schema installation class
Self-contained code
- The generated code is self-contained and does not depend on MetaL or libraries of code that are not supplied
Object Query Language
- Provides an Object Query Language (OQL) to define expressions to filter objects in search queries
No SQL
- All code is generated without the need for the developer to write SQL code manually
Forms
- Generation of classes to create, validate and process Web forms to manage objects of the data classes.
Reports
- Generation of classes to execute queries to retrieve data from many objects to elaborate reports or to execute another kind of bulk processing
UML Diagrams
- Automatic generation of Entity-Relationship graphs in UML of the component class diagram

Fast Secure File System exports existing directories securely over the network, letting users store and retrieve encrypted data in a scalable and transparent way. FSFS is written in C and works on GNU/Linux systems on x86 and PPC architectures, with help from FUSE and OpenSSL.
File systems are easily the most evident, from the point of view of users, component of an operating system. Through file systems it is possible to organize data in a wide variety of ways, and access resources through a common interface.
Users can nowadays not only store and retrieve documents, but also find information on running processes and system settings (through ProcFS), access and manipulate e-mail (for example with GmailFS), or perform several other operations.
In several circumstances and scenarios it is desirable to protect stored files and directories from manipulation by unknown or malicious users: financial or health-related data, confidential documents, or any kind of personal or sensitive data may need to be stored securely, in such a way that it can not be examined or modified freely by third parties.
Most file systems do not take action in this sense, and external cryptographic utilities are sometimes employed to secure data before storage. While this can be a perfectly secure solution, it is not transparent to users.
Distributed file systems propose efficient ways of accessing data remotely as if it resided on the local machine; when it comes to dealing with securely stored data as in the examples above, care must be taken to preserve confidentiality and integrity also during network transfer.
Not all distributed file systems accomplish this task, weakening the overall security of the system, or do so inefficiently, making it inconvenient for users.
FSFS is a secure, distributed file system in users space, written in C with much help from FUSE and OpenSSL. It lets users store and retrieve data securely and transparently, knowing that it is protected both on permanent storage devices and while in transit over the network.
It is also concerned with scalability, therefore separates data cryptography from the server, leaving it to the clients; this approach is similar to the one used in CFS, and opposite to those taken on by other secure file system solutions (like NFS on top of IPsec).
FSFS is written as a pair of user space daemons that act as client and server. Because of this, it needs no kernel support (unlike NFS over IPsec), save the FUSE loadable kernel module on clients, included in Linux since 2.6.14; servers dont use FUSE and depend only on user space OpenSSL libraries.
Servers export an existing file system (of virtually any kind) to clients over the network through two separate channels: a TLS connection set up with OpenSSL, and a clear channel. Requests from the clients to the servers are sent via the TLS socket, thus they are encrypted and authenticated, according to TLS v1 specifications, by the channel itself and decrypted on receipt, as they are usually very short and the relevant cryptography does not constitute a great overhead; simple server replies undergo the same process.
Cryptography in this case happens at both ends of the transmission.
In a distributed file system, large amounts of data may be transferred between clients and servers, thus encrypting and decrypting everything may become too cumbersome for both parties, and as more clients are added to the system the server may severely lose performance; moreover, file data should be stored encrypted anyway, so the cryptography could be moved to the clients, in such a way that each encrypts data before a write operation sends it over the network to the server, and decrypts it after a read retrieves it.
This way servers only deal with TLS details and can concentrate on serving client requests by doing the relevant I/O on the underlying, "physical" file system. As the data is already encrypted, it does not need to go through the TLS channel and the corresponding overhead, but can be sent via the clear channel, provided the messages are authenticated.
Enhancements:
- This release fixes two bugs. One bug related to socket creation and would cause problems on some systems (namely OpenSUSE 10.2). The other bug related to server configuration creation when using the Python configuration utilities. Users dont need to upgrade to this release if theyre not experiencing problems or are not using the Python configuration utilities.