root/trunk/hotstuff/scripts/dxsclient

#!/usr/bin/perl
#
# Web service invocation client
# Copyright (C) 2005, 2006 Josef Spillner <josef@kstuff.org>
# Published under 'GNU AGPLv3 or later' conditions

package dxsclient;

use strict;
use Getopt::Long qw(:config no_auto_abbrev bundling no_ignore_case);
use XML::DOM;
use MIME::Base64;
use SOAP::Lite; #+trace => "debug";
use Term::Shell;
use Data::Dumper;
use LWP::Simple;
use base qw(Term::Shell);

my $version = "0.9.3";

my $default_webservice = "http://localhost/cgi-bin/hotstuff-dxs";

my ($opt_upload, $opt_provider, $opt_help, $opt_information, $opt_categories, $opt_list);
my ($opt_version, $opt_webservice);

my %entrycache;
my %authcache;
my %categorycache;

$opt_webservice = $default_webservice;

my $options = GetOptions(
        "h|help"         => \$opt_help,
        "v|version"      => \$opt_version,
        "u|upload=s"     => \$opt_upload,
        "p|provider=s"   => \$opt_provider,
        "w|webservice=s" => \$opt_webservice,
        "i|information"  => \$opt_information,
        "c|categories"   => \$opt_categories,
        "l|list=s"       => \$opt_list
);
if(!$options){
        exit 1;
}

if($opt_help){
        print "dxsclient - command line client to the Desktop Exchange Service (DXS)\n";
        print "Copyright (C) 2005 - 2007 Josef Spillner <josef\@kstuff.org>\n";
        print "Published under 'GNU AGPLv3 or later' conditions\n";
        print;
        print "Operations:\n";
        print "[-u | --upload <file>   ] Upload .meta file and associated contents\n";
        print "[-i | --information     ] Display provider information\n";
        print "[-c | --categories      ] List available categories\n";
        print "[-l | --list <category> ] List all contents of a category\n";
        print;
        print "Options:\n";
        print "[-p | --provider <url>  ] Select a GHNS provider URL (overrides default webservice)\n";
        print "[-w | --webservice <url>] Select a webservice URL (if not given, use default: $default_webservice)\n";
        print "[-v | --version         ] Print version information\n";
        exit;
}
if($opt_version){
        print "$version\n";
        exit;
}

if($opt_provider){
        print "Loading GHNS provider file from $opt_provider...\n";
        $opt_webservice = "";

        my $outfile = "/tmp/provider.xml.xxx";
        mirror($opt_provider, $outfile);

        my $parser = new XML::DOM::Parser;
        my $doc = $parser->parsefile($outfile);

        my $ghnsproviders = $doc->getDocumentElement();
        for my $provider($ghnsproviders->getElementsByTagName("provider")){
                my $webservice = $provider->getAttribute("webservice");
                if($webservice){
                        my $name;
                        for my $title($provider->getElementsByTagName("title")){
                                $name = $title->getFirstChild()->getData;
                        }
                        print "Provider '$name' offers DXS\n";
                        $opt_webservice = $webservice;
                }
        }

        if(!$opt_webservice){
                print "Error: no GHNS provider with DXS found\n";
                exit 1;
        }
}

if($opt_information){
        information($opt_webservice);
        exit;
}
if($opt_upload){
        upload($opt_upload, $opt_webservice);
        exit;
}
if($opt_categories){
        categories($opt_webservice);
        exit;
}
if(defined $opt_list){
        list($opt_list, "", $opt_webservice);
        exit;
}

interactive();

sub SOAP::Transport::HTTP::Client::get_basic_credentials{
        print "This operation needs authentication!\n";

        my $user = $authcache{'user'};
        my $password = $authcache{'password'};

        if(!($user and $password)){
                my $shell = dxsclient->new;
                $user = $shell->prompt("Username: ", $user);
                $password = $shell->prompt("Password: ", $password);

                $authcache{'user'} = $user;
                $authcache{'password'} = $password;
        }

        return $user => $password;
}

sub upload{
        my $arg_file = shift(@_);
        my $arg_webservice = shift(@_);

        my ($author, $version, $release, $licence, $name, $category, $summary, $payload, $preview);
        my $error = 0;
        my %meta;

        print "Preparing web service invocation.\n";

        my $parser = new XML::DOM::Parser;
        my $doc = $parser->parsefile($arg_file);

        my $knewstuff = $doc->getDocumentElement();
        for my $stuff($knewstuff->getElementsByTagName("stuff")){
                $category = $stuff->getAttribute("category");
                my @taglist = $stuff->getElementsByTagName("*");
                for my $tag(@taglist){
                        my $tagname = $tag->getTagName;
                        my $tagvalue = "";
                        if($tag->getFirstChild){
                                $tagvalue = $tag->getFirstChild->getData;
                        }
        
                        if($tagname eq "author"){
                                $author = $tagvalue;
                        }elsif($tagname eq "version"){
                                $version = $tagvalue;
                        }elsif($tagname eq "release"){
                                $release = $tagvalue;
                        }elsif($tagname eq "licence"){
                                $licence = $tagvalue;
                        }elsif($tagname eq "name"){
                                $name = $tagvalue;
                        }elsif($tagname eq "summary"){
                                $summary = $tagvalue;
                        }elsif($tagname eq "payload"){
                                $payload = $tagvalue;
                        }elsif($tagname eq "preview"){
                                $preview = $tagvalue;
                        }
                }
        }

        local($/) = undef;

        open(FILE, $preview);
        my $preview_data = MIME::Base64::encode_base64(<FILE>);
        close(FILE);
        open(FILE, $payload);
        my $payload_data = MIME::Base64::encode_base64(<FILE>);
        close(FILE);

        $author = SOAP::Data->name("author" => $author);
        $version = SOAP::Data->name("version" => $version);
        $release = SOAP::Data->name("release" => $release);
        $licence = SOAP::Data->name("licence" => $licence);
        $name = SOAP::Data->name("name" => $name);
        $category = SOAP::Data->name("category" => $category);
        $summary = SOAP::Data->name("summary" => $summary);
        $payload = SOAP::Data->name("payload" => $payload_data);
        $preview = SOAP::Data->name("preview" => $preview_data);

        if(!$error){
                my $ns = "urn:DXS";

                my $ws = SOAP::Lite
                        #-> service("file:./ghns.wsdl")
                        -> readable(1)
                        -> uri($ns)
                        -> proxy($arg_webservice);

                my $som = $ws->GHNSUpload($author, $version, $release, $licence, $name, $category, $summary,
                        $payload, $preview);

                if($som->fault){
                        my $string = $som->faultstring;
                        chomp $string;
                        print "Error: $string\n";
                }else{
                        print "The response was:\n";
                        print $som->result, "\n";
                }
        }
}

sub information{
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $som = $ws->GHNSInfo();

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                my $server = $som->valueof("//GHNSInfoResponse/server");
                my $version = $som->valueof("//GHNSInfoResponse/version");
                my $provider = $som->valueof("//GHNSInfoResponse/provider");
                my $url = $som->valueof("//GHNSInfoResponse/url");
                print "Provider: $provider\n";
                print "Server: $server (Version $version)\n";
                print "URL: $url\n";
        }
}

sub categories{
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $som = $ws->GHNSCategories();

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                my $array_hashref = $som->valueof("//GHNSCategoriesResponse");
                my %array = %{$array_hashref};
                my @categories;
                if(ref($array{"category"}) eq "ARRAY"){
                        @categories = @{$array{"category"}};
                }else{
                        @categories = ($array{"category"});
                }
                for my $category_hashref(@categories){
                        my %category = %{$category_hashref};
                        my $categoryname = $category{"category"};
                        my $icon = $category{"icon"};
                        my $name = $category{"name"};
                        my $description = $category{"description"};
                        print "Category: $categoryname (Icon: $icon/Name: $name/Desc: $description)\n";

                        $categorycache{$categoryname} = 1;
                }
        }
}

sub list{
        my $arg_category = shift(@_);
        my $arg_feed = shift(@_);
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $category = SOAP::Data->name("category" => $arg_category);
        my $feed;
        if($arg_feed){
                $feed = SOAP::Data->name("feed" => $arg_feed);
        }

        my $som = $ws->GHNSList($category, $feed);

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                my @array_ref = $som->valueof("//GHNSListResponse/entries/entry");
                if(!$#array_ref){
                        print "Warning: no results returned\n";
                }

                for my $entry_hashref(@array_ref){
                        my %entry = %{$entry_hashref};
                        my $id = $entry{"id"};
                        my $author = $entry{"author"};
                        my $name = $entry{"name"};
                        print "Entry: ($id) $name ($author)\n";

                        $entrycache{$id} = $entry_hashref;
                }

                my $notapproved = $som->dataof("//GHNSListResponse/entries")->attr->{"notapproved"};
                if($notapproved > 0){
                        print "[... and $notapproved still in the queue...]\n";
                }
        }
}

sub history{
        my $arg_id = shift(@_);
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $id = SOAP::Data->name("id" => $arg_id);

        my $som = $ws->GHNSHistory($id);

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                my @entries;
                my $entries_array = $som->valueof("//GHNSHistoryResponse");
                if($entries_array){
                        @entries = @{$entries_array};
                }
                for my $entry_hash(@entries){
                        my %entry = %{$entry_hash};
                        my $id = $entry{"id"};
                        my $author = $entry{"author"};
                        my $name = $entry{"name"};
                        print "Entry: ($id) $name ($author)\n";

                        $entrycache{$id} = $entry_hash;
                }
        }
}

sub rating{
        my $arg_id = shift(@_);
        my $arg_rating = shift(@_);
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $id = SOAP::Data->name("id" => $arg_id);
        my $rating = SOAP::Data->name("rating" => $arg_rating);

        my $som = $ws->GHNSRating($id, $rating);

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                print "New collective rating is:\n";
                print $som->result, "\n";
        }
}

sub comment{
        my $arg_id = shift(@_);
        my $arg_comment = shift(@_);
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $id = SOAP::Data->name("id" => $arg_id);
        my $comment = SOAP::Data->name("comment" => $arg_comment);

        my $som = $ws->GHNSComment($id, $comment);

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                print "Comment added.\n";
        }
}

sub comments{
        my $arg_id = shift(@_);
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $id = SOAP::Data->name("id" => $arg_id);

        my $som = $ws->GHNSComments($id);

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                print "Comments on this entry:\n";

                my @array_ref = $som->valueof("//GHNSCommentsResponse/comments");

                for my $comment(@array_ref){
                        print "** $comment\n";
                }
        }
}

sub removal{
        my $arg_id = shift(@_);
        my $arg_webservice = shift(@_);

        my $ns = "urn:DXS";

        my $ws = SOAP::Lite
                -> readable(1)
                -> uri($ns)
                -> proxy($arg_webservice);

        my $id = SOAP::Data->name("id" => $arg_id);

        my $som = $ws->GHNSRemoval($id);

        if($som->fault){
                my $string = $som->faultstring;
                chomp $string;
                print "Error: $string\n";
        }else{
                print "Removal successfully requested.\n";
        }
}

sub interactive{
        my $shell = dxsclient->new;

        run_webservice(undef, $opt_webservice);

        $shell->cmdloop();
}

sub prompt_str{
        "dxs> ";
}

sub smry_info{
        "Display provider information";
}

sub smry_categories{
        "List available categories";
}

sub smry_list{
        "List all contents of a category";
}

sub smry_preview{
        "Download and view preview";
}

sub smry_install{
        "Download and install payload";
}

sub smry_details{
        "More information about an entry";
}

sub smry_history{
        "List historic information about an entry";
}

sub smry_webservice{
        "Toggle webservice URL";
}

sub smry_rating{
        "Change rating of an entry";
}

sub smry_comment{
        "Append a comment";
}

sub smry_comments{
        "List all comments";
}

sub smry_removal{
        "Request removal of an entry";
}

sub comp_list{
        shift(@_);
        my $word = shift(@_);

        my @list = ();

        foreach my $key(keys(%categorycache)){
                if($key =~ /^$word/){
                        @list = (@list, $key);
                }
        }

        return @list;
}

sub run_info{
        information($opt_webservice);
}

sub run_categories{
        categories($opt_webservice);
}

sub run_list{
        shift(@_);
        my $opt_category = shift(@_);
        my $opt_feed = shift(@_);
        if(defined $opt_category){
                list($opt_category, $opt_feed, $opt_webservice);
        }else{
                print "Syntax: list <category> [<feed>]\n";
        }
}

sub run_rating{
        shift(@_);
        my $opt_id = shift(@_);
        my $opt_rating = shift(@_);
        if($opt_id and $opt_rating){
                rating($opt_id, $opt_rating, $opt_webservice);
        }else{
                print "Syntax: rating <id> <rating=0..100>\n";
        }
}

sub run_comment{
        shift(@_);
        my $opt_id = shift(@_);
        my $opt_comment = shift(@_);
        if($opt_id and $opt_comment){
                comment($opt_id, $opt_comment, $opt_webservice);
        }else{
                print "Syntax: comment <id> <comment text>\n";
        }
}

sub run_comments{
        shift(@_);
        my $opt_id = shift(@_);
        if($opt_id){
                comments($opt_id, $opt_webservice);
        }else{
                print "Syntax: comments <id>\n";
        }
}

sub run_removal{
        shift(@_);
        my $opt_id = shift(@_);
        if($opt_id){
                removal($opt_id, $opt_webservice);
        }else{
                print "Syntax: removal <id>\n";
        }
}

sub run_preview{
        shift(@_);
        my $arg_id = shift(@_);
        if($arg_id){
                entry_preview($arg_id);
        }else{
                print "Syntax: preview <id>\n";
        }
}

sub run_install{
        shift(@_);
        my $arg_id = shift(@_);
        if($arg_id){
                entry_install($arg_id);
        }else{
                print "Syntax: install <id>\n";
        }
}

sub run_details{
        shift(@_);
        my $arg_id = shift(@_);
        if($arg_id){
                entry_details($arg_id);
        }else{
                print "Syntax: details <id>\n";
        }
}

sub run_history{
        shift(@_);
        my $arg_id = shift(@_);
        if($arg_id){
                entry_history($arg_id);
        }else{
                print "Syntax: history <id>\n";
        }
}

sub run_webservice{
        shift(@_);
        $opt_webservice = shift(@_);
        if($opt_webservice){
                print "Webservice is set to: $opt_webservice\n";
        }else{
                print "Syntax: webservice <url>\n";
        }
}

sub run_{
}

sub entry_preview{
        my $arg_id = shift(@_);

        my $entry_hash = $entrycache{$arg_id};
        if(!$entry_hash){
                print "Error: Unknown id $arg_id\n";
                return;
        }

        my %entry = %{$entry_hash};
        my $preview = $entry{"preview"};

        my $outfile = "/tmp/dxsclient.out.png";
        mirror($preview, $outfile);
        system("gqview $outfile");
}

sub entry_install{
        my $arg_id = shift(@_);

        my $entry_hash = $entrycache{$arg_id};
        if(!$entry_hash){
                print "Error: Unknown id $arg_id\n";
                return;
        }

        my %entry = %{$entry_hash};
        my $payload = $entry{"payload"};

        my $outfile = "/tmp/dxsclient.out.xxx";
        mirror($payload, $outfile);
        system("ls -la $outfile");
}

sub entry_details{
        my $arg_id = shift(@_);

        my $entry_hash = $entrycache{$arg_id};
        if(!$entry_hash){
                print "Error: Unknown id $arg_id\n";
                return;
        }

        my %entry = %{$entry_hash};
        my $id = $entry{"id"};
        my $author = $entry{"author"};
        my $name = $entry{"name"};
        my $version = $entry{"version"};
        my $release = $entry{"release"};
        my $releasedate = $entry{"releasedate"};
        my $preview = $entry{"preview"};
        my $payload = $entry{"payload"};
        my $summary = $entry{"summary "};
        my $rating = $entry{"rating"};
        my $downloads = $entry{"downloads"};
        my $category = $entry{"category"};
        my $licence = $entry{"licence"};

        print "Name: $name\n";
        print "Author: $author\n";
        print "Version: $version\n";
        print "Release: $release\n";
        print "Release date: $releasedate\n";
        print "Preview: $preview\n";
        print "Payload: $payload\n";
        print "Summary: $summary\n";
        print "Rating: $rating\n";
        print "Downloads: $downloads\n";
        print "Category: $category\n";
        print "Licence: $licence\n";
}

sub entry_history{
        my $arg_id = shift(@_);

        my $entry_hash = $entrycache{$arg_id};
        if(!$entry_hash){
                print "Error: Unknown id $arg_id\n";
                return;
        }

        my %entry = %{$entry_hash};

        history($arg_id, $opt_webservice);
}