Home Blog Page 10719

LuteLinux

Author: Benjamin D. Thomas

LuteLinux simplifies. We make Linux easy to install and use. We
distribute Linux with an easy installer, and a great deal of application software. We are the provider of choice for installations, documentation,
training and certification, consulting and administration.

LuteLinux.com
is THE base on the web for LuteLinux information, downloads, support,
training, certification, and consulting.

LuteLinux
Simplifies
We make Linux easy to install and
use. We distribute Linux with an easy installer (we program
it so you don’t need to), and a great deal of application
software (we assess software, and collect the goods so you
don’t need to). From the workstation level to the server, we
are the provider of choice for installations, documentation,
training and certification, consulting and administration.
Whether you’re running a large network or a workstation, our
mission is to get your Linux system up and running as
quickly and efficiciently as possible.

LuteLinux
Certifies

We offer LuteLinux certification
to those who have completed our training. If you’re wanting
to gain new skills, sharpen present skills, train a staff or
just yourself, we have a wide range of training
alternatives, from instructor led classes to e-learning,
electronic information exchange to written manuals. Our
dynamic adaptive testing system ensures accurate assessments
for real world scenarios. Whatever your training needs, we
offer comprehensive training, testing and certification
services.

LuteLinux
Provides

We also offer management and
consulting services to both individuals and corporations.
These services range from installation and configuration of
software, to the technical management of the corporate
intranet. From the workstation level to the server, we are
the provider of choice for installations, documentation,
training and certification, consulting and administrative
services. We are truly a one stop Linux shop.

LuteLinux.
Simplify. Provide. Certify.

Website : www.lutelinux.com
Contact : info@lutelinux.com
 

And now for something completely different…

The following patch will change the behavior of the window maker dock to that of the clip allowing you to place icons in any arbitrary order.

(click the read more button for the patch)


Author: Mike Baker

--- wmaker-0.61.1.orig/src/dock.c Mon Sep 27 11:58:05 1999
+++ wmaker-0.61.1/src/dock.c Tue Nov 2 18:34:12 1999
@@ -1231,10 +1231,7 @@
dock = wmalloc(sizeof(WDock));
memset(dock, 0, sizeof(WDock));

- if (type == WM_CLIP)
icon_count = CLIP_MAX_ICONS;
- else
- icon_count = scr->scr_height/wPreferences.icon_size;

dock->icon_array = wmalloc(sizeof(WAppIcon*)*icon_count);
memset(dock->icon_array, 0, sizeof(WAppIcon*)*icon_count);
@@ -1673,14 +1670,6 @@
wwarning(_("bad value in docked icon state info %s"),
PLGetString(dPosition));

- /* check position sanity */
- /* incomplete section! */
- if (type == WM_DOCK) {
- aicon->xindex = 0;
- if (aicon->yindex xindex, aicon->yindex);
- }
} else {
aicon->yindex = index;
aicon->xindex = 0;
@@ -2538,82 +2527,30 @@
return False;

if (dock->type == WM_DOCK) {
- if (icon->dock != dock && ex_x != 0)
- return False;
-
+ int neighbours = 0;
aicon = NULL;
for (i=0; imax_icons; i++) {
nicon = dock->icon_array[i];
- if (nicon && nicon->yindex == ex_y) {
+ if (nicon && nicon->xindex == ex_x && nicon->yindex == ex_y) {
aicon = nicon;
break;
}
}
-
- if (redocking) {
- int sig, done, closest;
-
- /* Possible cases when redocking:
- *
- * icon dragged out of range of any slot -> false
- * icon dragged to range of free slot
- * icon dragged to range of same slot
- * icon dragged to range of different icon
- */
- if (abs(ex_x) > DOCK_DETTACH_THRESHOLD)
- return False;
-
- if (ex_y>=0 && ex_y= 0) {
- for (j = 0; jmax_icons; j++) {
- if (dock->icon_array[j]
- && dock->icon_array[j]->yindex==closest) {
- /* slot is used by someone else */
- if (dock->icon_array[j]!=icon)
- done = 0;
+ for (i=0; imax_icons; i++) {
+ nicon = dock->icon_array[i];
+ if (nicon && nicon != icon && /* Icon can't be it's own neighbour */
+ (abs(nicon->xindex - ex_x) yindex - ex_y) = 0 && closest = closest && ex_y - closest = 0 && ex_y 

Color up your life with vim

‘vim’ (vi Improved) has built in syntax highlighting. To enable this, simply enter command mode (:) and type syntax on. You can even add your own syntax highlighting schemes, which are placed in /usr/share/vim/syntax


Author: Marius Aamodt Eriksen

Name that NIC

Did you know the IEEE is responsibe for the MAC (machine address) of your network card? Click here and punch in the first 6 hex digits of your card (3 bytes) to see the manufacturer.
On a related note, you can also have your card use a different MAC address

ifconfig eth1 hw ether deadbeef0001
(this needs do be done while the card is down for obvious reasons)

now your card will answer all arp requests with DE:AD:BE:EF:00:01.

Note:

The kernel performs this trick on most cards by setting the card into promiscuous mode and using software to filter out all MACs that aren’t yours which stands to reason it would be slightly slower than just using your real MAC.


Author: Mike Baker

Elfstone Linux

Author: Benjamin D. Thomas

Elfstone Linux is a highly stable Linux distribution
specifically designed for
programmers, engineers and network administrators. This distro is a networking specific OS and perhaps the most Unix-like of all commercial
distributions. Keeping it simple, thin, and fast is the common sense principal and basis for all Elfstone products.

Elfstone Linux

Elfstone Linux is a highly stable Linux distribution designed specifically for programmers,
engineers, and network administrators. As a real
network OS and perhaps the most Unix-like of all commercial distributions, Elfstone Linux is built around the OSF Motif 2.1 API with a universal
package management feature. This distribution currently based on the .RPM format easily allows for the installation of both RPMs and Tar/Tar.gz
packages.

Unlike other commercial distributions, Elfstone Linux was not designed from the installation perspective to share disk partitions with other
operating systems. Elfstone Linux is among the first distributions to provide USB
support as well as the highly intuitive, and extremely fast, interface that is a Motif/Athena hybrid.

Click for screen shots

The key to the outstanding performance of Elfstone Linux is really very simple. When servers are called upon to perform specific tasks, potential
points of failure are created when the software includes more than what is required to perform these functions.

Keeping it simple, is the common sense principal and basis for the development of all Elfstone products. Elfstone Linux contains only the software
that is necessary to operate your network each and every day without fail. Each app has been chosen strictly on the basis of
functionalityand reliability. While Linux has many fine applications available, we believe there is no need to load working servers with
unnecessary software.

Here is a quick list of what’s included with Elfstone Linux

  • The Linux 2.2.6 kernel with supporting libraries.
  • The Xfree86 windowing system with supporting libraries.
  • The GNU gcc compiler and supporting tools.
  • The Elfstone RTX Runtime libraries based on OSF Motif 2.1.
  • An excellent collection of handpicked system administration tools.
  • An efficient universal package management system tool.

    For more information about Elfstone Linux, please visit our website at
    http://www.elflinux.com

Best Linux

Author: Benjamin D. Thomas

The Best Linux operating system is easy to install with no
complicated options. Graphical installation goes smoothly, either on a new computer or beside another operating system. Selecting which operating
system to start is simple thanks to an advanced graphical boot menu.

Versatile
Best Linux is perfectly suited for use in the home, as a workstation or an internet
server.

Easy to install and versatile

The Best Linux operating system is easy to install with no complicated options.
Graphical installation goes smoothly, either on a new computer or beside another
operating system. Selecting which operating system to start is simple thanks to
an advanced graphical boot menu.

StarOfficeBest Linux starts straight into a graphical Windows-like KDE-desktop which
includes almost all of the software that you use daily. The multilingual desktop
consist of multiple workspaces to help you group your tasks. You can use one workspace
for work matters, another to surf the internet and a third e.g. for writing a
book. All this is possible due to Best Linux’s superior multi-tasking.

Best Linux supports networks

With Best Linux it’s easy to connect to the Internet. Largely based on Unix
servers, the Internet functions perfectly with Linux, a variety of Unix. You will
notice the difference in its superior performance and security. Best Linux will
not easily become infected by viruses which spread over the Internet. The operating
system includes a wide range of internet services, which gives you the opportunity
e.g. to easily build your own email and Web server. Best Linux functions as a
reliable and robust server for local area networks. It serves e.g. Windows and
NT workstations as a file and print server. A Best Linux file server for Windows
workstations outperforms NT in speed.


Better value from the most popular Linux in Finland

Best Linux is a completely free operating system with open source code. Because
of this, anyone can participate in developing it. This ensures that new drivers
and fixes are quickly produced. Linux is an operating system made by and for its
users, of which it has nearly 20 million around the globe. In only 4 months Best
Linux has become the most popular Linux distribution in Finland, the home of Linux.
It differs from other Linuxes in its reliability and precise refinement.

After an easy installation Best Linux requires almost no configuring or fine-tuning,
because we’ve already done that for you. Best Linux is also more secure. At boot,
no unnecessary programs are started automatically. For home users Best Linux offers
a CD-ROM full of carefully tested and selected Linux games. To guarantee a successful
installation we provide you with an installation support service during the life
span of the program. And finally, as an extra bonus we will ship you the latest
installation CD after you have registered your Best Linux for free. This guarantees
that your Best Linux Box is always up-to-date regardless of the date of purchase.

How does Best Linux compare with other distributions? See our comparison chart for
details.

Includes over 2000 applications: Star Office(tm), games, multimedia, desktop publishing,
utilities, programming languages, compilers, databases, instructions and manuals,

TECHNICAL SPECIFICATIONS (R2):

Kernel 2.2.14
XFree86 3.3.6 and 4.0
KDE 1.1.2
Star Office(tm) 5.1a

Languages supported by Best Linux: Finnish, Swedish, English, Russian, Estonian,
French, German and Spanish. Other languages which are not yet completely supported
are Czech, Danish, Hungarian, Icelandic, Indonesian, Italian, Norwegian, Polish,
Portuguese, Romanian, Serbian, Slovak, Turkish and Ukrainian. Please see the todo
directory in your installation CD.

CONTENTS:

Complete documentation

A printed manual and reference book.

Thousands of pages of manuals and instructions in electronic format
to help you to configure, fine-tune and utilize your Best Linux Operating System

4 CD-ROMs in a handy box

Best Linux Installation CD

Best Linux Source code CD

Best Linux Games CD

Well-tested Linux games and emulators, e.g. DOS, Atari ST, Amiga, C64, C128,
VIC20, PET, ZX Spectrum, Gameboy, Nintendo, ZX81.

Best Linux Software Library CD

A comprehensive software collection.

Installation support in English, Finnish, Russian and Estonian

System requirements and supported hardware

All processors from Intel 386 to the latest Pentium III and compatible

Hard disk space at least 160 MB for minimal, 900 MB for typical and
1400 MB for full installations excluding swap

Minimum of 32 MB RAM, 64 MB or more recommended

CD-ROM

Best Linux also supports most video cards, monitors, sound cards, printers,
network cards, IDE, Ultra DMA (33 and 66) and SCSI hard disks, scanners, modems,
ISDN cards, some USB devices and many other peripherals. Further information regarding
supported hardware can be obtained from Hardware Compatibility
List
.

Support and training

Price includes the most recent installation CD update sent to you by
mail after registration and an installation support service during the life span
of the program delivered by SOT Support System.

The latest updates are available at ftp.bestlinux.net.

Best Linux news group alt.os.linux.best
and mailing lists provide a forum for discussions and
fast answers to your questions about Best Linux

Commercial technical support

Training and certification

Publication

Title: Best Linux 2000 R2 (Moscow)
Author: SOT Finnish Software Engineering Ltd. and others
Publisher: SOT Finnish Software Engineering Ltd, Finland
Date: 11.5.2000
UPC-code: 69871732000
ISBN (User Manual): 952-5320-02-2
Language : English

For more information, please see: http://www.bestlinux.net/

Sun, Sun Microsystems, the Sun Logo, StarOffice and StarOffice
logo are trademarks or registered trademarks of Sun Microsystems,
Inc. in the United States and other countries, and are used under
license.

Libranet

Author: Benjamin D. Thomas

This top-notch distribution features a rich desktop
environment complete with popular applications. Designed for experienced and new users alike, Libranet delivers the promise of a GNU/Linux desktop
today.
This distribution will bring the best of GNU/Linux to your computer. Order or DOWNLOAD it now!

The Desktop

The focus of this distribution is ‘Linux on
the Desktop’. This excellent distribution, based on Debian, gives users a fully configured desktop complete with the best and most commonly used
applications and window managers. Linux by Libranet is the the most comprehensive desktop available.

User
   Friendly

Libranet is user friendly for new users and a quick track to an accomplished desktop for experienced users. The simple install
together with automatic configuration and selection of software packages, make the system easy to get up and running.

The Latest and Greatest

The best and
latest packages are included. Like IceWM window manager, the latest stable kernel and the KDE, Gnome and Enlightenment desktop environments.

  • Kernel 2.4.2
  • XFree86 4.0.1
  • KDE 2.1
  • ReiserFS
  • Libranet Adminmenu

Linux is Fun

We think that using a computer should be a fun filled and rewarding experience. We are thrilled with our desktop and
it’s gaining popularity and invite you to join us.

Please visit us at www.libranet.com

Get your’s on CD today!

DOWNLOAD it now!

Exploiting Amazon Web Services via PHP and SQLite

Author: Michael Stahnke

A few weeks ago a friend asked me how my book, Pro OpenSSH, was selling on Amazon.com. I was tracking the sales by going to Amazon.com and viewing the book page to examine the sales rank. The only data displayed about history information was today’s Sales Rank and Yesterday’s Sales Rank, which isn’t all that helpful. I decided to use PHP, SQLite, and the Amazon Web Services API to gather more useful data.

I thought it would be fun to track the sales rank over a period of time, then display a graph of the sales rank over time on a Web page.

You can gather data from Amazon in a number of ways. wget and grep could probably get the job done, but it is not elegant, nor is it encouraged by Amazon. The best way to get information is to use Amazon’s application programming interface (API).

Amazon’s Web Services (AWS) API offers a way to connect to the Amazon data warehouse and retrieve data about an Amazon item. To use the AWS API, you need to register with Amazon at the Amazon Web Services page. After registering, and accepting an end user license agreement (EULA), you will be given two keys: one for general access and requests, and one for verification and signing of requests. The general access key allows you to connect to the Amazon Web Services databases. The APIs are well-documented on the Amazon Web Services site.

I used the Amazon E-Commerce Service for my project to track sales rank on book titles over time. This service provides the ability to query an item via its Amazon Standard Identification Number (ASIN), International Standard Book Number (ISBN), author, artists, product name, publisher, or title, and retrieve virtually all information shown on the Amazon Web page about that item.

I started with an extremely simple PHP5 script that created the URL string you need to use with the Amazon Web service using Representational State Transfer (REST).

The PHP script is designed to run from the command line and POSTS a URL string. While you’re debugging the script, you can copy the URL string and paste it into a Web browser to verify that the Web services interaction is working appropriately. The following script shows the basic setup of the PHP script to query AWS.

<?
# Build URL that will query AWS
   $ACCESS_KEY =  'Access_Key';
  $asin =  '1590594762';
  $url =  'http://webservices.amazon.com/onca/xml?Service=AWSECommerceService';
  $url.=  "&AWSAccessKeyId=$ACCESS_KEY";
  $url.=  "&Operation=ItemLookup&IdType=ASIN&ItemId=$asin";
  $url.=  '&ResponseGroup=Medium,OfferFull';
  print   "<br />" . $url . "<br />";
?>

The output from this script is a URL you can enter in your browser. The browser will return some text formatted via XML. The XML schema for this text isn’t too complicated, and if you wanted to use an XSLT stylesheet, you could format the XML into HTML and have your presentation layer completed. However, my goal was not just to get information stored in Amazon’s database, but to store it myself so I can track the data over time.

For this I needed a data container. I had a few options for a data container in which to store statistics from the Web service queries. A relational database made the most sense, and PHP supports several. SQLite, introduced in PHP5, seemed like a nice choice, because SQLite is simple to administer and use.

Before you begin using SQLite, take a look at your PHP information and ensure that SQLite is supported by your configuration. If it is not, you can either compile the support into PHP or download an applicable package to add support for the database. Alternatively, you could use MySQL, PostgreSQL, Oracle, or another database.

Database setup

The database schema for this Web application involves two tables: one to track the unique Amazon Item Numbers (ASIN) and the initial date they were added into the tracking system, and the other to hold the ASIN, Sales Rank from Amazon, and datestamp for when the Sales Rank was updated. The small size of the database is a design feature.

The display page that shows the graphs, sales rank, and pricing information from Amazon will be updated upon display. That means we can pull the data, such as cover images, list price, description, title, and everything else dynamically. Amazon stores that information, so we don’t need to. Additionally, if the data changes, such as when price changes during a sale, the display page will have the updated information.

This is the basic schema for my SQLite database:

create table aws (
asin varchar(30),
sales_rank bigint,
active_date date);

create table item (
asin varchar(30) primary key);

Next, I added the ASIN into the item table manually via SQL. Obviously, you could write a PHP page to administer this portion of database interaction as well. After the initial script is modified to parse the XML and store the data into the database, you could set up the PHP script to run as a cron job. The script to fill the database will query the database to see what Amazon item numbers the script should be gathering statistics for. This allows for tracking of multiple items without any code changes, and thus does not lock the script into any hard-coded ASIN, as I used in the initial URL-building PHP code.

#!/usr/bin/php -q
<?php

  $DB="/var/www/db/aws.db";
  # Ensure database exists
  if (! file_exists($DB))
  {
    echo "The database file $DB not found.n";
    exit(05);
  }
  # Ensure database file is writable.
  elseif(is_writable($DB) != 1)
  {
    echo "Processing cannot continue, the database $DB cannot be written to.n";
    exit(06);
  }
  # Assumes basic Schema setup for $DB
  /* To get an appropriate database setup, simply run the following two lines
     of code inside an SQLITE prompt.
       create table item ( asin varchar(30) primary key);
      create table track ( asin varchar(30), sales_rank big_int, query_date date);
    To have an initial setup, an ASIN number must be entered into the 'item' table.
    In this case I have chosen my ISBN number for my book, Pro OpenSSH.
    Don't forget that rowid is kept internally in sqlite.
  */
  # Amazon Web Services access Key
  /* Get Amazon Web Services access Key (free) from http://aws.amazon.com
     The following key is not a working key, but used as an example.
  */
  $ACCESS_KEY='Access_Key';
  # Connect to database
  $dblink =  sqlite_open($DB) or die ("Couldn't connect to $DB");
  # Query database to find which ASINs to search on
  $sql = "SELECT asin FROM item ORDER BY asin";

 $resource_set = sqlite_query($dblink, $sql);
  $dt = date('Y-n-d H:i');
  while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
  {
    # Value for ASIN
    $asin=$row['asin'];
    # Build URL to query based on ASIN and ACCESS_KEY
    $url='http://webservices.amazon.com/onca/xml?Service=AWSECommerceService';
    $url.="&AWSAccessKeyId=$ACCESS_KEY";
    $url.="&Operation=ItemLookup&IdType=ASIN&ItemId=$asin";
    $url.='&ResponseGroup=Medium,OfferFull';
    # Place the results into an XML string
    $xml= file_get_contents($url);
    # Use Simple XML to put results into Simple XML object (requires PHP5)
    $simple_xml=simplexml_load_string($xml);
    # Retrieve Sales Rank
    $sales_rank=$simple_xml->Items->Item->SalesRank;
    # Place Sales rank in Database
    # Build SQL statement to insert values into database
    $sql2 = "INSERT INTO aws (sales_rank,active_date,asin) VALUES ('$sales_rank', '$dt', '$asin')";
    # Ensure Results are received
    $insert_results = sqlite_query($dblink, $sql2);
    {
 # Check results
    if($insert_results)
       echo "Database $DB updated.n";
    }
  }
    else
    {
       echo "Database $DB update failed.n";
       exit(07);
    }
?>

After retrieving results from AWS, the script inserts the sales rank parameter along with a date and which ASIN the information correlates to into the aws table. This table will provide the data points for displaying graphs and other presentation material about an Amazon item.

The script parses the XML shown after using a URL similar to the one seen in the first PHP listing. The XML is then loaded into a string using PHP’s file_get_contents function. From there the XML is loaded into a SimpleXML data structure that is a very thorough set of associative arrays that can reference any value contained inside XML tags. To see the whole listing you can use the var_dump or print_r functionality of PHP.

After finding the pertinent information to store — Sales Rank in this case — we use an insert statement to create a record inside the local database. If we get an error in almost any stage of execution, we exit and return a non-zero error code.

The final step is in presentation. As stated earlier, using XSLT to parse the XML is certainly an option, but for this exercise, I will just use native PHP functionality in conjunction with SimpleXML.

I wanted to graph the sales rank over time to show the status of my book sales. To do this, I used the Image::Graph PHP Extension and Application Repository (PEAR) module.

To install Image::Graph, follow normal PEAR installation procedures. The installation was fairly easy on Fedora and Ubuntu Linux systems. The next script is the display.php page, which accesses the database and displays the sales rank in graph form. The system could be modified easily to track price or albums from your favorite artist, or other items.

<?php
  #$Id$
  include 'Image/Graph.php';
  $DB="/var/www/db/aws.db";
  # Ensure database exists
  if (! file_exists($DB))
  {
    echo "The database file $DB not found.n";
    exit(05);
  }
  # Ensure database file is writable.
  elseif(is_writable($DB) != 1)
  {
    echo "Processing cannot continue, the database $DB cannot be written to.n";
    exit(06);
  }
  $ACCESS_KEY='Access_Key';
  # Connect to database
  $dblink =  sqlite_open($DB) or die ("Could connect to $DB");
  # Query database to find which ASINs to search on
  $sql = "SELECT asin FROM item ORDER BY asin";
  $resource_set = sqlite_query($dblink, $sql);
  print "<table>n";
  while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
  {
    # Value for ASIN
    $asin=$row['asin'];
    # Build URL to query based on ASIN and ACCESS_KEY
    $url='http://webservices.amazon.com/onca/xml?Service=AWSECommerceService';
    $url.="&AWSAccessKeyId=$ACCESS_KEY";
    $url.="&Operation=ItemLookup&IdType=ASIN&ItemId=$asin";
    $url.='&ResponseGroup=Medium,OfferFull';
    # Place the results into an XML string
    $xml= file_get_contents($url);
    # Use Simple XML to put results into Simple XML object
    $simple_xml=simplexml_load_string($xml);
    $author=$simple_xml->Items->Item->ItemAttributes->Author;
    $ISBN=$simple_xml->Items->Item->ItemAttributes->ISBN;
    $publisher=$simple_xml->Items->Item->ItemAttributes->Publisher;
    $publication_date=$simple_xml->Items->Item->ItemAttributes->PublicationDate;
    $title=$simple_xml->Items->Item->ItemAttributes->Title;
    $num_pages=$simple_xml->Items->Item->ItemAttributes->NumberOfPages;
    $list_price=$simple_xml->Items->Item->ItemAttributes->ListPrice->FormattedPrice;
    $image=$simple_xml->Items->Item->MediumImage->URL;
    $sale_price=$simple_xml->Items->Item->OfferSummary->LowestNewPrice->FormattedPrice;
    $min_rank=get_rank($asin,'min');
    $max_rank=get_rank($asin,'max');
    # Format the output, you'd probably want a CSS sheet of some sort
    print "<tr><td rowspan=6><IMG SRC=$image></td><td>Author: $author</td></tr>n
           <tr><td>Title: $title</td></tr>n
           <tr><td>Publisher: $publisher</td><tr>n
           <tr><td>ISBN: $ISBN</td></tr>n
           <tr><td>List Price: $list_price</td></tr>n
           <tr><td>Sale Price: $sale_price</td></tr>n
           <tr><td>Page Count: $num_pages</td></tr>n
           <tr><td>Best Rank: $min_rank</td></tr>n
           <tr><td>Worst Rank: $max_rank</td></tr>n
           <tr><td>Publication Date: $publication_date</td></tr>n";
   # Database chart points
  $Graph =& Image_Graph::factory('graph', array(600, 400));
  $Font =& $Graph->addNew('ttf_font', 'Verdana');
  $Font->setSize(10);
  $Graph->setFont($Font);
  $Plotarea =& $Graph->addNew('plotarea');
  $Dataset =& Image_Graph::factory('dataset');
  # SQL to get data points
  $sql="select active_date, sales_rank from aws where asin='$asin' order by active_date";
  $resource_set = sqlite_query($dblink, $sql);
  $i=0;
  while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
  {
      $Dataset->addPoint($i, $row['sales_rank']);
      $i++;
  }
  $AxisX =& $Plotarea->getAxis(IMAGE_GRAPH_AXIS_X);
  $AxisX->setTitle('Time');
  $AxisY =& $Plotarea->getAxis(IMAGE_GRAPH_AXIS_Y);
  $AxisY->setTitle('Sales Rank', 'vertical');
  $Plot =& $Plotarea->addNew('smooth_line', &$Dataset);
  $Graph->done(array('filename' => './output.png'));
  print "<IMG SRC='./output.png'>n";
  }
   print "</table>n";

function get_rank($asin, $type)
{
   global $dblink;
   $sql = "select $type(sales_rank) as rank from aws where asin='$asin'";
   $resource_set = sqlite_query($dblink, $sql);
   while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
   {
        return $row['rank'] ;
   }
}
?>

This PHP script retrieves information from the database and builds a graph based on the data collected. Here is a screen shot of the page in action.

This bit of code should look similar to the first listing, in that it makes database calls to the SQLite database and interacts with Amazon via AWS. After getting the previous rankings out of the database, and displaying the information gathered via AWS, which is stored in a SimpleXML object, the script makes a call to Image::Graph, which uses the data points retrieved from the database and makes a line graph with the rank as the Y-axis and date/time as the X-axis. The script outputs the graph in .png format and displays it via HTML.

The get_rank function returns the highest or lowest rank the item has had since the database has been active. The rank is displayed when the price, picture, author, and other information is displayed.

All this work still leaves much to do to create a fully usable application, but this is a good start. Remember that by using the AWS API you can get information about other types of products from Amazon, including information from Wish Lists, Wedding Registries, and ListMania data.

Category:

  • PHP

Exploiting Amazon Web Services via PHP and SQLite

Author: Michael Stahnke

A few weeks ago a friend asked me how my book, Pro OpenSSH, was selling on Amazon.com. I was tracking the sales by going to Amazon.com and viewing the book page to examine the sales rank. The only data displayed about history information was today’s Sales Rank and Yesterday’s Sales Rank, which isn’t all that helpful. I decided to use PHP, SQLite, and the Amazon Web Services API to gather more useful data.

I thought it would be fun to track the sales rank over a period of time, then display a graph of the sales rank over time on a Web page.

You can gather data from Amazon in a number of ways. wget and grep could probably get the job done, but it is not elegant, nor is it encouraged by Amazon. The best way to get information is to use Amazon’s application programming interface (API).

Amazon’s Web Services (AWS) API offers a way to connect to the Amazon data warehouse and retrieve data about an Amazon item. To use the AWS API, you need to register with Amazon at the Amazon Web Services page. After registering, and accepting an end user license agreement (EULA), you will be given two keys: one for general access and requests, and one for verification and signing of requests. The general access key allows you to connect to the Amazon Web Services databases. The APIs are well-documented on the Amazon Web Services site.

I used the Amazon E-Commerce Service for my project to track sales rank on book titles over time. This service provides the ability to query an item via its Amazon Standard Identification Number (ASIN), International Standard Book Number (ISBN), author, artists, product name, publisher, or title, and retrieve virtually all information shown on the Amazon Web page about that item.

I started with an extremely simple PHP5 script that created the URL string you need to use with the Amazon Web service using Representational State Transfer (REST).

The PHP script is designed to run from the command line and POSTS a URL string. While you’re debugging the script, you can copy the URL string and paste it into a Web browser to verify that the Web services interaction is working appropriately. The following script shows the basic setup of the PHP script to query AWS.

<?
# Build URL that will query AWS
   $ACCESS_KEY =  'Access_Key';
  $asin =  '1590594762';
  $url =  'http://webservices.amazon.com/onca/xml?Service=AWSECommerceService';
  $url.=  "&AWSAccessKeyId=$ACCESS_KEY";
  $url.=  "&Operation=ItemLookup&IdType=ASIN&ItemId=$asin";
  $url.=  '&ResponseGroup=Medium,OfferFull';
  print   "<br />" . $url . "<br />";
?>

The output from this script is a URL you can enter in your browser. The browser will return some text formatted via XML. The XML schema for this text isn’t too complicated, and if you wanted to use an XSLT stylesheet, you could format the XML into HTML and have your presentation layer completed. However, my goal was not just to get information stored in Amazon’s database, but to store it myself so I can track the data over time.

For this I needed a data container. I had a few options for a data container in which to store statistics from the Web service queries. A relational database made the most sense, and PHP supports several. SQLite, introduced in PHP5, seemed like a nice choice, because SQLite is simple to administer and use.

Before you begin using SQLite, take a look at your PHP information and ensure that SQLite is supported by your configuration. If it is not, you can either compile the support into PHP or download an applicable package to add support for the database. Alternatively, you could use MySQL, PostgreSQL, Oracle, or another database.

Database setup

The database schema for this Web application involves two tables: one to track the unique Amazon Item Numbers (ASIN) and the initial date they were added into the tracking system, and the other to hold the ASIN, Sales Rank from Amazon, and datestamp for when the Sales Rank was updated. The small size of the database is a design feature.

The display page that shows the graphs, sales rank, and pricing information from Amazon will be updated upon display. That means we can pull the data, such as cover images, list price, description, title, and everything else dynamically. Amazon stores that information, so we don’t need to. Additionally, if the data changes, such as when price changes during a sale, the display page will have the updated information.

This is the basic schema for my SQLite database:

create table aws (
asin varchar(30),
sales_rank bigint,
active_date date);

create table item (
asin varchar(30) primary key);

Next, I added the ASIN into the item table manually via SQL. Obviously, you could write a PHP page to administer this portion of database interaction as well. After the initial script is modified to parse the XML and store the data into the database, you could set up the PHP script to run as a cron job. The script to fill the database will query the database to see what Amazon item numbers the script should be gathering statistics for. This allows for tracking of multiple items without any code changes, and thus does not lock the script into any hard-coded ASIN, as I used in the initial URL-building PHP code.

#!/usr/bin/php -q
<?php

  $DB="/var/www/db/aws.db";
  # Ensure database exists
  if (! file_exists($DB))
  {
    echo "The database file $DB not found.n";
    exit(05);
  }
  # Ensure database file is writable.
  elseif(is_writable($DB) != 1)
  {
    echo "Processing cannot continue, the database $DB cannot be written to.n";
    exit(06);
  }
  # Assumes basic Schema setup for $DB
  /* To get an appropriate database setup, simply run the following two lines
     of code inside an SQLITE prompt.
       create table item ( asin varchar(30) primary key);
      create table track ( asin varchar(30), sales_rank big_int, query_date date);
    To have an initial setup, an ASIN number must be entered into the 'item' table.
    In this case I have chosen my ISBN number for my book, Pro OpenSSH.
    Don't forget that rowid is kept internally in sqlite.
  */
  # Amazon Web Services access Key
  /* Get Amazon Web Services access Key (free) from http://aws.amazon.com
     The following key is not a working key, but used as an example.
  */
  $ACCESS_KEY='Access_Key';
  # Connect to database
  $dblink =  sqlite_open($DB) or die ("Couldn't connect to $DB");
  # Query database to find which ASINs to search on
  $sql = "SELECT asin FROM item ORDER BY asin";

 $resource_set = sqlite_query($dblink, $sql);
  $dt = date('Y-n-d H:i');
  while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
  {
    # Value for ASIN
    $asin=$row['asin'];
    # Build URL to query based on ASIN and ACCESS_KEY
    $url='http://webservices.amazon.com/onca/xml?Service=AWSECommerceService';
    $url.="&AWSAccessKeyId=$ACCESS_KEY";
    $url.="&Operation=ItemLookup&IdType=ASIN&ItemId=$asin";
    $url.='&ResponseGroup=Medium,OfferFull';
    # Place the results into an XML string
    $xml= file_get_contents($url);
    # Use Simple XML to put results into Simple XML object (requires PHP5)
    $simple_xml=simplexml_load_string($xml);
    # Retrieve Sales Rank
    $sales_rank=$simple_xml->Items->Item->SalesRank;
    # Place Sales rank in Database
    # Build SQL statement to insert values into database
    $sql2 = "INSERT INTO aws (sales_rank,active_date,asin) VALUES ('$sales_rank', '$dt', '$asin')";
    # Ensure Results are received
    $insert_results = sqlite_query($dblink, $sql2);
    {
 # Check results
    if($insert_results)
       echo "Database $DB updated.n";
    }
  }
    else
    {
       echo "Database $DB update failed.n";
       exit(07);
    }
?>

After retrieving results from AWS, the script inserts the sales rank parameter along with a date and which ASIN the information correlates to into the aws table. This table will provide the data points for displaying graphs and other presentation material about an Amazon item.

The script parses the XML shown after using a URL similar to the one seen in the first PHP listing. The XML is then loaded into a string using PHP’s file_get_contents function. From there the XML is loaded into a SimpleXML data structure that is a very thorough set of associative arrays that can reference any value contained inside XML tags. To see the whole listing you can use the var_dump or print_r functionality of PHP.

After finding the pertinent information to store — Sales Rank in this case — we use an insert statement to create a record inside the local database. If we get an error in almost any stage of execution, we exit and return a non-zero error code.

The final step is in presentation. As stated earlier, using XSLT to parse the XML is certainly an option, but for this exercise, I will just use native PHP functionality in conjunction with SimpleXML.

I wanted to graph the sales rank over time to show the status of my book sales. To do this, I used the Image::Graph PHP Extension and Application Repository (PEAR) module.

To install Image::Graph, follow normal PEAR installation procedures. The installation was fairly easy on Fedora and Ubuntu Linux systems. The next script is the display.php page, which accesses the database and displays the sales rank in graph form. The system could be modified easily to track price or albums from your favorite artist, or other items.

<?php
  #$Id$
  include 'Image/Graph.php';
  $DB="/var/www/db/aws.db";
  # Ensure database exists
  if (! file_exists($DB))
  {
    echo "The database file $DB not found.n";
    exit(05);
  }
  # Ensure database file is writable.
  elseif(is_writable($DB) != 1)
  {
    echo "Processing cannot continue, the database $DB cannot be written to.n";
    exit(06);
  }
  $ACCESS_KEY='Access_Key';
  # Connect to database
  $dblink =  sqlite_open($DB) or die ("Could connect to $DB");
  # Query database to find which ASINs to search on
  $sql = "SELECT asin FROM item ORDER BY asin";
  $resource_set = sqlite_query($dblink, $sql);
  print "<table>n";
  while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
  {
    # Value for ASIN
    $asin=$row['asin'];
    # Build URL to query based on ASIN and ACCESS_KEY
    $url='http://webservices.amazon.com/onca/xml?Service=AWSECommerceService';
    $url.="&AWSAccessKeyId=$ACCESS_KEY";
    $url.="&Operation=ItemLookup&IdType=ASIN&ItemId=$asin";
    $url.='&ResponseGroup=Medium,OfferFull';
    # Place the results into an XML string
    $xml= file_get_contents($url);
    # Use Simple XML to put results into Simple XML object
    $simple_xml=simplexml_load_string($xml);
    $author=$simple_xml->Items->Item->ItemAttributes->Author;
    $ISBN=$simple_xml->Items->Item->ItemAttributes->ISBN;
    $publisher=$simple_xml->Items->Item->ItemAttributes->Publisher;
    $publication_date=$simple_xml->Items->Item->ItemAttributes->PublicationDate;
    $title=$simple_xml->Items->Item->ItemAttributes->Title;
    $num_pages=$simple_xml->Items->Item->ItemAttributes->NumberOfPages;
    $list_price=$simple_xml->Items->Item->ItemAttributes->ListPrice->FormattedPrice;
    $image=$simple_xml->Items->Item->MediumImage->URL;
    $sale_price=$simple_xml->Items->Item->OfferSummary->LowestNewPrice->FormattedPrice;
    $min_rank=get_rank($asin,'min');
    $max_rank=get_rank($asin,'max');
    # Format the output, you'd probably want a CSS sheet of some sort
    print "<tr><td rowspan=6><IMG SRC=$image></td><td>Author: $author</td></tr>n
           <tr><td>Title: $title</td></tr>n
           <tr><td>Publisher: $publisher</td><tr>n
           <tr><td>ISBN: $ISBN</td></tr>n
           <tr><td>List Price: $list_price</td></tr>n
           <tr><td>Sale Price: $sale_price</td></tr>n
           <tr><td>Page Count: $num_pages</td></tr>n
           <tr><td>Best Rank: $min_rank</td></tr>n
           <tr><td>Worst Rank: $max_rank</td></tr>n
           <tr><td>Publication Date: $publication_date</td></tr>n";
   # Database chart points
  $Graph =& Image_Graph::factory('graph', array(600, 400));
  $Font =& $Graph->addNew('ttf_font', 'Verdana');
  $Font->setSize(10);
  $Graph->setFont($Font);
  $Plotarea =& $Graph->addNew('plotarea');
  $Dataset =& Image_Graph::factory('dataset');
  # SQL to get data points
  $sql="select active_date, sales_rank from aws where asin='$asin' order by active_date";
  $resource_set = sqlite_query($dblink, $sql);
  $i=0;
  while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
  {
      $Dataset->addPoint($i, $row['sales_rank']);
      $i++;
  }
  $AxisX =& $Plotarea->getAxis(IMAGE_GRAPH_AXIS_X);
  $AxisX->setTitle('Time');
  $AxisY =& $Plotarea->getAxis(IMAGE_GRAPH_AXIS_Y);
  $AxisY->setTitle('Sales Rank', 'vertical');
  $Plot =& $Plotarea->addNew('smooth_line', &$Dataset);
  $Graph->done(array('filename' => './output.png'));
  print "<IMG SRC='./output.png'>n";
  }
   print "</table>n";

function get_rank($asin, $type)
{
   global $dblink;
   $sql = "select $type(sales_rank) as rank from aws where asin='$asin'";
   $resource_set = sqlite_query($dblink, $sql);
   while ($row = sqlite_fetch_array($resource_set, SQLITE_ASSOC))
   {
        return $row['rank'] ;
   }
}
?>

This PHP script retrieves information from the database and builds a graph based on the data collected. Here is a screen shot of the page in action.

This bit of code should look similar to the first listing, in that it makes database calls to the SQLite database and interacts with Amazon via AWS. After getting the previous rankings out of the database, and displaying the information gathered via AWS, which is stored in a SimpleXML object, the script makes a call to Image::Graph, which uses the data points retrieved from the database and makes a line graph with the rank as the Y-axis and date/time as the X-axis. The script outputs the graph in .png format and displays it via HTML.

The get_rank function returns the highest or lowest rank the item has had since the database has been active. The rank is displayed when the price, picture, author, and other information is displayed.

All this work still leaves much to do to create a fully usable application, but this is a good start. Remember that by using the AWS API you can get information about other types of products from Amazon, including information from Wish Lists, Wedding Registries, and ListMania data.

Category:

  • PHP

Corel Linux

Author: Benjamin D. Thomas

Experience Linux® performance built specifically for the
desktop with Corel® LINUX® OS. Based on Debian, this powerful system delivers an incredibly easy-to-use, four-step graphical installer that
automatically detects most PCI hardware. Featuring a KDE-based, drag-and-drop desktop environment and an innovative browser-style file manager, Corel
LINUX OS is an exciting development.

Highlights
& Features


A Powerful, Easy-to-Use Operating SystemDesigned Specifically for Your Desktop
Corels enhancements to Debian GNU/Linux® and KDE deliver a graphical desktop
environment that lets you get up and running fast. Featuring a simple four-step
installation program, a full-featured file manager, centralized configuration and system
updates, and an e-mail client and Web browser, Corel® LINUX® OS combines powerful
performance with intelligent simplicity.

Easy Installation with Corel® Install
Express

  • Lets you install Corel LINUX OS in four easy steps
  • Automatically detects most PCI hardware
  • Provides integrated partitioning to allow a
    dual-boot system
  • Includes custom install option
  • Offers a comprehensive Help system

Click to enlarge

Easy File Management with Corel® File Manager

  • Features a friendly, graphical drag-and-drop
    design
  • Lets you browse local and Windows® network drives
  • Allows Web browsing and FTP Internet file
    transfers

Click to enlarge

Graphical Control Center / Easy-to-Use
Graphical Desktop

  • Enjoy a friendly, uncomplicated work environment
    with enhanced KDE desktop
  • Set your IP address, gateway, DNS server and
    domain server quickly and easily in the graphical Control Center
  • Easily install printers with an enhanced graphical
    interface

Click to enlarge

Click to enlarge

Easy System Updates

  • Easily update your system over the Web*
  • Install new applications with just a few clicks

Click to enlarge

Outstanding Compatibility

  • Easily share Windows files
  • Compatible with other Linux software
  • Seamless integration with Windows and UNIX®/Linux
    networking environments

*Internet connection required.

What’s Included

The following is a breakdown of the components included in Corel® LINUX® OS Download,
Standard, and Deluxe:

Components Corel LINUX OS Download Corel LINUX OS Standard Corel LINUX OS Deluxe
Corel LINUX OS based on
Debian 2.2 Kernel
Enhanced KDE Desktop
Corel® Install Express
Corel® File Manager
User Guide
Installation Technical Support
included (30 days)
E-mail E-mail
and telephone
Netscape® Communicator
Adobe® Acrobat® Reader
Instant Messenger ICQ
compatible client
Bitstream® and Type 1 fonts 20 200
Corel® WordPerfect® 8 for Linux® Light version Full version
Corel WordPerfect 8 for Linux User
Manual
eFax Plus service three
months free*
Enhanced sound drivers (OSS)
CIVILIZATION®: Call to Power
strategy game Limited Edition**
BRU Backup Software
3.5″ Linux Penguin Mascot

Also Included…

  • Apache, mail, news, IRC
  • C/C++ and other programming languages
  • TCP/IP, NFS, UUCP, PPP, SMB
  • Perl, Tcl/Tk, awk, sed and other UNIX® tools

*Internet connection required.
**Full version. Network play and Editor/Cheater disabled.

System Requirements

  • Pentium® or Pentium-compatible processor
  • 24 MB RAM (64 MB RAM recommended)
  • 500 MB of hard disk space
  • CD-ROM drive, 2 MB VGA PCI card and mouse
  • Supports most hardware designed for Pentium
    computers. Click here
    to find out more about hardware compatibility for Corel LINUX OS.

For more information on Corel®
Linux
®, visit:http://linux.corel.com

CoReL LiNuX 4eVeR – D.Toeg