IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4440


Ignore:
Timestamp:
Jun 29, 2005, 4:35:06 PM (21 years ago)
Author:
jhoblitt
Message:

rename PS::IPP::IData -> Nebulous

Location:
trunk
Files:
99 edited

Legend:

Unmodified
Added
Removed

  • trunk/Nebulous-Server/Build.PL

    r3004 r4440  
    77
    88$build_pkg->new(
    9     module_name         => 'PS::IPP::IData',
    10     dist_version_from   => 'lib/PS/IPP/IData/Server.pm',
     9    module_name         => 'Nebulous',
     10    dist_version_from   => 'lib/Nebulous/Server.pm',
    1111    author              => 'Joshua Hoblitt <jhoblitt@cpan.org>',
    1212    license             => 'gpl',

  • trunk/Nebulous-Server/MANIFEST

    r4118 r4440  
    77README
    88Todo
    9 bootstrap.sh
    109docs/apache_setup.txt
    1110docs/c_api.h
    … …  
    1615docs/setup.txt
    1716docs/tmp.txt
    18 gsoap/idata.wsdl
    19 lib/PS/IPP/IData/Client.pm
    20 lib/PS/IPP/IData/Client/HTTP.pm
    21 lib/PS/IPP/IData/Client/Log.pm
    22 lib/PS/IPP/IData/Server.pm
    23 lib/PS/IPP/IData/Server/Apache.pm
    24 lib/PS/IPP/IData/Server/Log.pm
    25 lib/PS/IPP/IData/Server/SQL.pm
    26 lib/PS/IPP/IData/Util.pm
     17gsoap/nebulous.wsdl
     18lib/Nebulous/Client.pm
     19lib/Nebulous/Client/HTTP.pm
     20lib/Nebulous/Client/Log.pm
     21lib/Nebulous/Server.pm
     22lib/Nebulous/Server/Apache.pm
     23lib/Nebulous/Server/Log.pm
     24lib/Nebulous/Server/SQL.pm
     25lib/Nebulous/Util.pm
    2726scripts/bench_test.pl
    2827scripts/imageserver.pl
    … …  
    4544t/15_client_unlock.t
    4645t/16_client_find_instances.t
     46t/17_client_find.t
     47t/18_client_open.t
     48t/19_client_delete.t
     49t/20_client_copy.t
     50t/21_client_move.t
     51t/22_client_delete_instance.t
     52t/23_client_stat.t
    4753t/TEST.PL
    48 t/Test/IData.pm
     54t/Test/Nebulous.pm
    4955t/apache_03_server_create_object.x
    5056t/apache_04_server_replicate_object.x
    5157t/apache_05_server_lock_object.x
    5258t/conf/extra.conf.in
     59t/conf/startup.pl.in

  • trunk/Nebulous-Server/Todo

    r3013 r4440  
    1 TODO list for Perl module PS::IPP::IData
     1TODO list for Perl module Nebulous
    22
    33- redo database scheme with foreign keys

  • trunk/Nebulous-Server/docs/apache_setup.txt

    r2997 r4440  
    11# Copyright (C) 2004-2005  Joshua Hoblitt
    22#
    3 # $Id: apache_setup.txt,v 1.2 2005-01-14 21:23:35 jhoblitt Exp $
     3# $Id: apache_setup.txt,v 1.3 2005-06-30 02:35:05 jhoblitt Exp $
    44
    55- mod_perl-1.29 install
    … …  
    88#MP_TRACE = 1 MP_DEBUG = 1 MP_USE_DSO = 1 MP_INST_APACHE2 = 1 MP_APXS = /usr/sbin/apxs2
    99
    10 - add the "idata" group to /etc/group
    11 - configure Apache to run as the idata group.
     10- add the "nebulous" group to /etc/group
     11- configure Apache to run as the nebulous group.
     12
     13# out of data from here down...
    1214
    1315#
    … …  
    1517#
    1618
    17 ScriptAlias /idata /usr/local/apache/perl/imageserver.pl
     19ScriptAlias /nebulous /usr/local/apache/perl/imageserver.pl
    1820
    1921<Directory "/usr/local/apache/perl">
    … …  
    3436
    3537#
    36 # PS::IPP::IData::Apache interface
     38# Nebulous::Apache interface
    3739#
    3840
    3941PerlModule Apache::DBI
    40 PerlModule PS::IPP::IData::Apache
     42PerlModule Nebulous::Apache
    4143
    42 <Location /idata>
     44<Location /nebulous>
    4345        SetHandler perl-script
    44         PerlHandler PS::IPP::IData::Apache
     46        PerlHandler Nebulous::Apache
    4547</Location>
    4648

  • trunk/Nebulous-Server/docs/setup.txt

    r4119 r4440  
    3333
    3434
    35 mkdir /po01/idata
    36 chown root:idata /po01/idata
    37 chmod 0770 /po01/idata
     35mkdir /po01/nebulous
     36chown root:nebulous /po01/nebulous
     37chmod 0770 /po01/nebulous
    3838
    3939in /etc/mysql/my.cnf

  • trunk/Nebulous-Server/lib/Nebulous/Server.pm

    r2905 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Server.pm,v 1.8 2005-01-05 04:31:59 jhoblitt Exp $
    4 
    5 package PS::IPP::IData::Server;
     3# $Id: Server.pm,v 1.9 2005-06-30 02:35:06 jhoblitt Exp $
     4
     5package Nebulous::Server;
    66
    77use strict;
    … …  
    1111
    1212use DBI;
    13 use PS::IPP::IData::Util qw( :standard );
    14 use PS::IPP::IData::Server::Log;
    15 use PS::IPP::IData::Server::SQL;
     13use Nebulous::Util qw( :standard );
     14use Nebulous::Server::Log;
     15use Nebulous::Server::SQL;
    1616use Log::Log4perl;
    1717use Params::Validate qw( validate_pos SCALAR );
    … …  
    4040    );
    4141
    42     $log = Log::Log4perl::get_logger( "PS::IPP::IData::Server" );
    43     $sql = PS::IPP::IData::Server::SQL->new;
     42    $log = Log::Log4perl::get_logger( "Nebulous::Server" );
     43    $sql = Nebulous::Server::SQL->new;
    4444
    4545    $log->debug( "entered - @_" );

  • trunk/Nebulous-Server/lib/Nebulous/Server.pod

    r2863 r4440  
    33=head1 NAME
    44
    5 PS::IPP::IData::Server - iData server component
     5Nebulous::Server - Nebulous server component
    66
    77=head1 SYNOPSIS
    88
    9     use PS::IPP::IData::Server;
     9    use Nebulous::Server;
    1010
    11     PS::IPP::IData::Server->setup( $dsn, $username, $passwd );
    12     PS::IPP::IData::Server->create_object( $key, $class, $volume, $comment );
    13     PS::IPP::IData::Server->replicate_object( $key, $volume );
    14     PS::IPP::IData::Server->lock_object( $key, $type );
    15     PS::IPP::IData::Server->unlock_object( $key, $type );
    16     PS::IPP::IData::Server->find_instance( $key, $volume );
    17     PS::IPP::IData::Server->delete_instance( $uri );
    18     PS::IPP::IData::Server->stat_object( $key );
     11    Nebulous::Server->setup( $dsn, $username, $passwd );
     12    Nebulous::Server->create_object( $key, $class, $volume, $comment );
     13    Nebulous::Server->replicate_object( $key, $volume );
     14    Nebulous::Server->lock_object( $key, $type );
     15    Nebulous::Server->unlock_object( $key, $type );
     16    Nebulous::Server->find_instance( $key, $volume );
     17    Nebulous::Server->delete_instance( $uri );
     18    Nebulous::Server->stat_object( $key );
    1919
    2020=head1 DESCRIPTION
    2121
    22 This is the server side component of the iData system.  It is primarily a
     22This is the server side component of the Nebulous system.  It is primarily a
    2323middle-ware abstraction of an SQL database.
    2424
    … …  
    120120=head1 SEE ALSO
    121121
    122 L<PS::IPP::IData::Client>
     122L<Nebulous::Client>
    123123
    124124=cut

  • trunk/Nebulous-Server/lib/Nebulous/Server/Apache.pm

    r2918 r4440  
    33# $Id
    44
    5 package PS::IPP::IData::Server::Apache;
     5package Nebulous::Server::Apache;
    66
    77use strict;
    … …  
    1010our $VERSION = 0.01;
    1111
    12 use PS::IPP::IData::Server::SOAP;
     12use Nebulous::Server::SOAP;
    1313use SOAP::Transport::HTTP;
    1414
    1515my $server = SOAP::Transport::HTTP::Apache
    16     ->dispatch_to( 'PS::IPP::IData::Server::SOAP' )
     16    ->dispatch_to( 'Nebulous::Server::SOAP' )
    1717    ->options({ compress_threshold => 10 * 1024 });
    1818

  • trunk/Nebulous-Server/lib/Nebulous/Server/Log.pm

    r2898 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Log.pm,v 1.2 2005-01-05 02:44:54 jhoblitt Exp $
     3# $Id: Log.pm,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Server::Log;
     5package Nebulous::Server::Log;
    66
    77use strict;
    … …  
    1313                                                                                                                                         
    1414my $conf = q(
    15     log4perl.category.PS.IPP.IData.Server = DEBUG, SERVERLOGFILE
     15    log4perl.category.Nebulous.Server = DEBUG, SERVERLOGFILE
    1616
    1717    log4perl.appender.SERVERLOGFILE           = Log::Log4perl::Appender::File
    18     log4perl.appender.SERVERLOGFILE.filename  = /tmp/idata_server.log
     18    log4perl.appender.SERVERLOGFILE.filename  = /tmp/nebulous_server.log
    1919    log4perl.appender.SERVERLOGFILE.mode      = append
    2020    log4perl.appender.SERVERLOGFILE.layout    = Log::Log4perl::Layout::PatternLayout

  • trunk/Nebulous-Server/lib/Nebulous/Server/SOAP.pm

    r2917 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: SOAP.pm,v 1.1 2005-01-06 03:56:43 jhoblitt Exp $
     3# $Id: SOAP.pm,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Server::SOAP;
     5package Nebulous::Server::SOAP;
    66
    77use strict;
    … …  
    1010our $VERSION = '0.01';
    1111
    12 use PS::IPP::IData::Server;
     12use Nebulous::Server;
    1313use SOAP::Lite;
    1414import SOAP::Data 'name';
    … …  
    2222    return undef if $method eq 'DESTROY';
    2323
    24     return name( result => PS::IPP::IData::Server->$method( @_ ) );
     24    return name( result => Nebulous::Server->$method( @_ ) );
    2525}
    2626

  • trunk/Nebulous-Server/lib/Nebulous/Server/SQL.pm

    r3016 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: SQL.pm,v 1.4 2005-01-15 04:02:12 jhoblitt Exp $
     3# $Id: SQL.pm,v 1.5 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Server::SQL;
     5package Nebulous::Server::SQL;
    66
    77use strict;

  • trunk/Nebulous-Server/nebulous.wsdl

    r2785 r4440  
    11<?xml version="1.0"?>
    22
    3 <definitions name="idata" targetNamespace="http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server">
     3<definitions name="nebulous" targetNamespace="http://pan-starrs.ifa.hawaii.edu/Nebulous/Server">
    44
    55    <types>
    6         <schema targetNamespace="http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server"
     6        <schema targetNamespace="http://pan-starrs.ifa.hawaii.edu/Nebulous/Server"
    77            xmlns="http://www.w3.org/1999/XMLSchema">
    88
    … …  
    5353    </portType>
    5454
    55     <binding name="idataSoapBinding"
    56         type="es:GetidatarPortType">
     55    <binding name="nebulousSoapBinding"
     56        type="es:GetnebulousrPortType">
    5757
    5858        <soap:binding style="document"
    5959            transport="http://schemas.xmlsoap.org/soap/http"/>
    6060
    61         <operation name="Getidata">
     61        <operation name="Getnebulous">
    6262            <soap:operation
    6363                soapAction="http://www.snowboard-info.com/EndorsementSearch"/>

  • trunk/Nebulous-Server/scripts/bench_test.pl

    r3014 r4440  
    77
    88use Benchmark qw( timethese );
    9 use PS::IPP::IData::Client;
     9use Nebulous::Client;
    1010
    11 my $idata = PS::IPP::IData::Client->new(
    12     proxy   => 'http://localhost:80/idata'
     11my $neb = Nebulous::Client->new(
     12    proxy   => 'http://localhost:80/nebulous'
    1313);
    1414
    … …  
    1818    {
    1919        'create/delete' => sub {
    20             my $fh = $idata->create( $key );
     20            my $fh = $neb->create( $key );
    2121            close $fh;
    22             $idata->delete( $key );
     22            $neb->delete( $key );
    2323        },
    2424    }

  • trunk/Nebulous-Server/scripts/imageserver.pl

    r2785 r4440  
    88
    99use SOAP::Transport::HTTP;
    10 use PS::IPP::IData::Server;
     10use Nebulous::Server;
    1111   
    1212SOAP::Transport::HTTP::CGI
    13     -> dispatch_to( 'PS::IPP::IData::Server' )
     13    -> dispatch_to( 'Nebulous::Server' )
    1414    -> handle;

  • trunk/Nebulous-Server/scripts/ptest.pl

    r2785 r4440  
    66use lib "./lib";
    77
    8 use PS::IPP::IData::Client;
     8use Nebulous::Client;
    99
    10 my $idata = PS::IPP::IData::Client->new(
    11     uri     => 'http://localhost:80/PS/IPP/IData/Server',
    12     proxy   => 'http://localhost:80/idata'
     10my $neb = Nebulous::Client->new(
     11    proxy   => 'http://localhost:80/nebulous'
    1312);
    1413
    … …  
    2221    unless ( $pid )  {
    2322        my $fname = "${key}_$id";
    24         my $fh = $idata->create( $fname );
     23        my $fh = $neb->create( $fname );
    2524        die "can't create file $fname" unless $fh;
    2625
    … …  
    2827
    2928        close $fh;
    30         $idata->unlock( $fname, 'write' );
     29        $neb->unlock( $fname, 'write' );
    3130
    32         $fh = $idata->open( $fname, 'read' ) or die "can't open file";
     31        $fh = $neb->open( $fname, 'read' ) or die "can't open file";
    3332        close $fh;
    34         $idata->unlock( $fname, 'read' );
     33        $neb->unlock( $fname, 'read' );
    3534
    36         $idata->replicate( $fname );
    37         $idata->cull( $fname );
    38         $idata->find( $fname );
    39         $idata->copy( $fname, $fname . "_copy" );
    40         $idata->move( $fname, $fname . "_move" );
    41         $idata->delete( $fname . "_copy" );
    42         $idata->delete( $fname . "_move" );
     35        $neb->replicate( $fname );
     36        $neb->cull( $fname );
     37        $neb->find( $fname );
     38        $neb->copy( $fname, $fname . "_copy" );
     39        $neb->move( $fname, $fname . "_move" );
     40        $neb->delete( $fname . "_copy" );
     41        $neb->delete( $fname . "_move" );
    4342
    4443        exit 0;

  • trunk/Nebulous-Server/scripts/stest.pl

    r2785 r4440  
    66use lib "./lib";
    77
    8 use PS::IPP::IData::Client; # trace => 'debug';
     8use Nebulous::Client; # trace => 'debug';
    99
    10 my $idata = PS::IPP::IData::Client->new(
    11     proxy   => 'http://localhost:80/idata'
     10my $neb = Nebulous::Client->new(
     11    proxy   => 'http://localhost:80/nebulous'
    1212);
    1313
    1414my $fname = shift;
    1515
    16 #my $fh = $idata->create( $fname );
    17 #$idata->unlock( $fname, 'write' );
     16#my $fh = $neb->create( $fname );
     17#$neb->unlock( $fname, 'write' );
    1818
    19 $idata->create( $fname, 1 );
    20 $idata->unlock( $fname, 'write' );
    21 $idata->delete( $fname );
     19$neb->create( $fname, 1 );
     20$neb->unlock( $fname, 'write' );
     21$neb->delete( $fname );
    2222
    2323__END__
    … …  
    2828    print $fh "fooby\n";
    2929    close $fh;
    30     #$idata->unlock( $fname, 'write' );
     30    #$neb->unlock( $fname, 'write' );
    3131    my $filesize =  (stat( $key ))[7];
    3232    print "created file $key, ${filesize}bytes\n";

  • trunk/Nebulous-Server/t/01_load.t

    r4436 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 01_load.t,v 1.6 2005-06-30 01:37:16 jhoblitt Exp $
     5# $Id: 01_load.t,v 1.7 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use Test::More tests => 8;
    1313
    14 BEGIN { use_ok( 'PS::IPP::IData::Client' ); }
    15 BEGIN { use_ok( 'PS::IPP::IData::Client::Log' ); }
    16 BEGIN { use_ok( 'PS::IPP::IData::Client::HTTP' ); }
    17 BEGIN { use_ok( 'PS::IPP::IData::Util' ); }
    18 BEGIN { use_ok( 'PS::IPP::IData::Server' ); }
    19 BEGIN { use_ok( 'PS::IPP::IData::Server::SQL' ); }
    20 BEGIN { use_ok( 'PS::IPP::IData::Server::Log' ); }
    21 BEGIN { use_ok( 'PS::IPP::IData::Server::SOAP' ); }
     14BEGIN { use_ok( 'Nebulous::Client' ); }
     15BEGIN { use_ok( 'Nebulous::Client::Log' ); }
     16BEGIN { use_ok( 'Nebulous::Client::HTTP' ); }
     17BEGIN { use_ok( 'Nebulous::Util' ); }
     18BEGIN { use_ok( 'Nebulous::Server' ); }
     19BEGIN { use_ok( 'Nebulous::Server::SQL' ); }
     20BEGIN { use_ok( 'Nebulous::Server::Log' ); }
     21BEGIN { use_ok( 'Nebulous::Server::SOAP' ); }

  • trunk/Nebulous-Server/t/02_server_setup.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 02_server_setup.t,v 1.2 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 02_server_setup.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use Test::IData;
     14use Nebulous::Server;
     15use Test::Nebulous;
    1616
    17 Test::IData->setup;
     17Test::Nebulous->setup;
    1818
    1919ok(
    20     PS::IPP::IData::Server->setup(
     20    Nebulous::Server->setup(
    2121        "DBI:mysql:database=test:host=localhost",
    2222        "test",
    … …  
    2626);
    2727
    28 Test::IData->setup;
     28Test::Nebulous->setup;
    2929
    3030eval {
    31     PS::IPP::IData::Server->setup(
     31    Nebulous::Server->setup(
    3232        "DBI:mysql:database=foobar:host=localhost",
    3333        "baz",
    … …  
    3737like( $@, qr/DBI connect.*? failed/, "bad dsn/user/pass" );
    3838
    39 Test::IData->cleanup;
     39Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/03_server_create_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 03_server_create_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 03_server_create_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     my $uri = $idata->create_object( "foo" );
     30    my $uri = $neb->create_object( "foo" );
    3131
    3232    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    3939    # key, class
    40     my $uri = $idata->create_object( "foo", 0 );
     40    my $uri = $neb->create_object( "foo", 0 );
    4141
    4242    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4444}
    4545
    46 Test::IData->setup;
     46Test::Nebulous->setup;
    4747
    4848{
    4949    # key, class, volume
    50     my $uri = $idata->create_object( "foo", 0, "node01" );
     50    my $uri = $neb->create_object( "foo", 0, "node01" );
    5151
    5252    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    5959    # key, class, volume, comment
    60     my $uri = $idata->create_object( "foo", 0, "node01", "this is foo" );
     60    my $uri = $neb->create_object( "foo", 0, "node01", "this is foo" );
    6161
    6262    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    6464}
    6565
    66 Test::IData->setup;
     66Test::Nebulous->setup;
    6767
    6868eval {
    69     $idata->create_object( "foo" );
    70     $idata->create_object( "foo" );
     69    $neb->create_object( "foo" );
     70    $neb->create_object( "foo" );
    7171};
    7272like( $@, qr/Duplicate entry/, "object already exists" );
    7373
    74 Test::IData->setup;
     74Test::Nebulous->setup;
    7575
    7676eval {
    77     $idata->create_object();
     77    $neb->create_object();
    7878};
    7979like( $@, qr/2 - 4 were expected/, "no params" );
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     $idata->create_object( 1, 2, 3, 4, 5 );
     84    $neb->create_object( 1, 2, 3, 4, 5 );
    8585};
    8686like( $@, qr/2 - 4 were expected/, "too many params" );
    8787
    88 Test::IData->cleanup;
     88Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/04_server_replicate_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 04_server_replicate_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 04_server_replicate_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     $idata->create_object( "foo" );
    31     my $uri = $idata->replicate_object( "foo" );
     30    $neb->create_object( "foo" );
     31    my $uri = $neb->replicate_object( "foo" );
    3232
    3333    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key, $volume
    41     $idata->create_object( "foo" );
    42     my $uri = $idata->replicate_object( "foo", "node01" );
     41    $neb->create_object( "foo" );
     42    my $uri = $neb->replicate_object( "foo", "node01" );
    4343
    4444    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    5151    # key, $volume
    52     $idata->create_object( "foo" );
    53     my $uri1 = $idata->replicate_object( "foo", "node01" );
    54     my $uri2 = $idata->replicate_object( "foo", "node02" );
     52    $neb->create_object( "foo" );
     53    my $uri1 = $neb->replicate_object( "foo", "node01" );
     54    my $uri2 = $neb->replicate_object( "foo", "node02" );
    5555
    5656    ok( -e _get_file_path( $uri1 ), "file exists" );
    … …  
    6060}
    6161
    62 Test::IData->setup;
     62Test::Nebulous->setup;
    6363
    6464eval {
    65     $idata->replicate_object( "foo" );
     65    $neb->replicate_object( "foo" );
    6666};
    6767like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6868
    69 Test::IData->setup;
     69Test::Nebulous->setup;
    7070
    7171eval {
    72     $idata->replicate_object();
     72    $neb->replicate_object();
    7373};
    7474like( $@, qr/1 - 2 were expected/, "no params" );
    7575
    76 Test::IData->setup;
     76Test::Nebulous->setup;
    7777
    7878eval {
    79     $idata->replicate_object( 1, 2, 3 );
     79    $neb->replicate_object( 1, 2, 3 );
    8080};
    8181like( $@, qr/1 - 2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/05_server_lock_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 05_server_lock_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 05_server_lock_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     $idata->create_object( "foo" );
     29    $neb->create_object( "foo" );
    3030
    31     ok( $idata->lock_object( "foo", "read" ), "read lock" );
     31    ok( $neb->lock_object( "foo", "read" ), "read lock" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     $idata->create_object( "foo" );
     37    $neb->create_object( "foo" );
    3838
    39     ok( $idata->lock_object( "foo", "read" ), "read lock" );
    40     ok( $idata->lock_object( "foo", "read" ), "read lock" );
     39    ok( $neb->lock_object( "foo", "read" ), "read lock" );
     40    ok( $neb->lock_object( "foo", "read" ), "read lock" );
    4141}
    4242
    43 Test::IData->setup;
     43Test::Nebulous->setup;
    4444
    4545{
    46     $idata->create_object( "foo" );
     46    $neb->create_object( "foo" );
    4747
    48     ok( $idata->lock_object( "foo", "write" ), "write lock" );
     48    ok( $neb->lock_object( "foo", "write" ), "write lock" );
    4949}
    5050
    51 Test::IData->setup;
     51Test::Nebulous->setup;
    5252
    5353eval {
    54     $idata->lock_object( "foo", "read" );
     54    $neb->lock_object( "foo", "read" );
    5555};
    5656like( $@, qr/storage object does not exist/, "storage object does not exist" );
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060eval {
    61     $idata->lock_object( "foo", "write" );
     61    $neb->lock_object( "foo", "write" );
    6262};
    6363like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6464
    65 Test::IData->setup;
     65Test::Nebulous->setup;
    6666
    6767eval {
    68     $idata->create_object( "foo" );
     68    $neb->create_object( "foo" );
    6969
    70     $idata->lock_object( "foo", "write" );
    71     $idata->lock_object( "foo", "write" );
     70    $neb->lock_object( "foo", "write" );
     71    $neb->lock_object( "foo", "write" );
    7272};
    7373like( $@, qr/can not write lock twice/, "can not write lock twice" );
    7474
    75 Test::IData->setup;
     75Test::Nebulous->setup;
    7676
    7777eval {
    78     $idata->create_object( "foo" );
     78    $neb->create_object( "foo" );
    7979
    80     $idata->lock_object( "foo", "read" );
    81     $idata->lock_object( "foo", "write" );
     80    $neb->lock_object( "foo", "read" );
     81    $neb->lock_object( "foo", "write" );
    8282};
    8383like( $@, qr/can not write lock after read lock/, "can not write lock after read lock" );
    8484
    85 Test::IData->setup;
     85Test::Nebulous->setup;
    8686
    8787eval {
    88     $idata->create_object( "foo" );
     88    $neb->create_object( "foo" );
    8989
    90     $idata->lock_object( "foo", "write" );
    91     $idata->lock_object( "foo", "read" );
     90    $neb->lock_object( "foo", "write" );
     91    $neb->lock_object( "foo", "read" );
    9292};
    9393like( $@, qr/can not read lock after write lock/, "can not read lock after write lock" );
    9494
    95 Test::IData->setup;
     95Test::Nebulous->setup;
    9696
    9797eval {
    98     $idata->lock_object();
     98    $neb->lock_object();
    9999};
    100100like( $@, qr/2 were expected/, "no params" );
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104eval {
    105     $idata->lock_object( "foo" );
     105    $neb->lock_object( "foo" );
    106106};
    107107like( $@, qr/2 were expected/, "not enough params" );
    108108
    109 Test::IData->setup;
     109Test::Nebulous->setup;
    110110
    111111eval {
    112     $idata->lock_object( "foo", "both" );
     112    $neb->lock_object( "foo", "both" );
    113113};
    114114like( $@, qr/is read or write/, "not read or write" );
    115115
    116 Test::IData->setup;
     116Test::Nebulous->setup;
    117117
    118118eval {
    119     $idata->lock_object( "foo", 'read', 3 );
     119    $neb->lock_object( "foo", 'read', 3 );
    120120};
    121121like( $@, qr/2 were expected/, "too many params" );
    122122
    123 Test::IData->cleanup;
     123Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/06_server_unlock_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 06_server_unlock_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 06_server_unlock_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     $idata->create_object( "foo" );
     29    $neb->create_object( "foo" );
    3030
    31     $idata->lock_object( "foo", "read" );
     31    $neb->lock_object( "foo", "read" );
    3232
    33     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
     33    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     $idata->create_object( "foo" );
     39    $neb->create_object( "foo" );
    4040
    41     $idata->lock_object( "foo", "read" );
    42     $idata->lock_object( "foo", "read" );
     41    $neb->lock_object( "foo", "read" );
     42    $neb->lock_object( "foo", "read" );
    4343
    44     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
    45     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
     44    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
     45    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     $idata->create_object( "foo" );
     51    $neb->create_object( "foo" );
    5252
    53     $idata->lock_object( "foo", "write" );
     53    $neb->lock_object( "foo", "write" );
    5454
    55     ok( $idata->unlock_object( "foo", "write" ), "write unlock" );
     55    ok( $neb->unlock_object( "foo", "write" ), "write unlock" );
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060eval {
    61     $idata->unlock_object( "foo", "read" );
     61    $neb->unlock_object( "foo", "read" );
    6262};
    6363like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6464
    65 Test::IData->setup;
     65Test::Nebulous->setup;
    6666
    6767eval {
    68     $idata->unlock_object( "foo", "write" );
     68    $neb->unlock_object( "foo", "write" );
    6969};
    7070like( $@, qr/storage object does not exist/, "storage object does not exist" );
    7171
    72 Test::IData->setup;
     72Test::Nebulous->setup;
    7373
    7474eval {
    75     $idata->create_object( "foo" );
     75    $neb->create_object( "foo" );
    7676
    77     $idata->unlock_object( "foo", "read" );
     77    $neb->unlock_object( "foo", "read" );
    7878};
    7979like( $@, qr/can not remove non-existant read lock/, "no lock set" );
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     $idata->create_object( "foo" );
     84    $neb->create_object( "foo" );
    8585
    86     $idata->unlock_object( "foo", "write" );
     86    $neb->unlock_object( "foo", "write" );
    8787};
    8888like( $@, qr/can not remove non-existant write lock/, "no lock set" );
    8989
    90 Test::IData->setup;
     90Test::Nebulous->setup;
    9191
    9292eval {
    93     $idata->create_object( "foo" );
    94     $idata->lock_object( "foo", "write" );
     93    $neb->create_object( "foo" );
     94    $neb->lock_object( "foo", "write" );
    9595
    96     $idata->unlock_object( "foo", "read" );
     96    $neb->unlock_object( "foo", "read" );
    9797};
    9898like( $@, qr/can not have a read lock under a write lock/, "read unlock under write lock" );
    9999
    100 Test::IData->setup;
     100Test::Nebulous->setup;
    101101
    102102eval {
    103     $idata->create_object( "foo" );
    104     $idata->lock_object( "foo", "read" );
     103    $neb->create_object( "foo" );
     104    $neb->lock_object( "foo", "read" );
    105105
    106     $idata->unlock_object( "foo", "write" );
     106    $neb->unlock_object( "foo", "write" );
    107107};
    108108like( $@, qr/can not have a write lock under a read lock/, "write unlock under read lock" );
    109109
    110 Test::IData->setup;
     110Test::Nebulous->setup;
    111111
    112112eval {
    113     $idata->unlock_object();
     113    $neb->unlock_object();
    114114};
    115115like( $@, qr/2 were expected/, "no params" );
    116116
    117 Test::IData->setup;
     117Test::Nebulous->setup;
    118118
    119119eval {
    120     $idata->unlock_object( "foo" );
     120    $neb->unlock_object( "foo" );
    121121};
    122122like( $@, qr/2 were expected/, "not enough params" );
    123123
    124 Test::IData->setup;
     124Test::Nebulous->setup;
    125125
    126126eval {
    127     $idata->unlock_object( "foo", "both" );
     127    $neb->unlock_object( "foo", "both" );
    128128};
    129129like( $@, qr/is read or write/, "not read or write" );
    130130
    131 Test::IData->setup;
     131Test::Nebulous->setup;
    132132
    133133eval {
    134     $idata->unlock_object( "foo", 'read', 3 );
     134    $neb->unlock_object( "foo", 'read', 3 );
    135135};
    136136like( $@, qr/2 were expected/, "too many params" );
    137137
    138 Test::IData->cleanup;
     138Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/07_server_find_instances.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 07_server_find_instances.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 07_server_find_instances.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     my $uri = $idata->create_object( "foo" );
     30    my $uri = $neb->create_object( "foo" );
    3131
    32     my $locations = $idata->find_instances( "foo" );
     32    my $locations = $neb->find_instances( "foo" );
    3333
    3434    is( $uri, $locations->[0], "URIs match" );
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key
    41     my $uri1 = $idata->create_object( "foo" );
    42     my $uri2 = $idata->replicate_object( "foo" );
     41    my $uri1 = $neb->create_object( "foo" );
     42    my $uri2 = $neb->replicate_object( "foo" );
    4343
    44     my $locations = $idata->find_instances( "foo" );
     44    my $locations = $neb->find_instances( "foo" );
    4545
    4646    ok( eq_set( [$uri1, $uri2], $locations ), "URIs match" );
    4747}
    4848
    49 Test::IData->setup;
     49Test::Nebulous->setup;
    5050
    5151{
    5252    # key, volume
    53     my $uri = $idata->create_object( "foo" );
     53    my $uri = $neb->create_object( "foo" );
    5454
    55     my $locations = $idata->find_instances( "foo", "node01" );
     55    my $locations = $neb->find_instances( "foo", "node01" );
    5656
    5757    is( $uri, $locations->[0], "URIs match" );
    5858}
    5959
    60 Test::IData->setup;
     60Test::Nebulous->setup;
    6161
    6262{
    6363    # key
    64     my $uri1 = $idata->create_object( "foo" );
    65     my $uri2 = $idata->replicate_object( "foo" );
     64    my $uri1 = $neb->create_object( "foo" );
     65    my $uri2 = $neb->replicate_object( "foo" );
    6666
    67     my $locations = $idata->find_instances( "foo", "node01" );
     67    my $locations = $neb->find_instances( "foo", "node01" );
    6868
    6969    ok( eq_set( [$uri1, $uri2], $locations ), "URIs match" );
    … …  
    7171
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     $idata->find_instances( "foo" );
     76    $neb->find_instances( "foo" );
    7777};
    7878like( $@, qr/no instances found/, "storage object does not exist" );
    7979
    80 Test::IData->setup;
     80Test::Nebulous->setup;
    8181
    8282eval {
    83     $idata->find_instances();
     83    $neb->find_instances();
    8484};
    8585like( $@, qr/1 - 2 were expected/, "no params" );
    8686
    87 Test::IData->setup;
     87Test::Nebulous->setup;
    8888
    8989eval {
    90     $idata->find_instances( "foo", 'read', 3 );
     90    $neb->find_instances( "foo", 'read', 3 );
    9191};
    9292like( $@, qr/1 - 2 were expected/, "too many params" );
    9393
    94 Test::IData->cleanup;
     94Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/08_server_delete_instance.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 08_server_delete_instance.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 08_server_delete_instance.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     my $uri = $idata->create_object( "foo" );
     29    my $uri = $neb->create_object( "foo" );
    3030
    31     ok( $idata->delete_instance( $uri ), "delete instance" );
     31    ok( $neb->delete_instance( $uri ), "delete instance" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     my $uri1 = $idata->create_object( "foo" );
    38     my $uri2 = $idata->replicate_object( "foo" );
     37    my $uri1 = $neb->create_object( "foo" );
     38    my $uri2 = $neb->replicate_object( "foo" );
    3939
    40     ok( $idata->delete_instance( $uri1 ), "delete instance" );
     40    ok( $neb->delete_instance( $uri1 ), "delete instance" );
    4141
    42     my $locations = $idata->find_instances( "foo" );
     42    my $locations = $neb->find_instances( "foo" );
    4343
    4444    is( $locations->[0], $uri2, "instance remains" );
    4545
    46     ok( $idata->delete_instance( $uri2 ), "delete instance" );
     46    ok( $neb->delete_instance( $uri2 ), "delete instance" );
    4747
    4848    eval {
    49         $idata->find_instances( "foo" );
     49        $neb->find_instances( "foo" );
    5050    };
    5151    like( $@, qr/no instances found/, "storage object was deleted" );
    5252}
    5353
    54 Test::IData->setup;
     54Test::Nebulous->setup;
    5555
    5656eval {
    57     $idata->delete_instance( "file:/foo" );
     57    $neb->delete_instance( "file:/foo" );
    5858};
    5959like( $@, qr/no instance is associated with uri/, "uri does not exist" );
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363eval {
    64     $idata->delete_instance();
     64    $neb->delete_instance();
    6565};
    6666like( $@, qr/1 was expected/, "no params" );
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     $idata->delete_instance( "foo", 2 );
     71    $neb->delete_instance( "foo", 2 );
    7272};
    7373like( $@, qr/1 was expected/, "too many params" );
    7474
    75 Test::IData->cleanup;
     75Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/09_server_stat_object.t

    r3016 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 09_server_stat_object.t,v 1.4 2005-01-15 04:02:12 jhoblitt Exp $
     5# $Id: 09_server_stat_object.t,v 1.5 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     my $uri = $idata->create_object( "foo" );
     29    my $uri = $neb->create_object( "foo" );
    3030
    31     my $info = $idata->stat_object( "foo" );
     31    my $info = $neb->stat_object( "foo" );
    3232
    3333    is( scalar @$info, 8, "number of columns" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     my $uri = $idata->create_object( "foo", 9, "node01", "foobar" );
     39    my $uri = $neb->create_object( "foo", 9, "node01", "foobar" );
    4040
    41     my $info = $idata->stat_object( "foo" );
     41    my $info = $neb->stat_object( "foo" );
    4242
    4343    is( scalar @$info, 8,                       "number of columns" );
    … …  
    5252}
    5353
    54 Test::IData->setup;
     54Test::Nebulous->setup;
    5555
    5656eval {
    57     $idata->stat_object( "foo" );
     57    $neb->stat_object( "foo" );
    5858};
    5959like( $@, qr/no storage object found/, "object does not exist" );
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363eval {
    64     $idata->stat_object();
     64    $neb->stat_object();
    6565};
    6666like( $@, qr/1 was expected/, "no params" );
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     $idata->stat_object( "foo", 2 );
     71    $neb->stat_object( "foo", 2 );
    7272};
    7373like( $@, qr/1 was expected/, "too many params" );
    7474
    75 Test::IData->cleanup;
     75Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/10_client_new.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 10_client_new.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 10_client_new.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    2828
    29     isa_ok( $idata, "PS::IPP::IData::Client" );
     29    isa_ok( $neb, "Nebulous::Client" );
    3030}
    3131
    32 Test::IData->setup;
     32Test::Nebulous->setup;
    3333
    3434{
    35     my $idata = PS::IPP::IData::Client->new(
    36         proxy => "http://$hostport/idata",
    37         uri   => "http://example.com/PS/IPP/IData/Client",
     35    my $neb = Nebulous::Client->new(
     36        proxy => "http://$hostport/nebulous",
     37        uri   => "http://example.com/PS/IPP/Nebulous/Client",
    3838    );
    3939
    40     isa_ok( $idata, "PS::IPP::IData::Client" );
     40    isa_ok( $neb, "Nebulous::Client" );
    4141}
    4242
    43 Test::IData->setup;
     43Test::Nebulous->setup;
    4444
    4545eval {
    46     PS::IPP::IData::Client->new;
     46    Nebulous::Client->new;
    4747};
    4848like( $@, qr/Mandatory parameter/, "no proxy" );
    4949
    50 Test::IData->setup;
     50Test::Nebulous->setup;
    5151
    5252eval {
    53     PS::IPP::IData::Client->new(
     53    Nebulous::Client->new(
    5454        proxy => "foo",
    5555        dog => "do"
    … …  
    5858like( $@, qr/not listed in the validation options/, "bad param" );
    5959
    60 Test::IData->cleanup;
     60Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/11_client_create.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 11_client_create.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 11_client_create.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    2929
    30     my $fh = $idata->create( "foo" );
     30    my $fh = $neb->create( "foo" );
    3131
    3232    is( ref $fh, 'GLOB', "good filehandle" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key, class
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    4242
    43     my $fh = $idata->create( "foo", 0 );
     43    my $fh = $neb->create( "foo", 0 );
    4444
    4545    is( ref $fh, 'GLOB', "good filehandle" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    5151    # key, class, volume
    52     my $idata = PS::IPP::IData::Client->new(
    53         proxy => "http://$hostport/idata",
     52    my $neb = Nebulous::Client->new(
     53        proxy => "http://$hostport/nebulous",
    5454    );
    5555
    56     my $fh = $idata->create( "foo", 0, "node01" );
     56    my $fh = $neb->create( "foo", 0, "node01" );
    5757
    5858    is( ref $fh, 'GLOB', "good filehandle" );
    5959}
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363{
    6464    # key, class, volume, comment
    65     my $idata = PS::IPP::IData::Client->new(
    66         proxy => "http://$hostport/idata",
     65    my $neb = Nebulous::Client->new(
     66        proxy => "http://$hostport/nebulous",
    6767    );
    6868
    69     my $fh = $idata->create( "foo", 0, "node01", "this is foo" );
     69    my $fh = $neb->create( "foo", 0, "node01", "this is foo" );
    7070
    7171    is( ref $fh, 'GLOB', "good filehandle" );
    7272}
    7373
    74 Test::IData->setup;
     74Test::Nebulous->setup;
    7575
    7676{
    77     my $idata = PS::IPP::IData::Client->new(
    78         proxy => "http://$hostport/idata",
     77    my $neb = Nebulous::Client->new(
     78        proxy => "http://$hostport/nebulous",
    7979    );
    8080
    81     $idata->create( "foo" );
    82     is( $idata->create( "foo" ), undef, "object already exists" );
     81    $neb->create( "foo" );
     82    is( $neb->create( "foo" ), undef, "object already exists" );
    8383}
    8484
    85 Test::IData->setup;
     85Test::Nebulous->setup;
    8686
    8787eval {
    88     my $idata = PS::IPP::IData::Client->new(
    89         proxy => "http://$hostport/idata",
     88    my $neb = Nebulous::Client->new(
     89        proxy => "http://$hostport/nebulous",
    9090    );
    9191
    92     $idata->create();
     92    $neb->create();
    9393};
    9494like( $@, qr/2 - 4 were expected/, "no params" );
    9595
    96 Test::IData->setup;
     96Test::Nebulous->setup;
    9797
    9898eval {
    99     my $idata = PS::IPP::IData::Client->new(
    100         proxy => "http://$hostport/idata",
     99    my $neb = Nebulous::Client->new(
     100        proxy => "http://$hostport/nebulous",
    101101    );
    102102
    103     $idata->create( 1, 2, 3, 4, 5 );
     103    $neb->create( 1, 2, 3, 4, 5 );
    104104};
    105105like( $@, qr/2 - 4 were expected/, "too many params" );
    106106
    107 Test::IData->cleanup;
     107Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/12_client_replicate.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 12_client_replicate.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 12_client_replicate.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
     29    $neb->create( "foo" );
    3030
    31     my $uri = $idata->replicate( "foo" );
     31    my $uri = $neb->replicate( "foo" );
    3232
    3333    ok( $uri, "good replication" );
    … …  
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key, $volume
    41     my $idata = PS::IPP::IData::Client->new(
    42         proxy => "http://$hostport/idata",
     41    my $neb = Nebulous::Client->new(
     42        proxy => "http://$hostport/nebulous",
    4343    );
    44     $idata->create( "foo" );
     44    $neb->create( "foo" );
    4545
    46     my $uri = $idata->replicate( "foo", "node01" );
     46    my $uri = $neb->replicate( "foo", "node01" );
    4747
    4848    ok( $uri, "good replication" );
    … …  
    5050}
    5151
    52 Test::IData->setup;
     52Test::Nebulous->setup;
    5353
    5454{
    5555    # key, $volume
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->create( "foo" );
     59    $neb->create( "foo" );
    6060
    61     my $uri1 = $idata->replicate( "foo", "node01" );
    62     my $uri2 = $idata->replicate( "foo", "node02" );
     61    my $uri1 = $neb->replicate( "foo", "node01" );
     62    my $uri2 = $neb->replicate( "foo", "node02" );
    6363
    6464    ok( $uri1, "good replication" );
    … …  
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $idata = PS::IPP::IData::Client->new(
    74         proxy => "http://$hostport/idata",
     73    my $neb = Nebulous::Client->new(
     74        proxy => "http://$hostport/nebulous",
    7575    );
    76     my $uri = $idata->replicate( "foo" );
     76    my $uri = $neb->replicate( "foo" );
    7777
    7878    is( $uri, undef, "storage object does not exist" );
    7979}
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     my $idata = PS::IPP::IData::Client->new(
    85         proxy => "http://$hostport/idata",
     84    my $neb = Nebulous::Client->new(
     85        proxy => "http://$hostport/nebulous",
    8686    );
    87     $idata->replicate();
     87    $neb->replicate();
    8888};
    8989like( $@, qr/1 - 2 were expected/, "no params" );
    9090
    91 Test::IData->setup;
     91Test::Nebulous->setup;
    9292
    9393eval {
    94     my $idata = PS::IPP::IData::Client->new(
    95         proxy => "http://$hostport/idata",
     94    my $neb = Nebulous::Client->new(
     95        proxy => "http://$hostport/nebulous",
    9696    );
    97     $idata->replicate( 1, 2, 3 );
     97    $neb->replicate( 1, 2, 3 );
    9898};
    9999like( $@, qr/1 - 2 were expected/, "too many params" );
    100100
    101 Test::IData->cleanup;
     101Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/13_client_cull.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 13_client_cull.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 13_client_cull.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
    30     $idata->replicate( "foo" );
     29    $neb->create( "foo" );
     30    $neb->replicate( "foo" );
    3131
    32     my $uri = $idata->cull( "foo" );
     32    my $uri = $neb->cull( "foo" );
    3333
    3434    ok( $uri, "good cull" );
    … …  
    3636}
    3737
    38 Test::IData->setup;
     38Test::Nebulous->setup;
    3939
    4040SKIP: {
    … …  
    4242
    4343    # key, $volume
    44     my $idata = PS::IPP::IData::Client->new(
    45         proxy => "http://$hostport/idata",
     44    my $neb = Nebulous::Client->new(
     45        proxy => "http://$hostport/nebulous",
    4646    );
    47     $idata->create( "foo" );
    48     $idata->replicate( "foo", "node01" );
     47    $neb->create( "foo" );
     48    $neb->replicate( "foo", "node01" );
    4949
    50     my $uri = $idata->cull( "foo", "node01" );
     50    my $uri = $neb->cull( "foo", "node01" );
    5151
    5252    ok( $uri, "good cull" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    5959    # key
    60     my $idata = PS::IPP::IData::Client->new(
    61         proxy => "http://$hostport/idata",
     60    my $neb = Nebulous::Client->new(
     61        proxy => "http://$hostport/nebulous",
    6262    );
    63     $idata->create( "foo" );
     63    $neb->create( "foo" );
    6464
    65     $idata->replicate( "foo", "node01" );
    66     $idata->replicate( "foo", "node02" );
     65    $neb->replicate( "foo", "node01" );
     66    $neb->replicate( "foo", "node02" );
    6767
    68     my $uri1 = $idata->cull( "foo" );
    69     my $uri2 = $idata->cull( "foo" );
     68    my $uri1 = $neb->cull( "foo" );
     69    my $uri2 = $neb->cull( "foo" );
    7070
    7171    ok( $uri1, "good cull" );
    … …  
    7575}
    7676
    77 Test::IData->setup;
     77Test::Nebulous->setup;
    7878
    7979SKIP: {
    … …  
    8181
    8282    # key, $volume
    83     my $idata = PS::IPP::IData::Client->new(
    84         proxy => "http://$hostport/idata",
     83    my $neb = Nebulous::Client->new(
     84        proxy => "http://$hostport/nebulous",
    8585    );
    86     $idata->create( "foo" );
     86    $neb->create( "foo" );
    8787
    88     $idata->replicate( "foo", "node01" );
    89     $idata->replicate( "foo", "node02" );
     88    $neb->replicate( "foo", "node01" );
     89    $neb->replicate( "foo", "node02" );
    9090
    91     my $uri1 = $idata->cull( "foo", "node01" );
    92     my $uri2 = $idata->cull( "foo", "node02" );
     91    my $uri1 = $neb->cull( "foo", "node01" );
     92    my $uri2 = $neb->cull( "foo", "node02" );
    9393
    9494    ok( $uri1, "good cull" );
    … …  
    9898}
    9999
    100 Test::IData->setup;
     100Test::Nebulous->setup;
    101101
    102102{
    103     my $idata = PS::IPP::IData::Client->new(
    104         proxy => "http://$hostport/idata",
     103    my $neb = Nebulous::Client->new(
     104        proxy => "http://$hostport/nebulous",
    105105    );
    106     my $uri = $idata->cull( "foo" );
     106    my $uri = $neb->cull( "foo" );
    107107
    108108    is( $uri, undef, "storage object does not exist" );
    109109}
    110110
    111 Test::IData->setup;
     111Test::Nebulous->setup;
    112112
    113113eval {
    114     my $idata = PS::IPP::IData::Client->new(
    115         proxy => "http://$hostport/idata",
     114    my $neb = Nebulous::Client->new(
     115        proxy => "http://$hostport/nebulous",
    116116    );
    117     $idata->cull();
     117    $neb->cull();
    118118};
    119119like( $@, qr/1 was expected/, "no params" );
    120120
    121 Test::IData->setup;
     121Test::Nebulous->setup;
    122122
    123123eval {
    124     my $idata = PS::IPP::IData::Client->new(
    125         proxy => "http://$hostport/idata",
     124    my $neb = Nebulous::Client->new(
     125        proxy => "http://$hostport/nebulous",
    126126    );
    127     $idata->cull( 1, 2 );
     127    $neb->cull( 1, 2 );
    128128};
    129129like( $@, qr/1 was expected/, "too many params" );
    130130
    131 Test::IData->cleanup;
     131Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/14_client_lock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 14_client_lock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 14_client_lock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key, type
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
    28     );
    29     $idata->create( "foo" );
    30 
    31     ok( $idata->lock( "foo", "read" ), "read lock" );
    32 }
    33 
    34 Test::IData->setup;
    35 
    36 {
    37     # key, type, timeout
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
    40     );
    41     $idata->create( "foo" );
    42 
    43     ok( $idata->lock( "foo", "read", 10 ), "read lock" );
    44 }
    45 
    46 Test::IData->setup;
    47 
    48 {
    49     my $idata = PS::IPP::IData::Client->new(
    50         proxy => "http://$hostport/idata",
    51     );
    52     $idata->create( "foo" );
    53 
    54     ok( $idata->lock( "foo", "read" ), "read lock" );
    55     ok( $idata->lock( "foo", "read" ), "read lock" );
    56 }
    57 
    58 Test::IData->setup;
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
     28    );
     29    $neb->create( "foo" );
     30
     31    ok( $neb->lock( "foo", "read" ), "read lock" );
     32}
     33
     34Test::Nebulous->setup;
     35
     36{
     37    # key, type, timeout
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
     40    );
     41    $neb->create( "foo" );
     42
     43    ok( $neb->lock( "foo", "read", 10 ), "read lock" );
     44}
     45
     46Test::Nebulous->setup;
     47
     48{
     49    my $neb = Nebulous::Client->new(
     50        proxy => "http://$hostport/nebulous",
     51    );
     52    $neb->create( "foo" );
     53
     54    ok( $neb->lock( "foo", "read" ), "read lock" );
     55    ok( $neb->lock( "foo", "read" ), "read lock" );
     56}
     57
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, type
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
    64     );
    65     $idata->create( "foo" );
    66 
    67     ok( $idata->lock( "foo", "write" ), "write lock" );
    68 }
    69 
    70 Test::IData->setup;
    71 
    72 {
    73     # key, type, timeout
    74     my $idata = PS::IPP::IData::Client->new(
    75         proxy => "http://$hostport/idata",
    76     );
    77     $idata->create( "foo" );
    78 
    79     ok( $idata->lock( "foo", "write", 10 ), "write lock" );
    80 }
    81 
    82 Test::IData->setup;
    83 
    84 {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
    87     );
    88 
    89     is( $idata->lock( "foo", "read" ), undef, "storage object does not exist" );
    90 }
    91 
    92 Test::IData->setup;
    93 
    94 {
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
    97     );
    98 
    99     is( $idata->lock( "foo", "write" ), undef, "storage object does not exist" );
    100 }
    101 
    102 Test::IData->setup;
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
     64    );
     65    $neb->create( "foo" );
     66
     67    ok( $neb->lock( "foo", "write" ), "write lock" );
     68}
     69
     70Test::Nebulous->setup;
     71
     72{
     73    # key, type, timeout
     74    my $neb = Nebulous::Client->new(
     75        proxy => "http://$hostport/nebulous",
     76    );
     77    $neb->create( "foo" );
     78
     79    ok( $neb->lock( "foo", "write", 10 ), "write lock" );
     80}
     81
     82Test::Nebulous->setup;
     83
     84{
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
     87    );
     88
     89    is( $neb->lock( "foo", "read" ), undef, "storage object does not exist" );
     90}
     91
     92Test::Nebulous->setup;
     93
     94{
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
     97    );
     98
     99    is( $neb->lock( "foo", "write" ), undef, "storage object does not exist" );
     100}
     101
     102Test::Nebulous->setup;
    103103
    104104diag "testing a spinlock, this will be a litle slow...";
    … …  
    109109
    110110    # key, type, timeout
    111     my $idata = PS::IPP::IData::Client->new(
    112         proxy => "http://$hostport/idata",
    113     );
    114     $idata->create( "foo" );
    115 
    116     $idata->lock( "foo", "read" );
    117     $idata->lock( "foo", "write" );
     111    my $neb = Nebulous::Client->new(
     112        proxy => "http://$hostport/nebulous",
     113    );
     114    $neb->create( "foo" );
     115
     116    $neb->lock( "foo", "read" );
     117    $neb->lock( "foo", "write" );
    118118
    119119    alarm 0;
    … …  
    121121like( $@, qr/timeout/, "default spinlock" );
    122122
    123 Test::IData->setup;
     123Test::Nebulous->setup;
    124124
    125125diag "testing a spinlock, this will be a litle slow...";
    … …  
    130130
    131131    # key, type, timeout
    132     my $idata = PS::IPP::IData::Client->new(
    133         proxy => "http://$hostport/idata",
    134     );
    135     $idata->create( "foo" );
    136 
    137     $idata->lock( "foo", "read" );
    138     unless ( $idata->lock( "foo", "write" ) ) {
     132    my $neb = Nebulous::Client->new(
     133        proxy => "http://$hostport/nebulous",
     134    );
     135    $neb->create( "foo" );
     136
     137    $neb->lock( "foo", "read" );
     138    unless ( $neb->lock( "foo", "write" ) ) {
    139139        alarm 0;
    140140        die "gaveup";
    … …  
    145145like( $@, qr/gaveup/, "default spinlock" );
    146146
    147 Test::IData->setup;
     147Test::Nebulous->setup;
    148148
    149149diag "testing a spinlock, this will be a litle slow...";
    … …  
    154154
    155155    # key, type, timeout
    156     my $idata = PS::IPP::IData::Client->new(
    157         proxy => "http://$hostport/idata",
    158     );
    159     $idata->create( "foo" );
    160 
    161     $idata->lock( "foo", "read" );
    162     $idata->lock( "foo", "write", 5 );
     156    my $neb = Nebulous::Client->new(
     157        proxy => "http://$hostport/nebulous",
     158    );
     159    $neb->create( "foo" );
     160
     161    $neb->lock( "foo", "read" );
     162    $neb->lock( "foo", "write", 5 );
    163163
    164164    alarm 0;
    … …  
    166166like( $@, qr/timeout/, "specified spinlock" );
    167167
    168 Test::IData->setup;
     168Test::Nebulous->setup;
    169169
    170170diag "testing a spinlock, this will be a litle slow...";
    … …  
    175175
    176176    # key, type, timeout
    177     my $idata = PS::IPP::IData::Client->new(
    178         proxy => "http://$hostport/idata",
    179     );
    180     $idata->create( "foo" );
    181 
    182     $idata->lock( "foo", "read" );
    183     unless ( $idata->lock( "foo", "write", 5 ) ) {
     177    my $neb = Nebulous::Client->new(
     178        proxy => "http://$hostport/nebulous",
     179    );
     180    $neb->create( "foo" );
     181
     182    $neb->lock( "foo", "read" );
     183    unless ( $neb->lock( "foo", "write", 5 ) ) {
    184184        alarm 0;
    185185        die "gaveup";
    … …  
    191191like( $@, qr/gaveup/, "specified spinlock" );
    192192
    193 Test::IData->setup;
    194 
    195 {
    196     my $idata = PS::IPP::IData::Client->new(
    197         proxy => "http://$hostport/idata",
    198     );
    199     $idata->create( "foo" );
    200 
    201     $idata->lock( "foo", "write" );
    202     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
    203 }
    204 
    205 Test::IData->setup;
    206 
    207 {
    208     my $idata = PS::IPP::IData::Client->new(
    209         proxy => "http://$hostport/idata",
    210     );
    211     $idata->create( "foo" );
    212 
    213     $idata->lock( "foo", "read" );
    214     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
    215 }
    216 
    217 Test::IData->setup;
    218 
    219 {
    220     my $idata = PS::IPP::IData::Client->new(
    221         proxy => "http://$hostport/idata",
    222     );
    223     $idata->create( "foo" );
    224 
    225     $idata->lock( "foo", "write" );
    226     is( $idata->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
    227 }
    228 
    229 Test::IData->setup;
    230 
    231 eval {
    232     my $idata = PS::IPP::IData::Client->new(
    233         proxy => "http://$hostport/idata",
    234     );
    235 
    236     $idata->lock();
     193Test::Nebulous->setup;
     194
     195{
     196    my $neb = Nebulous::Client->new(
     197        proxy => "http://$hostport/nebulous",
     198    );
     199    $neb->create( "foo" );
     200
     201    $neb->lock( "foo", "write" );
     202    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
     203}
     204
     205Test::Nebulous->setup;
     206
     207{
     208    my $neb = Nebulous::Client->new(
     209        proxy => "http://$hostport/nebulous",
     210    );
     211    $neb->create( "foo" );
     212
     213    $neb->lock( "foo", "read" );
     214    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
     215}
     216
     217Test::Nebulous->setup;
     218
     219{
     220    my $neb = Nebulous::Client->new(
     221        proxy => "http://$hostport/nebulous",
     222    );
     223    $neb->create( "foo" );
     224
     225    $neb->lock( "foo", "write" );
     226    is( $neb->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
     227}
     228
     229Test::Nebulous->setup;
     230
     231eval {
     232    my $neb = Nebulous::Client->new(
     233        proxy => "http://$hostport/nebulous",
     234    );
     235
     236    $neb->lock();
    237237};
    238238like( $@, qr/2 - 3 were expected/, "no params" );
    239239
    240 Test::IData->setup;
    241 
    242 eval {
    243     my $idata = PS::IPP::IData::Client->new(
    244         proxy => "http://$hostport/idata",
    245     );
    246 
    247     $idata->lock( "foo" );
     240Test::Nebulous->setup;
     241
     242eval {
     243    my $neb = Nebulous::Client->new(
     244        proxy => "http://$hostport/nebulous",
     245    );
     246
     247    $neb->lock( "foo" );
    248248};
    249249like( $@, qr/2 - 3 were expected/, "not enough params" );
    250250
    251 Test::IData->setup;
    252 
    253 eval {
    254     my $idata = PS::IPP::IData::Client->new(
    255         proxy => "http://$hostport/idata",
    256     );
    257 
    258     $idata->lock( "foo", "both" );
     251Test::Nebulous->setup;
     252
     253eval {
     254    my $neb = Nebulous::Client->new(
     255        proxy => "http://$hostport/nebulous",
     256    );
     257
     258    $neb->lock( "foo", "both" );
    259259};
    260260like( $@, qr/is read or write/, "not read or write" );
    261261
    262 Test::IData->setup;
    263 
    264 eval {
    265     my $idata = PS::IPP::IData::Client->new(
    266         proxy => "http://$hostport/idata",
    267     );
    268 
    269     $idata->lock( "foo", 'read', 3, "bar" );
     262Test::Nebulous->setup;
     263
     264eval {
     265    my $neb = Nebulous::Client->new(
     266        proxy => "http://$hostport/nebulous",
     267    );
     268
     269    $neb->lock( "foo", 'read', 3, "bar" );
    270270};
    271271like( $@, qr/2 - 3 were expected/, "too many params" );
    272272
    273 Test::IData->cleanup;
     273Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/15_client_unlock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 15_client_unlock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 15_client_unlock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
    29     $idata->lock( "foo", "read" );
     28    $neb->create( "foo" );
     29    $neb->lock( "foo", "read" );
    3030
    31     ok( $idata->unlock( "foo", "read" ), "read unlock" );
     31    ok( $neb->unlock( "foo", "read" ), "read unlock" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     my $idata = PS::IPP::IData::Client->new(
    38         proxy => "http://$hostport/idata",
     37    my $neb = Nebulous::Client->new(
     38        proxy => "http://$hostport/nebulous",
    3939    );
    40     $idata->create( "foo" );
    41     $idata->lock( "foo", "read" );
    42     $idata->lock( "foo", "read" );
     40    $neb->create( "foo" );
     41    $neb->lock( "foo", "read" );
     42    $neb->lock( "foo", "read" );
    4343
    44     ok( $idata->unlock( "foo", "read" ), "read unlock" );
    45     ok( $idata->unlock( "foo", "read" ), "read unlock" );
     44    ok( $neb->unlock( "foo", "read" ), "read unlock" );
     45    ok( $neb->unlock( "foo", "read" ), "read unlock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    54     $idata->create( "foo" );
    55     $idata->lock( "foo", "write" );
     54    $neb->create( "foo" );
     55    $neb->lock( "foo", "write" );
    5656
    57     ok( $idata->unlock( "foo", "write" ), "write unlock" );
     57    ok( $neb->unlock( "foo", "write" ), "write unlock" );
    5858}
    5959
    60 Test::IData->setup;
     60Test::Nebulous->setup;
    6161
    6262{
    63     my $idata = PS::IPP::IData::Client->new(
    64         proxy => "http://$hostport/idata",
     63    my $neb = Nebulous::Client->new(
     64        proxy => "http://$hostport/nebulous",
    6565    );
    6666
    67     is( $idata->unlock( "foo", "read" ), undef, "storage object does not exist" );
     67    is( $neb->unlock( "foo", "read" ), undef, "storage object does not exist" );
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $idata = PS::IPP::IData::Client->new(
    74         proxy => "http://$hostport/idata",
     73    my $neb = Nebulous::Client->new(
     74        proxy => "http://$hostport/nebulous",
    7575    );
    7676
    77     is( $idata->unlock( "foo", "write" ), undef, "storage object does not exist" );
     77    is( $neb->unlock( "foo", "write" ), undef, "storage object does not exist" );
    7878}
    7979
    80 Test::IData->setup;
     80Test::Nebulous->setup;
    8181
    8282{
    83     my $idata = PS::IPP::IData::Client->new(
    84         proxy => "http://$hostport/idata",
     83    my $neb = Nebulous::Client->new(
     84        proxy => "http://$hostport/nebulous",
    8585    );
    86     $idata->create( "foo" );
     86    $neb->create( "foo" );
    8787
    88     is( $idata->unlock( "foo", "read" ), undef, "no lock set" );
     88    is( $neb->unlock( "foo", "read" ), undef, "no lock set" );
    8989}
    9090
    91 Test::IData->setup;
     91Test::Nebulous->setup;
    9292
    9393{
    94     my $idata = PS::IPP::IData::Client->new(
    95         proxy => "http://$hostport/idata",
     94    my $neb = Nebulous::Client->new(
     95        proxy => "http://$hostport/nebulous",
    9696    );
    97     $idata->create( "foo" );
     97    $neb->create( "foo" );
    9898
    99     is( $idata->unlock( "foo", "write" ), undef, "no lock set" );
     99    is( $neb->unlock( "foo", "write" ), undef, "no lock set" );
    100100}
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104{
    105     my $idata = PS::IPP::IData::Client->new(
    106         proxy => "http://$hostport/idata",
     105    my $neb = Nebulous::Client->new(
     106        proxy => "http://$hostport/nebulous",
    107107    );
    108     $idata->create( "foo" );
    109     $idata->lock( "foo", "write" );
     108    $neb->create( "foo" );
     109    $neb->lock( "foo", "write" );
    110110
    111     is( $idata->unlock( "foo", "read" ), undef, "read unlock under write lock" );
     111    is( $neb->unlock( "foo", "read" ), undef, "read unlock under write lock" );
    112112}
    113113
    114 Test::IData->setup;
     114Test::Nebulous->setup;
    115115
    116116{
    117     my $idata = PS::IPP::IData::Client->new(
    118         proxy => "http://$hostport/idata",
     117    my $neb = Nebulous::Client->new(
     118        proxy => "http://$hostport/nebulous",
    119119    );
    120     $idata->create( "foo" );
    121     $idata->lock( "foo", "read" );
     120    $neb->create( "foo" );
     121    $neb->lock( "foo", "read" );
    122122
    123     is( $idata->unlock( "foo", "write" ), undef, "write unlock under read lock" );
     123    is( $neb->unlock( "foo", "write" ), undef, "write unlock under read lock" );
    124124}
    125125
    126 Test::IData->setup;
     126Test::Nebulous->setup;
    127127
    128128eval {
    129     my $idata = PS::IPP::IData::Client->new(
    130         proxy => "http://$hostport/idata",
     129    my $neb = Nebulous::Client->new(
     130        proxy => "http://$hostport/nebulous",
    131131    );
    132132
    133     $idata->unlock();
     133    $neb->unlock();
    134134};
    135135like( $@, qr/2 were expected/, "no params" );
    136136
    137 Test::IData->setup;
     137Test::Nebulous->setup;
    138138
    139139eval {
    140     my $idata = PS::IPP::IData::Client->new(
    141         proxy => "http://$hostport/idata",
     140    my $neb = Nebulous::Client->new(
     141        proxy => "http://$hostport/nebulous",
    142142    );
    143143
    144     $idata->unlock( "foo" );
     144    $neb->unlock( "foo" );
    145145};
    146146like( $@, qr/2 were expected/, "not enough params" );
    147147
    148 Test::IData->setup;
     148Test::Nebulous->setup;
    149149
    150150eval {
    151     my $idata = PS::IPP::IData::Client->new(
    152         proxy => "http://$hostport/idata",
     151    my $neb = Nebulous::Client->new(
     152        proxy => "http://$hostport/nebulous",
    153153    );
    154154
    155     $idata->unlock( "foo", "both" );
     155    $neb->unlock( "foo", "both" );
    156156};
    157157like( $@, qr/is read or write/, "not read or write" );
    158158
    159 Test::IData->setup;
     159Test::Nebulous->setup;
    160160
    161161eval {
    162     my $idata = PS::IPP::IData::Client->new(
    163         proxy => "http://$hostport/idata",
     162    my $neb = Nebulous::Client->new(
     163        proxy => "http://$hostport/nebulous",
    164164    );
    165165
    166     $idata->unlock( "foo", 'read', 3 );
     166    $neb->unlock( "foo", 'read', 3 );
    167167};
    168168like( $@, qr/2 were expected/, "too many params" );
    169169
    170 Test::IData->cleanup;
     170Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/16_client_find_instances.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 16_client_find_instances.t,v 1.5 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 16_client_find_instances.t,v 1.6 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
     29    $neb->create( "foo" );
    3030
    31     my $locations = $idata->find_instances( "foo" );
     31    my $locations = $neb->find_instances( "foo" );
    3232
    3333    is( scalar @$locations, 1, "found 1" );
    … …  
    3636}
    3737
    38 Test::IData->setup;
     38Test::Nebulous->setup;
    3939
    4040{
    4141    # key
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    45     $idata->create( "foo" );
    46     $idata->replicate( "foo" );
     45    $neb->create( "foo" );
     46    $neb->replicate( "foo" );
    4747
    48     my $locations = $idata->find_instances( "foo" );
     48    my $locations = $neb->find_instances( "foo" );
    4949
    5050    is( scalar @$locations, 2, "found 2" );
    … …  
    5555}
    5656
    57 Test::IData->setup;
     57Test::Nebulous->setup;
    5858
    5959{
    6060    # key, volume
    61     my $idata = PS::IPP::IData::Client->new(
    62         proxy => "http://$hostport/idata",
     61    my $neb = Nebulous::Client->new(
     62        proxy => "http://$hostport/nebulous",
    6363    );
    64     $idata->create( "foo" );
     64    $neb->create( "foo" );
    6565
    66     my $locations = $idata->find_instances( "foo", "node01" );
     66    my $locations = $neb->find_instances( "foo", "node01" );
    6767
    6868    is( scalar @$locations, 1, "found 1" );
    … …  
    7171}
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575{
    7676    # key
    77     my $idata = PS::IPP::IData::Client->new(
    78         proxy => "http://$hostport/idata",
     77    my $neb = Nebulous::Client->new(
     78        proxy => "http://$hostport/nebulous",
    7979    );
    80     $idata->create( "foo" );
    81     $idata->replicate( "foo" );
     80    $neb->create( "foo" );
     81    $neb->replicate( "foo" );
    8282
    83     my $locations = $idata->find_instances( "foo", "node01" );
     83    my $locations = $neb->find_instances( "foo", "node01" );
    8484
    8585    is( scalar @$locations, 2, "found 2" );
    … …  
    9090}
    9191
    92 Test::IData->setup;
     92Test::Nebulous->setup;
    9393
    9494{
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
    9797    );
    9898
    99     is( $idata->find_instances( "foo" ), undef, "storage object does not exist" );
     99    is( $neb->find_instances( "foo" ), undef, "storage object does not exist" );
    100100}
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104eval {
    105     my $idata = PS::IPP::IData::Client->new(
    106         proxy => "http://$hostport/idata",
     105    my $neb = Nebulous::Client->new(
     106        proxy => "http://$hostport/nebulous",
    107107    );
    108108
    109     $idata->find_instances();
     109    $neb->find_instances();
    110110};
    111111like( $@, qr/1 - 2 were expected/, "no params" );
    112112
    113 Test::IData->setup;
     113Test::Nebulous->setup;
    114114
    115115eval {
    116     my $idata = PS::IPP::IData::Client->new(
    117         proxy => "http://$hostport/idata",
     116    my $neb = Nebulous::Client->new(
     117        proxy => "http://$hostport/nebulous",
    118118    );
    119119
    120     $idata->find_instances( "foo", 'read', 3 );
     120    $neb->find_instances( "foo", 'read', 3 );
    121121};
    122122like( $@, qr/1 - 2 were expected/, "too many params" );
    123123
    124 Test::IData->cleanup;
     124Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/17_client_find.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 17_client_find.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 17_client_find.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     my $uri = $idata->create( "foo" );
     29    my $uri = $neb->create( "foo" );
    3030
    31     my $path = $idata->find( "foo" );
     31    my $path = $neb->find( "foo" );
    3232
    3333    ok( -e $path, "file exists" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    4242
    43     my $path = $idata->find( "foo" );
     43    my $path = $neb->find( "foo" );
    4444
    4545    ok( ! -e $path, "file doesn't exist" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050eval {
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    5454
    55     $idata->find();
     55    $neb->find();
    5656};
    5757like( $@, qr/1 was expected/, "no params" );
    5858
    59 Test::IData->setup;
     59Test::Nebulous->setup;
    6060
    6161eval {
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
    6464    );
    6565
    66     $idata->find( "foo", "bar" );
     66    $neb->find( "foo", "bar" );
    6767};
    6868like( $@, qr/1 was expected/, "too many params" );
    6969
    70 Test::IData->cleanup;
     70Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/18_client_open.t

    r2896 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 18_client_open.t,v 1.1 2005-01-05 01:41:05 jhoblitt Exp $
     5# $Id: 18_client_open.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
    30     my $fh = $idata->open( "foo", 'read' );
     29    $neb->create( "foo" );
     30    my $fh = $neb->open( "foo", 'read' );
    3131
    3232    is( ref $fh, 'GLOB', "good filehandle" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    42     $idata->create( "foo" );
    43     my $fh = $idata->open( "foo", 'write' );
     42    $neb->create( "foo" );
     43    my $fh = $neb->open( "foo", 'write' );
    4444
    4545    is( ref $fh, 'GLOB', "good filehandle" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    5454
    55     is( ref $idata->open( "foo", 'write' ), 'GLOB', "create new object" );
     55    is( ref $neb->open( "foo", 'write' ), 'GLOB', "create new object" );
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060{
    61     my $idata = PS::IPP::IData::Client->new(
    62         proxy => "http://$hostport/idata",
     61    my $neb = Nebulous::Client->new(
     62        proxy => "http://$hostport/nebulous",
    6363    );
    6464
    65     is( $idata->open( "foo", 'read' ), undef, "can't create new object" );
     65    is( $neb->open( "foo", 'read' ), undef, "can't create new object" );
    6666}
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     my $idata = PS::IPP::IData::Client->new(
    72         proxy => "http://$hostport/idata",
     71    my $neb = Nebulous::Client->new(
     72        proxy => "http://$hostport/nebulous",
    7373    );
    74     $idata->open( "foo", 'bar' );
     74    $neb->open( "foo", 'bar' );
    7575};
    7676like( $@, qr/is read or write/, "2nd params not read or write" );
    7777
    78 Test::IData->setup;
     78Test::Nebulous->setup;
    7979
    8080eval {
    81     my $idata = PS::IPP::IData::Client->new(
    82         proxy => "http://$hostport/idata",
     81    my $neb = Nebulous::Client->new(
     82        proxy => "http://$hostport/nebulous",
    8383    );
    84     $idata->open();
     84    $neb->open();
    8585};
    8686like( $@, qr/2 were expected/, "no params" );
    8787
    88 Test::IData->setup;
     88Test::Nebulous->setup;
    8989
    9090eval {
    91     my $idata = PS::IPP::IData::Client->new(
    92         proxy => "http://$hostport/idata",
     91    my $neb = Nebulous::Client->new(
     92        proxy => "http://$hostport/nebulous",
    9393    );
    94     $idata->open( 1, 'read', 3 );
     94    $neb->open( 1, 'read', 3 );
    9595};
    9696like( $@, qr/2 were expected/, "too many params" );
    9797
    98 Test::IData->cleanup;
     98Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/19_client_delete.t

    r2913 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 19_client_delete.t,v 1.2 2005-01-05 22:27:22 jhoblitt Exp $
     5# $Id: 19_client_delete.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->delete( "foo" ), "delete object" );
     30    ok( $neb->delete( "foo" ), "delete object" );
    3131
    32     my $locations = $idata->find_instances( "foo" );
     32    my $locations = $neb->find_instances( "foo" );
    3333
    3434    is( $locations, undef, "no instances" );
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    40     my $idata = PS::IPP::IData::Client->new(
    41         proxy => "http://$hostport/idata",
     40    my $neb = Nebulous::Client->new(
     41        proxy => "http://$hostport/nebulous",
    4242    );
    43     $idata->create( "foo" );
    44     $idata->replicate( "foo" );
     43    $neb->create( "foo" );
     44    $neb->replicate( "foo" );
    4545
    46     ok( $idata->delete( "foo" ), "delete object" );
     46    ok( $neb->delete( "foo" ), "delete object" );
    4747
    48     my $locations = $idata->find_instances( "foo" );
     48    my $locations = $neb->find_instances( "foo" );
    4949
    5050    is( $locations, undef, "no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555{
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    5959
    60     is( $idata->delete( "foo" ), undef, "delete non-existant object" );
     60    is( $neb->delete( "foo" ), undef, "delete non-existant object" );
    6161}
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->delete();
     69    $neb->delete();
    7070};
    7171like( $@, qr/1 was expected/, "no params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->delete( "foo", 2 );
     79    $neb->delete( "foo", 2 );
    8080};
    8181like( $@, qr/1 was expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/20_client_copy.t

    r2878 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 20_client_copy.t,v 1.1 2005-01-04 02:13:21 jhoblitt Exp $
     5# $Id: 20_client_copy.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->copy( "foo", "foobar" ), "copied object" );
     30    ok( $neb->copy( "foo", "foobar" ), "copied object" );
    3131
    32     my $locations1 = $idata->find_instances( "foobar" );
    33     my $locations2 = $idata->find_instances( "foobar" );
     32    my $locations1 = $neb->find_instances( "foobar" );
     33    my $locations2 = $neb->find_instances( "foobar" );
    3434
    3535    is( scalar @$locations1, 1, "old object has an instances" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    4545
    46     ok( ! $idata->copy( "foo", "foobar" ), "copy non-existant object" );
     46    ok( ! $neb->copy( "foo", "foobar" ), "copy non-existant object" );
    4747
    48     my $locations = $idata->find_instances( "foobar" );
     48    my $locations = $neb->find_instances( "foobar" );
    4949
    5050    is( $locations, undef, "new object has no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555eval {
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->copy();
     59    $neb->copy();
    6060};
    6161like( $@, qr/2 were expected/, "no params" );
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->copy( "foo" );
     69    $neb->copy( "foo" );
    7070};
    7171like( $@, qr/2 were expected/, "not enough params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->copy( "foo", "bar", "baz" );
     79    $neb->copy( "foo", "bar", "baz" );
    8080};
    8181like( $@, qr/2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/21_client_move.t

    r2881 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 21_client_move.t,v 1.1 2005-01-04 02:48:31 jhoblitt Exp $
     5# $Id: 21_client_move.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->move( "foo", "foobar" ), "move object" );
     30    ok( $neb->move( "foo", "foobar" ), "move object" );
    3131
    32     my $locations1 = $idata->find_instances( "foo" );
    33     my $locations2 = $idata->find_instances( "foobar" );
     32    my $locations1 = $neb->find_instances( "foo" );
     33    my $locations2 = $neb->find_instances( "foobar" );
    3434
    3535    is( $locations1, undef, "old object has no instances" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    4545
    46     ok( ! $idata->move( "foo", "foobar" ), "move non-existant object" );
     46    ok( ! $neb->move( "foo", "foobar" ), "move non-existant object" );
    4747
    48     my $locations = $idata->find_instances( "foobar" );
     48    my $locations = $neb->find_instances( "foobar" );
    4949
    5050    is( $locations, undef, "new object has no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555eval {
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->move();
     59    $neb->move();
    6060};
    6161like( $@, qr/2 were expected/, "no params" );
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->move( "foo" );
     69    $neb->move( "foo" );
    7070};
    7171like( $@, qr/2 were expected/, "not enough params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->move( "foo", "bar", "baz" );
     79    $neb->move( "foo", "bar", "baz" );
    8080};
    8181like( $@, qr/2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/22_client_delete_instance.t

    r2882 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 22_client_delete_instance.t,v 1.1 2005-01-04 03:14:19 jhoblitt Exp $
     5# $Id: 22_client_delete_instance.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     my $locations = $idata->find_instances( "foo" );
     30    my $locations = $neb->find_instances( "foo" );
    3131
    32     my $uri = $idata->delete_instance( @$locations[0] );
     32    my $uri = $neb->delete_instance( @$locations[0] );
    3333
    3434    is( $uri, @$locations[0], "delete instance" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    45     $idata->create( "foo" );
    46     $idata->replicate( "foo" );
     45    $neb->create( "foo" );
     46    $neb->replicate( "foo" );
    4747
    48     my $uri1 = $idata->find_instances( "foo" )->[0];
     48    my $uri1 = $neb->find_instances( "foo" )->[0];
    4949
    50     ok( $idata->delete_instance( $uri1 ), "delete instance" );
     50    ok( $neb->delete_instance( $uri1 ), "delete instance" );
    5151
    52     my $uri2 = $idata->find_instances( "foo" )->[0];
     52    my $uri2 = $neb->find_instances( "foo" )->[0];
    5353
    5454    isnt( $uri1, $uri2, "other instance remains" );
    5555
    56     ok( $idata->delete_instance( $uri2 ), "delete instance" );
     56    ok( $neb->delete_instance( $uri2 ), "delete instance" );
    5757
    58     my $locations = $idata->find_instances( "foo" );
     58    my $locations = $neb->find_instances( "foo" );
    5959
    6060    is( $locations, undef, "no remaning instances" );
    … …  
    6262
    6363{
    64     my $idata = PS::IPP::IData::Client->new(
    65         proxy => "http://$hostport/idata",
     64    my $neb = Nebulous::Client->new(
     65        proxy => "http://$hostport/nebulous",
    6666    );
    67     my $uri = $idata->delete_instance( "file:/foo" );
     67    my $uri = $neb->delete_instance( "file:/foo" );
    6868
    6969    is( $uri, undef, "uri does not exist" );
    7070}
    7171
    72 Test::IData->setup;
     72Test::Nebulous->setup;
    7373
    7474eval {
    75     my $idata = PS::IPP::IData::Client->new(
    76         proxy => "http://$hostport/idata",
     75    my $neb = Nebulous::Client->new(
     76        proxy => "http://$hostport/nebulous",
    7777    );
    78     $idata->delete_instance();
     78    $neb->delete_instance();
    7979};
    8080like( $@, qr/1 was expected/, "no params" );
    8181
    82 Test::IData->setup;
     82Test::Nebulous->setup;
    8383
    8484eval {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
    8787    );
    88     $idata->delete_instance( "foo", 2 );
     88    $neb->delete_instance( "foo", 2 );
    8989};
    9090like( $@, qr/1 was expected/, "too many params" );
    9191
    92 Test::IData->cleanup;
     92Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/23_client_stat.t

    r3016 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 23_client_stat.t,v 1.2 2005-01-15 04:02:12 jhoblitt Exp $
     5# $Id: 23_client_stat.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     my $info = $idata->stat( "foo" );
     30    my $info = $neb->stat( "foo" );
    3131
    3232    is( scalar @$info, 8, "number of columns" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
    4040    );
    41     $idata->create( "foo", 9, "node01", "foobar" );
     41    $neb->create( "foo", 9, "node01", "foobar" );
    4242
    43     my $info = $idata->stat( "foo" );
     43    my $info = $neb->stat( "foo" );
    4444
    4545    is( scalar @$info, 8,                       "number of columns" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    59     my $idata = PS::IPP::IData::Client->new(
    60         proxy => "http://$hostport/idata",
     59    my $neb = Nebulous::Client->new(
     60        proxy => "http://$hostport/nebulous",
    6161    );
    62     my $info = $idata->stat( "foo" );
     62    my $info = $neb->stat( "foo" );
    6363
    6464    is( $info, undef, "object does not exist" );
    6565}
    6666
    67 Test::IData->setup;
     67Test::Nebulous->setup;
    6868
    6969eval {
    70     my $idata = PS::IPP::IData::Client->new(
    71         proxy => "http://$hostport/idata",
     70    my $neb = Nebulous::Client->new(
     71        proxy => "http://$hostport/nebulous",
    7272    );
    73     $idata->stat();
     73    $neb->stat();
    7474};
    7575like( $@, qr/1 was expected/, "no params" );
    7676
    77 Test::IData->setup;
     77Test::Nebulous->setup;
    7878
    7979eval {
    80     my $idata = PS::IPP::IData::Client->new(
    81         proxy => "http://$hostport/idata",
     80    my $neb = Nebulous::Client->new(
     81        proxy => "http://$hostport/nebulous",
    8282    );
    83     $idata->stat( "foo", 2 );
     83    $neb->stat( "foo", 2 );
    8484};
    8585like( $@, qr/1 was expected/, "too many params" );
    8686
    87 Test::IData->cleanup;
     87Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/apache_03_server_create_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    2626    # key
    27     my $uri = $idata->create_object( "foo" )->result;
     27    my $uri = $neb->create_object( "foo" )->result;
    2828
    2929    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    3737    # key, class
    38     my $uri = $idata->create_object( "foo", 0 )->result;
    39     $idata->delete_instance( $uri );
     38    my $uri = $neb->create_object( "foo", 0 )->result;
     39    $neb->delete_instance( $uri );
    4040
    4141    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4444}
    4545
    46 Test::IData->setup;
     46Test::Nebulous->setup;
    4747
    4848{
    4949    # key, class, volume
    50     my $uri = $idata->create_object( "foo", 0, "node01" )->result;
    51     $idata->delete_instance( $uri );
     50    my $uri = $neb->create_object( "foo", 0, "node01" )->result;
     51    $neb->delete_instance( $uri );
    5252
    5353    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, class, volume, comment
    62     my $uri = $idata->create_object( "foo", 0, "node01", "this is foo" )->result;
    63     $idata->delete_instance( $uri );
     62    my $uri = $neb->create_object( "foo", 0, "node01", "this is foo" )->result;
     63    $neb->delete_instance( $uri );
    6464
    6565    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     $idata->create_object( "foo" );
    74     my $response = $idata->create_object( "foo" );
     73    $neb->create_object( "foo" );
     74    my $response = $neb->create_object( "foo" );
    7575
    7676    like( $response->faultstring, qr/Duplicate entry/, "object already exists" );
    7777}
    7878
    79 Test::IData->setup;
     79Test::Nebulous->setup;
    8080
    8181{
    82     my $response = $idata->create_object();
     82    my $response = $neb->create_object();
    8383
    8484    like( $response->faultstring, qr/2 - 4 were expected/, "no params" );
    8585}
    8686
    87 Test::IData->setup;
     87Test::Nebulous->setup;
    8888
    8989{
    90     my $response = $idata->create_object( 1, 2, 3, 4, 5 );
     90    my $response = $neb->create_object( 1, 2, 3, 4, 5 );
    9191
    9292    like( $response->faultstring, qr/2 - 4 were expected/, "too many params" );
    9393}
    9494
    95 Test::IData->cleanup;
     95Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/apache_04_server_replicate_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    2626    # key
    27     $idata->create_object( "foo" );
    28     my $uri = $idata->replicate_object( "foo" )->result;
     27    $neb->create_object( "foo" );
     28    my $uri = $neb->replicate_object( "foo" )->result;
    2929
    3030    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key, $volume
    39     $idata->create_object( "foo" );
    40     my $uri = $idata->replicate_object( "foo", "node01" )->result;
     39    $neb->create_object( "foo" );
     40    my $uri = $neb->replicate_object( "foo", "node01" )->result;
    4141
    4242    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4545}
    4646
    47 Test::IData->setup;
     47Test::Nebulous->setup;
    4848
    4949{
    5050    # key, $volume
    51     $idata->create_object( "foo" );
    52     my $uri1 = $idata->replicate_object( "foo", "node01" )->result;
    53     my $uri2 = $idata->replicate_object( "foo", "node02" )->result;
     51    $neb->create_object( "foo" );
     52    my $uri1 = $neb->replicate_object( "foo", "node01" )->result;
     53    my $uri2 = $neb->replicate_object( "foo", "node02" )->result;
    5454
    5555    ok( -e _get_file_path( $uri1 ), "file exists" );
    … …  
    6060}
    6161
    62 Test::IData->setup;
     62Test::Nebulous->setup;
    6363
    6464{
    65     my $response = $idata->replicate_object();
     65    my $response = $neb->replicate_object();
    6666
    6767    like( $response->faultstring, qr/1 - 2 were expected/, "no params" );
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $response = $idata->replicate_object( 1, 2, 3 );
     73    my $response = $neb->replicate_object( 1, 2, 3 );
    7474
    7575    like( $response->faultstring, qr/1 - 2 were expected/, "too many params" );
    7676}
    7777
    78 Test::IData->setup;
     78Test::Nebulous->setup;
    7979
    8080{
    81     my $response = $idata->replicate_object( "foo" );
     81    my $response = $neb->replicate_object( "foo" );
    8282
    8383    like( $response->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    8484}
    8585
    86 Test::IData->cleanup;
     86Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/apache_05_server_lock_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    26     $idata->create_object( "foo" );
     26    $neb->create_object( "foo" );
    2727
    28     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
     28    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
    2929}
    3030
    31 Test::IData->setup;
     31Test::Nebulous->setup;
    3232
    3333{
    34     $idata->create_object( "foo" );
     34    $neb->create_object( "foo" );
    3535
    36     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
    37     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
     36    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
     37    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
    3838}
    3939
    40 Test::IData->setup;
     40Test::Nebulous->setup;
    4141
    4242{
    43     $idata->create_object( "foo" );
     43    $neb->create_object( "foo" );
    4444
    45     ok( $idata->lock_object( "foo", "write" )->result, "write lock" );
     45    ok( $neb->lock_object( "foo", "write" )->result, "write lock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $result = $idata->lock_object( "foo", "read" );
     51    my $result = $neb->lock_object( "foo", "read" );
    5252
    5353    like( $result->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    59     my $result = $idata->lock_object( "foo", "write" );
     59    my $result = $neb->lock_object( "foo", "write" );
    6060
    6161    like( $result->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    6262}
    6363
    64 Test::IData->setup;
     64Test::Nebulous->setup;
    6565
    6666{
    67     $idata->create_object( "foo" );
     67    $neb->create_object( "foo" );
    6868
    69     $idata->lock_object( "foo", "write" );
    70     my $result = $idata->lock_object( "foo", "write" );
     69    $neb->lock_object( "foo", "write" );
     70    my $result = $neb->lock_object( "foo", "write" );
    7171
    7272    like( $result->faultstring, qr/can not write lock twice/, "can not write lock twice" );
    7373}
    7474
    75 Test::IData->setup;
     75Test::Nebulous->setup;
    7676
    7777{
    78     $idata->create_object( "foo" );
     78    $neb->create_object( "foo" );
    7979
    80     $idata->lock_object( "foo", "read" );
    81     my $result = $idata->lock_object( "foo", "write" );
     80    $neb->lock_object( "foo", "read" );
     81    my $result = $neb->lock_object( "foo", "write" );
    8282
    8383    like( $result->faultstring, qr/can not write lock after read lock/, "can not write lock after read lock" );
    8484}
    8585
    86 Test::IData->setup;
     86Test::Nebulous->setup;
    8787
    8888{
    89     $idata->create_object( "foo" );
     89    $neb->create_object( "foo" );
    9090
    91     $idata->lock_object( "foo", "write" );
    92     my $result = $idata->lock_object( "foo", "read" );
     91    $neb->lock_object( "foo", "write" );
     92    my $result = $neb->lock_object( "foo", "read" );
    9393
    9494    like( $result->faultstring, qr/can not read lock after write lock/, "can not read lock after write lock" );
    9595}
    9696
    97 Test::IData->setup;
     97Test::Nebulous->setup;
    9898
    9999{
    100     my $result = $idata->lock_object();
     100    my $result = $neb->lock_object();
    101101
    102102    like( $result->faultstring, qr/2 were expected/, "no params" );
    103103}
    104104
    105 Test::IData->setup;
     105Test::Nebulous->setup;
    106106
    107107{
    108     my $result = $idata->lock_object( "foo" );
     108    my $result = $neb->lock_object( "foo" );
    109109
    110110    like( $result->faultstring, qr/2 were expected/, "not enough params" );
    111111}
    112112
    113 Test::IData->setup;
     113Test::Nebulous->setup;
    114114
    115115{
    116     my $result = $idata->lock_object( "foo", "both" );
     116    my $result = $neb->lock_object( "foo", "both" );
    117117
    118118    like( $result->faultstring, qr/is read or write/, "not read or write" );
    119119}
    120120
    121 Test::IData->setup;
     121Test::Nebulous->setup;
    122122
    123123{
    124     my $result = $idata->lock_object( "foo", 'read', 3 );
     124    my $result = $neb->lock_object( "foo", 'read', 3 );
    125125
    126126    like( $result->faultstring, qr/2 were expected/, "too many params" );
    127127}
    128128
    129 Test::IData->cleanup;
     129Test::Nebulous->cleanup;

  • trunk/Nebulous/Build.PL

    r3004 r4440  
    77
    88$build_pkg->new(
    9     module_name         => 'PS::IPP::IData',
    10     dist_version_from   => 'lib/PS/IPP/IData/Server.pm',
     9    module_name         => 'Nebulous',
     10    dist_version_from   => 'lib/Nebulous/Server.pm',
    1111    author              => 'Joshua Hoblitt <jhoblitt@cpan.org>',
    1212    license             => 'gpl',

  • trunk/Nebulous/MANIFEST

    r4118 r4440  
    77README
    88Todo
    9 bootstrap.sh
    109docs/apache_setup.txt
    1110docs/c_api.h
    … …  
    1615docs/setup.txt
    1716docs/tmp.txt
    18 gsoap/idata.wsdl
    19 lib/PS/IPP/IData/Client.pm
    20 lib/PS/IPP/IData/Client/HTTP.pm
    21 lib/PS/IPP/IData/Client/Log.pm
    22 lib/PS/IPP/IData/Server.pm
    23 lib/PS/IPP/IData/Server/Apache.pm
    24 lib/PS/IPP/IData/Server/Log.pm
    25 lib/PS/IPP/IData/Server/SQL.pm
    26 lib/PS/IPP/IData/Util.pm
     17gsoap/nebulous.wsdl
     18lib/Nebulous/Client.pm
     19lib/Nebulous/Client/HTTP.pm
     20lib/Nebulous/Client/Log.pm
     21lib/Nebulous/Server.pm
     22lib/Nebulous/Server/Apache.pm
     23lib/Nebulous/Server/Log.pm
     24lib/Nebulous/Server/SQL.pm
     25lib/Nebulous/Util.pm
    2726scripts/bench_test.pl
    2827scripts/imageserver.pl
    … …  
    4544t/15_client_unlock.t
    4645t/16_client_find_instances.t
     46t/17_client_find.t
     47t/18_client_open.t
     48t/19_client_delete.t
     49t/20_client_copy.t
     50t/21_client_move.t
     51t/22_client_delete_instance.t
     52t/23_client_stat.t
    4753t/TEST.PL
    48 t/Test/IData.pm
     54t/Test/Nebulous.pm
    4955t/apache_03_server_create_object.x
    5056t/apache_04_server_replicate_object.x
    5157t/apache_05_server_lock_object.x
    5258t/conf/extra.conf.in
     59t/conf/startup.pl.in

  • trunk/Nebulous/Todo

    r3013 r4440  
    1 TODO list for Perl module PS::IPP::IData
     1TODO list for Perl module Nebulous
    22
    33- redo database scheme with foreign keys

  • trunk/Nebulous/docs/apache_setup.txt

    r2997 r4440  
    11# Copyright (C) 2004-2005  Joshua Hoblitt
    22#
    3 # $Id: apache_setup.txt,v 1.2 2005-01-14 21:23:35 jhoblitt Exp $
     3# $Id: apache_setup.txt,v 1.3 2005-06-30 02:35:05 jhoblitt Exp $
    44
    55- mod_perl-1.29 install
    … …  
    88#MP_TRACE = 1 MP_DEBUG = 1 MP_USE_DSO = 1 MP_INST_APACHE2 = 1 MP_APXS = /usr/sbin/apxs2
    99
    10 - add the "idata" group to /etc/group
    11 - configure Apache to run as the idata group.
     10- add the "nebulous" group to /etc/group
     11- configure Apache to run as the nebulous group.
     12
     13# out of data from here down...
    1214
    1315#
    … …  
    1517#
    1618
    17 ScriptAlias /idata /usr/local/apache/perl/imageserver.pl
     19ScriptAlias /nebulous /usr/local/apache/perl/imageserver.pl
    1820
    1921<Directory "/usr/local/apache/perl">
    … …  
    3436
    3537#
    36 # PS::IPP::IData::Apache interface
     38# Nebulous::Apache interface
    3739#
    3840
    3941PerlModule Apache::DBI
    40 PerlModule PS::IPP::IData::Apache
     42PerlModule Nebulous::Apache
    4143
    42 <Location /idata>
     44<Location /nebulous>
    4345        SetHandler perl-script
    44         PerlHandler PS::IPP::IData::Apache
     46        PerlHandler Nebulous::Apache
    4547</Location>
    4648

  • trunk/Nebulous/docs/setup.txt

    r4119 r4440  
    3333
    3434
    35 mkdir /po01/idata
    36 chown root:idata /po01/idata
    37 chmod 0770 /po01/idata
     35mkdir /po01/nebulous
     36chown root:nebulous /po01/nebulous
     37chmod 0770 /po01/nebulous
    3838
    3939in /etc/mysql/my.cnf

  • trunk/Nebulous/lib/Nebulous/Client.pm

    r2919 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Client.pm,v 1.14 2005-01-06 04:11:02 jhoblitt Exp $
    4 
    5 package PS::IPP::IData::Client;
     3# $Id: Client.pm,v 1.15 2005-06-30 02:35:06 jhoblitt Exp $
     4
     5package Nebulous::Client;
    66
    77use strict;
    … …  
    1212use File::Copy qw();
    1313use Log::Log4perl qw(get_logger :levels);
    14 use PS::IPP::IData::Client::Log;
    15 use PS::IPP::IData::Util qw( :standard );
     14use Nebulous::Client::Log;
     15use Nebulous::Util qw( :standard );
    1616use Params::Validate qw( validate validate_pos SCALAR );
    1717#use SOAP::Lite +trace => [qw( debug )];
    … …  
    2323use constant LOCK_DEFAULT   => 10;    # default to a 10s lock timeout
    2424
    25 my $log = get_logger( "PS::IPP::IData::Client" );
     25my $log = get_logger( "Nebulous::Client" );
    2626$log->level( $WARN );
    2727
    … …  
    7474    my $lite = SOAP::Lite->new(
    7575            proxy => $args{ 'proxy' },
    76             uri   => $args{ 'uri' } || "urn:PS/IPP/IData/Server/SOAP",
     76            uri   => $args{ 'uri' } || "urn:Nebulous/Server/SOAP",
    7777    );
    7878

  • trunk/Nebulous/lib/Nebulous/Client.pod

    r2912 r4440  
    33=head1 NAME
    44
    5 PS::IPP::IData::Client - iData client component
     5Nebulous::Client - Nebulous client component
    66
    77=head1 SYNOPSIS
    88
    9     use PS::IPP::IData::Client;
     9    use Nebulous::Client;
    1010
    11     my $idata = PS::IPP::IData::Client->new(
    12         proxy   => 'http://localhost:80/idata'
     11    my $neb = Nebulous::Client->new(
     12        proxy   => 'http://localhost:80/nebulous'
    1313    );
    1414
    15     my $fh = $idata->create( "key", 0, "node01", "example" );
    16     $idata->replicate( "key", "node01" );
    17     $idata->cull( "key" );
    18     $idata->lock( "key", 'write' );
    19     $idata->unlock( "key", 'write' );
    20     my $uris = $idata->find_instances( "key", "node01" );
    21     my $path = $idata->find( "key" );
    22     my $fh = $idata->open( "key", 'read' );
     15    my $fh = $neb->create( "key", 0, "node01", "example" );
     16    $neb->replicate( "key", "node01" );
     17    $neb->cull( "key" );
     18    $neb->lock( "key", 'write' );
     19    $neb->unlock( "key", 'write' );
     20    my $uris = $neb->find_instances( "key", "node01" );
     21    my $path = $neb->find( "key" );
     22    my $fh = $neb->open( "key", 'read' );
    2323    $data->delete( "key" );
    2424    $data->copy( "key", "new_key" );
    2525    $data->move( "key", "new_key" );
    2626    $data->delete_instance( $uri );
    27     my $stats = $idata->stat( "key" );
     27    my $stats = $neb->stat( "key" );
    2828
    2929=head1 DESCRIPTION
    3030
    31 This component provides client access to the iData storage system.  It provides
    32 an interface for files to be added, managed, and removed from the system.
     31This component provides client access to the Nebulous storage system.  It
     32provides an interface for files to be added, managed, and removed from the
     33system.
    3334
    3435=head1 USAGE
    … …  
    3940I<symbols>.
    4041
    41     use PS::IPP::IData::Client trace => qw( debug );
     42    use Nebulous::Client trace => qw( debug );
    4243
    4344The hash is allowed to have a single key, C<trace>.  This controls the level of
    … …  
    5758Accepts a mandatory hash.
    5859
    59     my $idata = PS::IPP::IData::Client->new(
    60         proxy   => 'http://localhost:80/idata'
    61         uri     => 'urn:PS/IPP/IData/Server',
     60    my $neb = Nebulous::Client->new(
     61        proxy   => 'http://localhost:80/nebulous'
     62        uri     => 'urn:Nebulous/Server',
    6263    );
    6364
    … …  
    6667=item * proxy
    6768
    68 The URL of the iData server to connect to.
     69The URL of the Nebulous server to connect to.
    6970
    7071=item * uri
    … …  
    119120=item MogileFS
    120121
    121 The iData system is similar in function to MogileFS but very different in
     122The Nebulous system is similar in function to MogileFS but very different in
    122123implementation and operation.
    123124
    … …  
    160161=head1 SEE ALSO
    161162
    162 L<PS::IPP::IData::Server>
     163L<Nebulous::Server>
    163164
    164165=cut

  • trunk/Nebulous/lib/Nebulous/Client/HTTP.pm

    r2785 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: HTTP.pm,v 1.1.1.1 2004-12-22 02:16:24 jhoblitt Exp $
     3# $Id: HTTP.pm,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Client::HTTP;
     5package Nebulous::Client::HTTP;
    66
    77use strict;

  • trunk/Nebulous/lib/Nebulous/Client/Log.pm

    r2898 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Log.pm,v 1.2 2005-01-05 02:44:54 jhoblitt Exp $
     3# $Id: Log.pm,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Client::Log;
     5package Nebulous::Client::Log;
    66
    77use strict;
    … …  
    1313
    1414my $conf = q(
    15     log4perl.category.PS.IPP.IData.Client = DEBUG, Screen
    16 #log4perl.category.PS.IPP.IData.Client = DEBUG, CLIENTLOGFILE, Screen
     15    log4perl.category.Nebulous.Client = DEBUG, Screen
     16#log4perl.category.Nebulous.Client = DEBUG, CLIENTLOGFILE, Screen
    1717
    1818    log4perl.appender.Screen        = Log::Log4perl::Appender::Screen
    … …  
    2222
    2323    log4perl.appender.CLIENTLOGFILE           = Log::Log4perl::Appender::File
    24     log4perl.appender.CLIENTLOGFILE.filename  = /tmp/idata_client.log
     24    log4perl.appender.CLIENTLOGFILE.filename  = /tmp/nebulous_client.log
    2525    log4perl.appender.CLIENTLOGFILE.mode      = append
    2626    log4perl.appender.CLIENTLOGFILE.layout    = Log::Log4perl::Layout::PatternLayout

  • trunk/Nebulous/lib/Nebulous/Server.pm

    r2905 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Server.pm,v 1.8 2005-01-05 04:31:59 jhoblitt Exp $
    4 
    5 package PS::IPP::IData::Server;
     3# $Id: Server.pm,v 1.9 2005-06-30 02:35:06 jhoblitt Exp $
     4
     5package Nebulous::Server;
    66
    77use strict;
    … …  
    1111
    1212use DBI;
    13 use PS::IPP::IData::Util qw( :standard );
    14 use PS::IPP::IData::Server::Log;
    15 use PS::IPP::IData::Server::SQL;
     13use Nebulous::Util qw( :standard );
     14use Nebulous::Server::Log;
     15use Nebulous::Server::SQL;
    1616use Log::Log4perl;
    1717use Params::Validate qw( validate_pos SCALAR );
    … …  
    4040    );
    4141
    42     $log = Log::Log4perl::get_logger( "PS::IPP::IData::Server" );
    43     $sql = PS::IPP::IData::Server::SQL->new;
     42    $log = Log::Log4perl::get_logger( "Nebulous::Server" );
     43    $sql = Nebulous::Server::SQL->new;
    4444
    4545    $log->debug( "entered - @_" );

  • trunk/Nebulous/lib/Nebulous/Server.pod

    r2863 r4440  
    33=head1 NAME
    44
    5 PS::IPP::IData::Server - iData server component
     5Nebulous::Server - Nebulous server component
    66
    77=head1 SYNOPSIS
    88
    9     use PS::IPP::IData::Server;
     9    use Nebulous::Server;
    1010
    11     PS::IPP::IData::Server->setup( $dsn, $username, $passwd );
    12     PS::IPP::IData::Server->create_object( $key, $class, $volume, $comment );
    13     PS::IPP::IData::Server->replicate_object( $key, $volume );
    14     PS::IPP::IData::Server->lock_object( $key, $type );
    15     PS::IPP::IData::Server->unlock_object( $key, $type );
    16     PS::IPP::IData::Server->find_instance( $key, $volume );
    17     PS::IPP::IData::Server->delete_instance( $uri );
    18     PS::IPP::IData::Server->stat_object( $key );
     11    Nebulous::Server->setup( $dsn, $username, $passwd );
     12    Nebulous::Server->create_object( $key, $class, $volume, $comment );
     13    Nebulous::Server->replicate_object( $key, $volume );
     14    Nebulous::Server->lock_object( $key, $type );
     15    Nebulous::Server->unlock_object( $key, $type );
     16    Nebulous::Server->find_instance( $key, $volume );
     17    Nebulous::Server->delete_instance( $uri );
     18    Nebulous::Server->stat_object( $key );
    1919
    2020=head1 DESCRIPTION
    2121
    22 This is the server side component of the iData system.  It is primarily a
     22This is the server side component of the Nebulous system.  It is primarily a
    2323middle-ware abstraction of an SQL database.
    2424
    … …  
    120120=head1 SEE ALSO
    121121
    122 L<PS::IPP::IData::Client>
     122L<Nebulous::Client>
    123123
    124124=cut

  • trunk/Nebulous/lib/Nebulous/Server/Apache.pm

    r2918 r4440  
    33# $Id
    44
    5 package PS::IPP::IData::Server::Apache;
     5package Nebulous::Server::Apache;
    66
    77use strict;
    … …  
    1010our $VERSION = 0.01;
    1111
    12 use PS::IPP::IData::Server::SOAP;
     12use Nebulous::Server::SOAP;
    1313use SOAP::Transport::HTTP;
    1414
    1515my $server = SOAP::Transport::HTTP::Apache
    16     ->dispatch_to( 'PS::IPP::IData::Server::SOAP' )
     16    ->dispatch_to( 'Nebulous::Server::SOAP' )
    1717    ->options({ compress_threshold => 10 * 1024 });
    1818

  • trunk/Nebulous/lib/Nebulous/Server/Log.pm

    r2898 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Log.pm,v 1.2 2005-01-05 02:44:54 jhoblitt Exp $
     3# $Id: Log.pm,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Server::Log;
     5package Nebulous::Server::Log;
    66
    77use strict;
    … …  
    1313                                                                                                                                         
    1414my $conf = q(
    15     log4perl.category.PS.IPP.IData.Server = DEBUG, SERVERLOGFILE
     15    log4perl.category.Nebulous.Server = DEBUG, SERVERLOGFILE
    1616
    1717    log4perl.appender.SERVERLOGFILE           = Log::Log4perl::Appender::File
    18     log4perl.appender.SERVERLOGFILE.filename  = /tmp/idata_server.log
     18    log4perl.appender.SERVERLOGFILE.filename  = /tmp/nebulous_server.log
    1919    log4perl.appender.SERVERLOGFILE.mode      = append
    2020    log4perl.appender.SERVERLOGFILE.layout    = Log::Log4perl::Layout::PatternLayout

  • trunk/Nebulous/lib/Nebulous/Server/SOAP.pm

    r2917 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: SOAP.pm,v 1.1 2005-01-06 03:56:43 jhoblitt Exp $
     3# $Id: SOAP.pm,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Server::SOAP;
     5package Nebulous::Server::SOAP;
    66
    77use strict;
    … …  
    1010our $VERSION = '0.01';
    1111
    12 use PS::IPP::IData::Server;
     12use Nebulous::Server;
    1313use SOAP::Lite;
    1414import SOAP::Data 'name';
    … …  
    2222    return undef if $method eq 'DESTROY';
    2323
    24     return name( result => PS::IPP::IData::Server->$method( @_ ) );
     24    return name( result => Nebulous::Server->$method( @_ ) );
    2525}
    2626

  • trunk/Nebulous/lib/Nebulous/Server/SQL.pm

    r3016 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: SQL.pm,v 1.4 2005-01-15 04:02:12 jhoblitt Exp $
     3# $Id: SQL.pm,v 1.5 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Server::SQL;
     5package Nebulous::Server::SQL;
    66
    77use strict;

  • trunk/Nebulous/lib/Nebulous/Util.pm

    r2898 r4440  
    11# Copyright (c) 2004  Joshua Hoblitt
    22#
    3 # $Id: Util.pm,v 1.2 2005-01-05 02:44:54 jhoblitt Exp $
     3# $Id: Util.pm,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package PS::IPP::IData::Util;
     5package Nebulous::Util;
    66
    77use strict;

  • trunk/Nebulous/nebclient/bootstrap.sh

    r3098 r4440  
    33# Copyright (C) 2005  Joshua Hoblitt
    44#
    5 # $Id: bootstrap.sh,v 1.7 2005-01-27 01:08:05 jhoblitt Exp $
     5# $Id: bootstrap.sh,v 1.8 2005-06-30 02:35:05 jhoblitt Exp $
    66
    7 wsdl2h -o src/idata.h -c idata.wsdl \
    8 && soapcpp2 -d src -c src/idata.h \
     7wsdl2h -o src/nebulous.h -c nebulous.wsdl \
     8&& soapcpp2 -d src -c src/nebulous.h \
    99&& rm -f src/*.xml
    1010

  • trunk/Nebulous/nebclient/configure.ac

    r3017 r4440  
    11dnl Copyright (C) 2005  Joshua Hoblitt
    22dnl
    3 dnl $Id: configure.ac,v 1.2 2005-01-16 10:37:59 jhoblitt Exp $
     3dnl $Id: configure.ac,v 1.3 2005-06-30 02:35:05 jhoblitt Exp $
    44
    55dnl Process this file with autoconf to produce a configure script.
    6 AC_INIT([idataclient], [0.0.1], [jhoblitt@cpan.org])
     6AC_INIT([nebulousclient], [0.0.1], [jhoblitt@cpan.org])
    77AM_INIT_AUTOMAKE(AC_PACKAGE_NAME, AC_PACKAGE_VERSION)
    8 AC_REVISION([$Revision: 1.2 $])
     8AC_REVISION([$Revision: 1.3 $])
    99
    1010dnl generate config.h

  • trunk/Nebulous/nebclient/nebulous.wsdl

    r3061 r4440  
    11<?xml version="1.0"?>
    2 <definitions name="IDataServer"
    3     targetNamespace="urn:PS/IPP/IData/Server/SOAP"
    4     xmlns:tns="urn:PS/IPP/IData/Server/SOAP"
     2<definitions name="NebulousServer"
     3    targetNamespace="urn:Nebulous/Server/SOAP"
     4    xmlns:tns="urn:Nebulous/Server/SOAP"
    55    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
    66    xmlns:enc="http://schemas.xmlsoap.org/soap/encoding/"
    77    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    88    xmlns="http://schemas.xmlsoap.org/wsdl/"
    9     xmlns:ns="urn:PS/IPP/IData/Server/SOAP">
     9    xmlns:ns="urn:Nebulous/Server/SOAP">
    1010
    1111    <types>
    1212        <schema xmlns="http://www.w3.org/2001/XMLSchema"
    13             targetNamespace="urn:PS/IPP/IData/Server/SOAP"
     13            targetNamespace="urn:Nebulous/Server/SOAP"
    1414            xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    1515            xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/">
    … …  
    8585
    8686
    87     <portType name="PS/IPP/IData/Server/SOAPPort">
     87    <portType name="Nebulous/Server/SOAPPort">
    8888        <operation name="create_object">
    8989            <input  message="tns:create_objectRequest" />
    … …  
    138138
    139139
    140     <binding name="SOAP" type="tns:PS/IPP/IData/Server/SOAPPort">
     140    <binding name="SOAP" type="tns:Nebulous/Server/SOAPPort">
    141141        <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
    142142        <operation name="create_object">
    143             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#create_object" />
    144             <input>
    145                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    146                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    147             </input>
    148             <output>
    149                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     143            <soap:operation soapAction="urn:Nebulous/Server/SOAP#create_object" />
     144            <input>
     145                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     146                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     147            </input>
     148            <output>
     149                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    150150                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    151151            </output>
    152152        </operation>
    153153        <operation name="replicate_object">
    154             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#replicate_object" />
    155             <input>
    156                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    157                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    158             </input>
    159             <output>
    160                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     154            <soap:operation soapAction="urn:Nebulous/Server/SOAP#replicate_object" />
     155            <input>
     156                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     157                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     158            </input>
     159            <output>
     160                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    161161                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    162162            </output>
    163163        </operation>
    164164        <operation name="lock_object">
    165             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#lock_object" />
    166             <input>
    167                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    168                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    169             </input>
    170             <output>
    171                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     165            <soap:operation soapAction="urn:Nebulous/Server/SOAP#lock_object" />
     166            <input>
     167                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     168                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     169            </input>
     170            <output>
     171                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    172172                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    173173            </output>
    174174        </operation>
    175175        <operation name="unlock_object">
    176             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#unlock_object" />
    177             <input>
    178                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    179                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    180             </input>
    181             <output>
    182                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     176            <soap:operation soapAction="urn:Nebulous/Server/SOAP#unlock_object" />
     177            <input>
     178                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     179                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     180            </input>
     181            <output>
     182                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    183183                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    184184            </output>
    185185        </operation>
    186186        <operation name="find_instances">
    187             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#find_instances" />
    188             <input>
    189                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    190                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    191             </input>
    192             <output>
    193                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     187            <soap:operation soapAction="urn:Nebulous/Server/SOAP#find_instances" />
     188            <input>
     189                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     190                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     191            </input>
     192            <output>
     193                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    194194                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    195195            </output>
    196196        </operation>
    197197        <operation name="delete_instance">
    198             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#delete_instance" />
    199             <input>
    200                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    201                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    202             </input>
    203             <output>
    204                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     198            <soap:operation soapAction="urn:Nebulous/Server/SOAP#delete_instance" />
     199            <input>
     200                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     201                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     202            </input>
     203            <output>
     204                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    205205                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    206206            </output>
    207207        </operation>
    208208        <operation name="stat_object">
    209             <soap:operation soapAction="urn:PS/IPP/IData/Server/SOAP#stat_object" />
    210             <input>
    211                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
    212                     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    213             </input>
    214             <output>
    215                 <soap:body use="encoded" namespace="urn:PS/IPP/IData/Server/SOAP"
     209            <soap:operation soapAction="urn:Nebulous/Server/SOAP#stat_object" />
     210            <input>
     211                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
     212                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
     213            </input>
     214            <output>
     215                <soap:body use="encoded" namespace="urn:Nebulous/Server/SOAP"
    216216                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
    217217            </output>
    … …  
    220220
    221221
    222     <service name="PS/IPP/IData/Server/SOAP">
    223         <port name="PS/IPP/IData/Server/SOAPPort" binding="tns:SOAP">
    224             <soap:address location="http://localhost:80/idata" />
     222    <service name="Nebulous/Server/SOAP">
     223        <port name="Nebulous/Server/SOAPPort" binding="tns:SOAP">
     224            <soap:address location="http://localhost:80/nebulous" />
    225225        </port>
    226226    </service>

  • trunk/Nebulous/nebclient/src/Makefile.am

    r3052 r4440  
    11# Copyright (C) 2005  Joshua Hoblitt
    22#
    3 # $Id: Makefile.am,v 1.3 2005-01-19 00:31:35 jhoblitt Exp $
     3# $Id: Makefile.am,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 include_HEADERS=idataclient.h
    6 lib_LTLIBRARIES = libidataclient.la
    7 libidataclient_la_LDFLAGS = -release @PACKAGE_VERSION@
    8 libidataclient_la_SOURCES =\
    9     idataclient.h\
    10     idataclient.c\
     5include_HEADERS=nebclient.h
     6lib_LTLIBRARIES = libnebclient.la
     7libnebclient_la_LDFLAGS = -release @PACKAGE_VERSION@
     8libnebclient_la_SOURCES =\
     9    nebclient.h\
     10    nebclient.c\
    1111    xmalloc.h\
    1212    xmalloc.c\
    … …  
    2121bin_PROGRAMS = test
    2222test_SOURCES = test.c
    23 test_LDADD = libidataclient.la
     23test_LDADD = libnebclient.la

  • trunk/Nebulous/nebclient/src/nebclient.c

    r4121 r4440  
    11/*
    2  * idataclient.c - idata client
     2 * nebclient.c - nebulous client
    33 *
    44 * Copyright (C) 2005  Joshua Hoblitt
    55 *
    6  * $Id: nebclient.c,v 1.3 2005-06-06 21:21:05 jhoblitt Exp $
     6 * $Id: nebclient.c,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    77 */
    88
    … …  
    1818#include "soapH.h"
    1919#include "SOAP.nsmap"
    20 #include "idataclient.h"
     20#include "nebclient.h"
    2121
    2222#define ERRBUF_SIZE 255
    2323
    24 static off_t idataCopyFile(char *source, char *dest);
    25 static off_t idataCopyFilehandle(int sourceFH, int destFH);
    26 
    27 void idataServerInit(idataServer *server)
     24static off_t nebCopyFile(char *source, char *dest);
     25static off_t nebCopyFilehandle(int sourceFH, int destFH);
     26
     27void nebServerInit(nebServer *server)
    2828{
    2929    soap_init(server);
    3030}
    3131
    32 char *idataServerErr(idataServer *server)
     32char *nebServerErr(nebServer *server)
    3333{
    3434    char            *fault;
    … …  
    4545}
    4646
    47 void idataServerCleanup(idataServer *server)
     47void nebServerCleanup(nebServer *server)
    4848{
    4949    soap_end(server); // remove deserialized data and clean up
    … …  
    5151}
    5252
    53 int idataCreate(idataServer *server, char *key, unsigned int class, char *volume, char *comment, char **URI)
     53int nebCreate(nebServer *server, char *key, unsigned int class, char *volume, char *comment, char **URI)
    5454{
    5555    struct ns1__create_USCOREobjectResponse response;
    … …  
    6161        strcpy(*URI, response.result);
    6262
    63         if (!idataParseURI(*URI, &filename)) {
     63        if (!nebParseURI(*URI, &filename)) {
    6464            fprintf(stderr, "can not parse URI\n");
    6565
    … …  
    8181}
    8282
    83 int idataReplicate(idataServer *server, char *key, char *volume, char **URI )
     83int nebReplicate(nebServer *server, char *key, char *volume, char **URI )
    8484{
    8585    struct ns1__replicate_USCOREobjectResponse response;
    … …  
    9191        strcpy(*URI, response.result);
    9292
    93         if (!idataParseURI(*URI, &filename)) {
     93        if (!nebParseURI(*URI, &filename)) {
    9494            fprintf(stderr, "can not parse URI\n");
    9595
    … …  
    9797        }
    9898
    99         sourceFH = idataOpen(server, key, IDATA_READ);
     99        sourceFH = nebOpen(server, key, NEB_READ);
    100100        if (sourceFH == -1) {
    101101            fprintf(stderr, "can not open key %s\n", key );
    … …  
    111111        }
    112112
    113         idataCopyFilehandle(sourceFH, destFH);
     113        nebCopyFilehandle(sourceFH, destFH);
    114114
    115115        if (close(sourceFH) == -1) {
    … …  
    130130}
    131131
    132 int idataCull( idataServer *server,char *key )
    133 {
    134 
    135     return 0;
    136 }
    137 
    138 int idataLock(idataServer *server, char *key, rw flag )
    139 {
    140 
    141     return 0;
    142 }
    143 
    144 int idataUnlock(idataServer *server, char *key, rw flag )
    145 {
    146 
    147     return 0;
    148 }
    149 
    150 int idataFindInstances(idataServer *server, char *key, char *volume, char ***locations)
     132int nebCull( nebServer *server,char *key )
     133{
     134
     135    return 0;
     136}
     137
     138int nebLock(nebServer *server, char *key, rw flag )
     139{
     140
     141    return 0;
     142}
     143
     144int nebUnlock(nebServer *server, char *key, rw flag )
     145{
     146
     147    return 0;
     148}
     149
     150int nebFindInstances(nebServer *server, char *key, char *volume, char ***locations)
    151151{
    152152    struct ns1__find_USCOREinstancesResponse response;
    … …  
    179179}
    180180
    181 int idataFind(idataServer *server, char *key )
    182 {
    183 
    184     return 0;
    185 }
    186 
    187 int idataOpen(idataServer *server, char *key, rw flag )
    188 {
    189 
    190     return 0;
    191 }
    192 
    193 int idataDelete(idataServer *server, char *key )
    194 {
    195 
    196     return 0;
    197 }
    198 
    199 int idataCopy(idataServer *server, char *key, char *newKey )
    200 {
    201 
    202     return 0;
    203 }
    204 
    205 int idataMove(idataServer *server, char *key, char *newKey )
    206 {
    207 
    208     return 0;
    209 }
    210 
    211 int idataDelete_instance(idataServer *server, char *URI )
    212 {
    213 
    214     return 0;
    215 }
    216 
    217 int idataStat(idataServer *server, char *key )
    218 {
    219 
    220     return 0;
    221 }
    222 
    223 int idataErr(idataServer *server, char *errString )
    224 {
    225 
    226     return 0;
    227 }
    228 
    229 int idataParseURI(const char *URI, char **filename)
     181int nebFind(nebServer *server, char *key )
     182{
     183
     184    return 0;
     185}
     186
     187int nebOpen(nebServer *server, char *key, rw flag )
     188{
     189
     190    return 0;
     191}
     192
     193int nebDelete(nebServer *server, char *key )
     194{
     195
     196    return 0;
     197}
     198
     199int nebCopy(nebServer *server, char *key, char *newKey )
     200{
     201
     202    return 0;
     203}
     204
     205int nebMove(nebServer *server, char *key, char *newKey )
     206{
     207
     208    return 0;
     209}
     210
     211int nebDelete_instance(nebServer *server, char *URI )
     212{
     213
     214    return 0;
     215}
     216
     217int nebStat(nebServer *server, char *key )
     218{
     219
     220    return 0;
     221}
     222
     223int nebErr(nebServer *server, char *errString )
     224{
     225
     226    return 0;
     227}
     228
     229int nebParseURI(const char *URI, char **filename)
    230230{
    231231    regex_t         myregex;
    … …  
    270270}
    271271
    272 void idataFree(void *ptr) {
     272void nebFree(void *ptr) {
    273273    xfree(ptr);
    274274}
    275275
    276 static off_t idataCopyFile(char *source, char *dest)
     276static off_t nebCopyFile(char *source, char *dest)
    277277{
    278278    int             sourceFH;
    … …  
    294294    }
    295295
    296     bytesCopied = idataCopyFilehandle(sourceFH, destFH);
     296    bytesCopied = nebCopyFilehandle(sourceFH, destFH);
    297297    if (bytesCopied < 0) {
    298298        return -1;
    … …  
    314314}
    315315
    316 static off_t idataCopyFilehandle(int sourceFH, int destFH)
     316static off_t nebCopyFilehandle(int sourceFH, int destFH)
    317317{
    318318    off_t           bytesTotal;

  • trunk/Nebulous/nebclient/src/nebclient.h

    r4121 r4440  
    11/*
    2  * idataclient -  idata client
     2 * nebclient.h -  nebulous client header
    33 *
    44 * Copyright (C) 2005  Joshua Hoblitt
    55 *
    6  * $Id: nebclient.h,v 1.5 2005-06-06 21:21:05 jhoblitt Exp $
     6 * $Id: nebclient.h,v 1.6 2005-06-30 02:35:06 jhoblitt Exp $
    77 */
    88
    9 #ifndef IDATACLIENT_H
    10 #define IDATACLIENT_H 1
     9#ifndef NEBCLIENT_H
     10#define NEBCLIENT_H 1
    1111
    1212#include "soapH.h"
    1313
    14 typedef enum { IDATA_READ, IDATA_WRITE } rw;
    15 typedef struct soap idataServer;
     14typedef enum { NEB_READ, NEB_WRITE } rw;
     15typedef struct soap nebServer;
    1616
    17 void idataServerInit(idataServer *server);
     17void nebServerInit(nebServer *server);
    1818
    19 char *idataServerErr(idataServer *server);
     19char *nebServerErr(nebServer *server);
    2020
    21 void idataServerCleanup(idataServer *server);
     21void nebServerCleanup(nebServer *server);
    2222
    23 int idataCreate(idataServer *server, char *key, unsigned int class, char *volume, char *comment, char **URI);
     23int nebCreate(nebServer *server, char *key, unsigned int class, char *volume, char *comment, char **URI);
    2424
    25 int idataReplicate(idataServer *server, char *key, char *volume, char **URI);
     25int nebReplicate(nebServer *server, char *key, char *volume, char **URI);
    2626
    27 int idataCull(idataServer *server, char *key);
     27int nebCull(nebServer *server, char *key);
    2828
    29 int idataLock(idataServer *server, char *key, rw flag);
     29int nebLock(nebServer *server, char *key, rw flag);
    3030
    31 int idataUnlock(idataServer *server, char *key, rw flag);
     31int nebUnlock(nebServer *server, char *key, rw flag);
    3232
    33 int idataFindInstances(idataServer *server, char *key, char *volume, char ***locations);
     33int nebFindInstances(nebServer *server, char *key, char *volume, char ***locations);
    3434
    35 int idataFind(idataServer *server, char *key);
     35int nebFind(nebServer *server, char *key);
    3636
    37 int idataOpen(idataServer *server, char *key, rw flag);
     37int nebOpen(nebServer *server, char *key, rw flag);
    3838
    39 int idataDelete(idataServer *server, char *key);
     39int nebDelete(nebServer *server, char *key);
    4040
    41 int idataCopy(idataServer *server, char *key, char *newKey);
     41int nebCopy(nebServer *server, char *key, char *newKey);
    4242
    43 int idataMove(idataServer *server, char *key, char *newKey);
     43int nebMove(nebServer *server, char *key, char *newKey);
    4444
    45 int idataDelete_instance(idataServer *server, char *URI);
     45int nebDelete_instance(nebServer *server, char *URI);
    4646
    47 int idataStat(idataServer *server, char *key);
     47int nebStat(nebServer *server, char *key);
    4848
    49 int idataErr(idataServer *server, char *errString);
     49int nebErr(nebServer *server, char *errString);
    5050
    51 int idataParseURI(const char *URI, char **filename);
     51int nebParseURI(const char *URI, char **filename);
    5252
    53 void idataFree(void *ptr);
     53void nebFree(void *ptr);
    5454
    55 #endif // IDATACLIENT_H
     55#endif // NEBLIENT_H

  • trunk/Nebulous/nebclient/src/test.c

    r4120 r4440  
    11#include <stdio.h>
    22#include <unistd.h>
    3 #include "idataclient.h"
     3#include "nebclient.h"
    44
    55int main (int argc, char **argv) {
    6     idataServer     server;
     6    nebServer     server;
    77    char            *URI;
    88    int             fh;
    … …  
    1010    char            **foo;
    1111
    12     idataServerInit(&server);
     12    nebServerInit(&server);
    1313
    14     fh = idataCreate(&server, argv[1], 0, NULL, NULL, &URI);
     14    fh = nebCreate(&server, argv[1], 0, NULL, NULL, &URI);
    1515
    1616    if (fh > 0) {
    1717        printf( "uri is %s\n", URI );
    1818
    19         idataFree(URI);
     19        nebFree(URI);
    2020
    2121        if(close(fh) != 0){
    … …  
    2525        printf( "local error\n" );
    2626    } else {
    27         printf( "server error: %s\n", idataServerErr(&server) );
     27        printf( "server error: %s\n", nebServerErr(&server) );
    2828    }
    2929
    30     n = idataFindInstances(&server, argv[1], NULL, &foo);
     30    n = nebFindInstances(&server, argv[1], NULL, &foo);
    3131    printf( "found %d instances\n", n );
    3232
    33     idataServerCleanup(&server);
     33    nebServerCleanup(&server);
    3434
    3535    exit(0);

  • trunk/Nebulous/nebulous.wsdl

    r2785 r4440  
    11<?xml version="1.0"?>
    22
    3 <definitions name="idata" targetNamespace="http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server">
     3<definitions name="nebulous" targetNamespace="http://pan-starrs.ifa.hawaii.edu/Nebulous/Server">
    44
    55    <types>
    6         <schema targetNamespace="http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server"
     6        <schema targetNamespace="http://pan-starrs.ifa.hawaii.edu/Nebulous/Server"
    77            xmlns="http://www.w3.org/1999/XMLSchema">
    88
    … …  
    5353    </portType>
    5454
    55     <binding name="idataSoapBinding"
    56         type="es:GetidatarPortType">
     55    <binding name="nebulousSoapBinding"
     56        type="es:GetnebulousrPortType">
    5757
    5858        <soap:binding style="document"
    5959            transport="http://schemas.xmlsoap.org/soap/http"/>
    6060
    61         <operation name="Getidata">
     61        <operation name="Getnebulous">
    6262            <soap:operation
    6363                soapAction="http://www.snowboard-info.com/EndorsementSearch"/>

  • trunk/Nebulous/scripts/bench_test.pl

    r3014 r4440  
    77
    88use Benchmark qw( timethese );
    9 use PS::IPP::IData::Client;
     9use Nebulous::Client;
    1010
    11 my $idata = PS::IPP::IData::Client->new(
    12     proxy   => 'http://localhost:80/idata'
     11my $neb = Nebulous::Client->new(
     12    proxy   => 'http://localhost:80/nebulous'
    1313);
    1414
    … …  
    1818    {
    1919        'create/delete' => sub {
    20             my $fh = $idata->create( $key );
     20            my $fh = $neb->create( $key );
    2121            close $fh;
    22             $idata->delete( $key );
     22            $neb->delete( $key );
    2323        },
    2424    }

  • trunk/Nebulous/scripts/imageserver.pl

    r2785 r4440  
    88
    99use SOAP::Transport::HTTP;
    10 use PS::IPP::IData::Server;
     10use Nebulous::Server;
    1111   
    1212SOAP::Transport::HTTP::CGI
    13     -> dispatch_to( 'PS::IPP::IData::Server' )
     13    -> dispatch_to( 'Nebulous::Server' )
    1414    -> handle;

  • trunk/Nebulous/scripts/ptest.pl

    r2785 r4440  
    66use lib "./lib";
    77
    8 use PS::IPP::IData::Client;
     8use Nebulous::Client;
    99
    10 my $idata = PS::IPP::IData::Client->new(
    11     uri     => 'http://localhost:80/PS/IPP/IData/Server',
    12     proxy   => 'http://localhost:80/idata'
     10my $neb = Nebulous::Client->new(
     11    proxy   => 'http://localhost:80/nebulous'
    1312);
    1413
    … …  
    2221    unless ( $pid )  {
    2322        my $fname = "${key}_$id";
    24         my $fh = $idata->create( $fname );
     23        my $fh = $neb->create( $fname );
    2524        die "can't create file $fname" unless $fh;
    2625
    … …  
    2827
    2928        close $fh;
    30         $idata->unlock( $fname, 'write' );
     29        $neb->unlock( $fname, 'write' );
    3130
    32         $fh = $idata->open( $fname, 'read' ) or die "can't open file";
     31        $fh = $neb->open( $fname, 'read' ) or die "can't open file";
    3332        close $fh;
    34         $idata->unlock( $fname, 'read' );
     33        $neb->unlock( $fname, 'read' );
    3534
    36         $idata->replicate( $fname );
    37         $idata->cull( $fname );
    38         $idata->find( $fname );
    39         $idata->copy( $fname, $fname . "_copy" );
    40         $idata->move( $fname, $fname . "_move" );
    41         $idata->delete( $fname . "_copy" );
    42         $idata->delete( $fname . "_move" );
     35        $neb->replicate( $fname );
     36        $neb->cull( $fname );
     37        $neb->find( $fname );
     38        $neb->copy( $fname, $fname . "_copy" );
     39        $neb->move( $fname, $fname . "_move" );
     40        $neb->delete( $fname . "_copy" );
     41        $neb->delete( $fname . "_move" );
    4342
    4443        exit 0;

  • trunk/Nebulous/scripts/stest.pl

    r2785 r4440  
    66use lib "./lib";
    77
    8 use PS::IPP::IData::Client; # trace => 'debug';
     8use Nebulous::Client; # trace => 'debug';
    99
    10 my $idata = PS::IPP::IData::Client->new(
    11     proxy   => 'http://localhost:80/idata'
     10my $neb = Nebulous::Client->new(
     11    proxy   => 'http://localhost:80/nebulous'
    1212);
    1313
    1414my $fname = shift;
    1515
    16 #my $fh = $idata->create( $fname );
    17 #$idata->unlock( $fname, 'write' );
     16#my $fh = $neb->create( $fname );
     17#$neb->unlock( $fname, 'write' );
    1818
    19 $idata->create( $fname, 1 );
    20 $idata->unlock( $fname, 'write' );
    21 $idata->delete( $fname );
     19$neb->create( $fname, 1 );
     20$neb->unlock( $fname, 'write' );
     21$neb->delete( $fname );
    2222
    2323__END__
    … …  
    2828    print $fh "fooby\n";
    2929    close $fh;
    30     #$idata->unlock( $fname, 'write' );
     30    #$neb->unlock( $fname, 'write' );
    3131    my $filesize =  (stat( $key ))[7];
    3232    print "created file $key, ${filesize}bytes\n";

  • trunk/Nebulous/t/01_load.t

    r4436 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 01_load.t,v 1.6 2005-06-30 01:37:16 jhoblitt Exp $
     5# $Id: 01_load.t,v 1.7 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use Test::More tests => 8;
    1313
    14 BEGIN { use_ok( 'PS::IPP::IData::Client' ); }
    15 BEGIN { use_ok( 'PS::IPP::IData::Client::Log' ); }
    16 BEGIN { use_ok( 'PS::IPP::IData::Client::HTTP' ); }
    17 BEGIN { use_ok( 'PS::IPP::IData::Util' ); }
    18 BEGIN { use_ok( 'PS::IPP::IData::Server' ); }
    19 BEGIN { use_ok( 'PS::IPP::IData::Server::SQL' ); }
    20 BEGIN { use_ok( 'PS::IPP::IData::Server::Log' ); }
    21 BEGIN { use_ok( 'PS::IPP::IData::Server::SOAP' ); }
     14BEGIN { use_ok( 'Nebulous::Client' ); }
     15BEGIN { use_ok( 'Nebulous::Client::Log' ); }
     16BEGIN { use_ok( 'Nebulous::Client::HTTP' ); }
     17BEGIN { use_ok( 'Nebulous::Util' ); }
     18BEGIN { use_ok( 'Nebulous::Server' ); }
     19BEGIN { use_ok( 'Nebulous::Server::SQL' ); }
     20BEGIN { use_ok( 'Nebulous::Server::Log' ); }
     21BEGIN { use_ok( 'Nebulous::Server::SOAP' ); }

  • trunk/Nebulous/t/02_server_setup.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 02_server_setup.t,v 1.2 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 02_server_setup.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use Test::IData;
     14use Nebulous::Server;
     15use Test::Nebulous;
    1616
    17 Test::IData->setup;
     17Test::Nebulous->setup;
    1818
    1919ok(
    20     PS::IPP::IData::Server->setup(
     20    Nebulous::Server->setup(
    2121        "DBI:mysql:database=test:host=localhost",
    2222        "test",
    … …  
    2626);
    2727
    28 Test::IData->setup;
     28Test::Nebulous->setup;
    2929
    3030eval {
    31     PS::IPP::IData::Server->setup(
     31    Nebulous::Server->setup(
    3232        "DBI:mysql:database=foobar:host=localhost",
    3333        "baz",
    … …  
    3737like( $@, qr/DBI connect.*? failed/, "bad dsn/user/pass" );
    3838
    39 Test::IData->cleanup;
     39Test::Nebulous->cleanup;

  • trunk/Nebulous/t/03_server_create_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 03_server_create_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 03_server_create_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     my $uri = $idata->create_object( "foo" );
     30    my $uri = $neb->create_object( "foo" );
    3131
    3232    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    3939    # key, class
    40     my $uri = $idata->create_object( "foo", 0 );
     40    my $uri = $neb->create_object( "foo", 0 );
    4141
    4242    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4444}
    4545
    46 Test::IData->setup;
     46Test::Nebulous->setup;
    4747
    4848{
    4949    # key, class, volume
    50     my $uri = $idata->create_object( "foo", 0, "node01" );
     50    my $uri = $neb->create_object( "foo", 0, "node01" );
    5151
    5252    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    5959    # key, class, volume, comment
    60     my $uri = $idata->create_object( "foo", 0, "node01", "this is foo" );
     60    my $uri = $neb->create_object( "foo", 0, "node01", "this is foo" );
    6161
    6262    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    6464}
    6565
    66 Test::IData->setup;
     66Test::Nebulous->setup;
    6767
    6868eval {
    69     $idata->create_object( "foo" );
    70     $idata->create_object( "foo" );
     69    $neb->create_object( "foo" );
     70    $neb->create_object( "foo" );
    7171};
    7272like( $@, qr/Duplicate entry/, "object already exists" );
    7373
    74 Test::IData->setup;
     74Test::Nebulous->setup;
    7575
    7676eval {
    77     $idata->create_object();
     77    $neb->create_object();
    7878};
    7979like( $@, qr/2 - 4 were expected/, "no params" );
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     $idata->create_object( 1, 2, 3, 4, 5 );
     84    $neb->create_object( 1, 2, 3, 4, 5 );
    8585};
    8686like( $@, qr/2 - 4 were expected/, "too many params" );
    8787
    88 Test::IData->cleanup;
     88Test::Nebulous->cleanup;

  • trunk/Nebulous/t/04_server_replicate_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 04_server_replicate_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 04_server_replicate_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     $idata->create_object( "foo" );
    31     my $uri = $idata->replicate_object( "foo" );
     30    $neb->create_object( "foo" );
     31    my $uri = $neb->replicate_object( "foo" );
    3232
    3333    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key, $volume
    41     $idata->create_object( "foo" );
    42     my $uri = $idata->replicate_object( "foo", "node01" );
     41    $neb->create_object( "foo" );
     42    my $uri = $neb->replicate_object( "foo", "node01" );
    4343
    4444    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    5151    # key, $volume
    52     $idata->create_object( "foo" );
    53     my $uri1 = $idata->replicate_object( "foo", "node01" );
    54     my $uri2 = $idata->replicate_object( "foo", "node02" );
     52    $neb->create_object( "foo" );
     53    my $uri1 = $neb->replicate_object( "foo", "node01" );
     54    my $uri2 = $neb->replicate_object( "foo", "node02" );
    5555
    5656    ok( -e _get_file_path( $uri1 ), "file exists" );
    … …  
    6060}
    6161
    62 Test::IData->setup;
     62Test::Nebulous->setup;
    6363
    6464eval {
    65     $idata->replicate_object( "foo" );
     65    $neb->replicate_object( "foo" );
    6666};
    6767like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6868
    69 Test::IData->setup;
     69Test::Nebulous->setup;
    7070
    7171eval {
    72     $idata->replicate_object();
     72    $neb->replicate_object();
    7373};
    7474like( $@, qr/1 - 2 were expected/, "no params" );
    7575
    76 Test::IData->setup;
     76Test::Nebulous->setup;
    7777
    7878eval {
    79     $idata->replicate_object( 1, 2, 3 );
     79    $neb->replicate_object( 1, 2, 3 );
    8080};
    8181like( $@, qr/1 - 2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous/t/05_server_lock_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 05_server_lock_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 05_server_lock_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     $idata->create_object( "foo" );
     29    $neb->create_object( "foo" );
    3030
    31     ok( $idata->lock_object( "foo", "read" ), "read lock" );
     31    ok( $neb->lock_object( "foo", "read" ), "read lock" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     $idata->create_object( "foo" );
     37    $neb->create_object( "foo" );
    3838
    39     ok( $idata->lock_object( "foo", "read" ), "read lock" );
    40     ok( $idata->lock_object( "foo", "read" ), "read lock" );
     39    ok( $neb->lock_object( "foo", "read" ), "read lock" );
     40    ok( $neb->lock_object( "foo", "read" ), "read lock" );
    4141}
    4242
    43 Test::IData->setup;
     43Test::Nebulous->setup;
    4444
    4545{
    46     $idata->create_object( "foo" );
     46    $neb->create_object( "foo" );
    4747
    48     ok( $idata->lock_object( "foo", "write" ), "write lock" );
     48    ok( $neb->lock_object( "foo", "write" ), "write lock" );
    4949}
    5050
    51 Test::IData->setup;
     51Test::Nebulous->setup;
    5252
    5353eval {
    54     $idata->lock_object( "foo", "read" );
     54    $neb->lock_object( "foo", "read" );
    5555};
    5656like( $@, qr/storage object does not exist/, "storage object does not exist" );
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060eval {
    61     $idata->lock_object( "foo", "write" );
     61    $neb->lock_object( "foo", "write" );
    6262};
    6363like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6464
    65 Test::IData->setup;
     65Test::Nebulous->setup;
    6666
    6767eval {
    68     $idata->create_object( "foo" );
     68    $neb->create_object( "foo" );
    6969
    70     $idata->lock_object( "foo", "write" );
    71     $idata->lock_object( "foo", "write" );
     70    $neb->lock_object( "foo", "write" );
     71    $neb->lock_object( "foo", "write" );
    7272};
    7373like( $@, qr/can not write lock twice/, "can not write lock twice" );
    7474
    75 Test::IData->setup;
     75Test::Nebulous->setup;
    7676
    7777eval {
    78     $idata->create_object( "foo" );
     78    $neb->create_object( "foo" );
    7979
    80     $idata->lock_object( "foo", "read" );
    81     $idata->lock_object( "foo", "write" );
     80    $neb->lock_object( "foo", "read" );
     81    $neb->lock_object( "foo", "write" );
    8282};
    8383like( $@, qr/can not write lock after read lock/, "can not write lock after read lock" );
    8484
    85 Test::IData->setup;
     85Test::Nebulous->setup;
    8686
    8787eval {
    88     $idata->create_object( "foo" );
     88    $neb->create_object( "foo" );
    8989
    90     $idata->lock_object( "foo", "write" );
    91     $idata->lock_object( "foo", "read" );
     90    $neb->lock_object( "foo", "write" );
     91    $neb->lock_object( "foo", "read" );
    9292};
    9393like( $@, qr/can not read lock after write lock/, "can not read lock after write lock" );
    9494
    95 Test::IData->setup;
     95Test::Nebulous->setup;
    9696
    9797eval {
    98     $idata->lock_object();
     98    $neb->lock_object();
    9999};
    100100like( $@, qr/2 were expected/, "no params" );
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104eval {
    105     $idata->lock_object( "foo" );
     105    $neb->lock_object( "foo" );
    106106};
    107107like( $@, qr/2 were expected/, "not enough params" );
    108108
    109 Test::IData->setup;
     109Test::Nebulous->setup;
    110110
    111111eval {
    112     $idata->lock_object( "foo", "both" );
     112    $neb->lock_object( "foo", "both" );
    113113};
    114114like( $@, qr/is read or write/, "not read or write" );
    115115
    116 Test::IData->setup;
     116Test::Nebulous->setup;
    117117
    118118eval {
    119     $idata->lock_object( "foo", 'read', 3 );
     119    $neb->lock_object( "foo", 'read', 3 );
    120120};
    121121like( $@, qr/2 were expected/, "too many params" );
    122122
    123 Test::IData->cleanup;
     123Test::Nebulous->cleanup;

  • trunk/Nebulous/t/06_server_unlock_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 06_server_unlock_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 06_server_unlock_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     $idata->create_object( "foo" );
     29    $neb->create_object( "foo" );
    3030
    31     $idata->lock_object( "foo", "read" );
     31    $neb->lock_object( "foo", "read" );
    3232
    33     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
     33    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     $idata->create_object( "foo" );
     39    $neb->create_object( "foo" );
    4040
    41     $idata->lock_object( "foo", "read" );
    42     $idata->lock_object( "foo", "read" );
     41    $neb->lock_object( "foo", "read" );
     42    $neb->lock_object( "foo", "read" );
    4343
    44     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
    45     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
     44    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
     45    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     $idata->create_object( "foo" );
     51    $neb->create_object( "foo" );
    5252
    53     $idata->lock_object( "foo", "write" );
     53    $neb->lock_object( "foo", "write" );
    5454
    55     ok( $idata->unlock_object( "foo", "write" ), "write unlock" );
     55    ok( $neb->unlock_object( "foo", "write" ), "write unlock" );
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060eval {
    61     $idata->unlock_object( "foo", "read" );
     61    $neb->unlock_object( "foo", "read" );
    6262};
    6363like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6464
    65 Test::IData->setup;
     65Test::Nebulous->setup;
    6666
    6767eval {
    68     $idata->unlock_object( "foo", "write" );
     68    $neb->unlock_object( "foo", "write" );
    6969};
    7070like( $@, qr/storage object does not exist/, "storage object does not exist" );
    7171
    72 Test::IData->setup;
     72Test::Nebulous->setup;
    7373
    7474eval {
    75     $idata->create_object( "foo" );
     75    $neb->create_object( "foo" );
    7676
    77     $idata->unlock_object( "foo", "read" );
     77    $neb->unlock_object( "foo", "read" );
    7878};
    7979like( $@, qr/can not remove non-existant read lock/, "no lock set" );
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     $idata->create_object( "foo" );
     84    $neb->create_object( "foo" );
    8585
    86     $idata->unlock_object( "foo", "write" );
     86    $neb->unlock_object( "foo", "write" );
    8787};
    8888like( $@, qr/can not remove non-existant write lock/, "no lock set" );
    8989
    90 Test::IData->setup;
     90Test::Nebulous->setup;
    9191
    9292eval {
    93     $idata->create_object( "foo" );
    94     $idata->lock_object( "foo", "write" );
     93    $neb->create_object( "foo" );
     94    $neb->lock_object( "foo", "write" );
    9595
    96     $idata->unlock_object( "foo", "read" );
     96    $neb->unlock_object( "foo", "read" );
    9797};
    9898like( $@, qr/can not have a read lock under a write lock/, "read unlock under write lock" );
    9999
    100 Test::IData->setup;
     100Test::Nebulous->setup;
    101101
    102102eval {
    103     $idata->create_object( "foo" );
    104     $idata->lock_object( "foo", "read" );
     103    $neb->create_object( "foo" );
     104    $neb->lock_object( "foo", "read" );
    105105
    106     $idata->unlock_object( "foo", "write" );
     106    $neb->unlock_object( "foo", "write" );
    107107};
    108108like( $@, qr/can not have a write lock under a read lock/, "write unlock under read lock" );
    109109
    110 Test::IData->setup;
     110Test::Nebulous->setup;
    111111
    112112eval {
    113     $idata->unlock_object();
     113    $neb->unlock_object();
    114114};
    115115like( $@, qr/2 were expected/, "no params" );
    116116
    117 Test::IData->setup;
     117Test::Nebulous->setup;
    118118
    119119eval {
    120     $idata->unlock_object( "foo" );
     120    $neb->unlock_object( "foo" );
    121121};
    122122like( $@, qr/2 were expected/, "not enough params" );
    123123
    124 Test::IData->setup;
     124Test::Nebulous->setup;
    125125
    126126eval {
    127     $idata->unlock_object( "foo", "both" );
     127    $neb->unlock_object( "foo", "both" );
    128128};
    129129like( $@, qr/is read or write/, "not read or write" );
    130130
    131 Test::IData->setup;
     131Test::Nebulous->setup;
    132132
    133133eval {
    134     $idata->unlock_object( "foo", 'read', 3 );
     134    $neb->unlock_object( "foo", 'read', 3 );
    135135};
    136136like( $@, qr/2 were expected/, "too many params" );
    137137
    138 Test::IData->cleanup;
     138Test::Nebulous->cleanup;

  • trunk/Nebulous/t/07_server_find_instances.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 07_server_find_instances.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 07_server_find_instances.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     my $uri = $idata->create_object( "foo" );
     30    my $uri = $neb->create_object( "foo" );
    3131
    32     my $locations = $idata->find_instances( "foo" );
     32    my $locations = $neb->find_instances( "foo" );
    3333
    3434    is( $uri, $locations->[0], "URIs match" );
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key
    41     my $uri1 = $idata->create_object( "foo" );
    42     my $uri2 = $idata->replicate_object( "foo" );
     41    my $uri1 = $neb->create_object( "foo" );
     42    my $uri2 = $neb->replicate_object( "foo" );
    4343
    44     my $locations = $idata->find_instances( "foo" );
     44    my $locations = $neb->find_instances( "foo" );
    4545
    4646    ok( eq_set( [$uri1, $uri2], $locations ), "URIs match" );
    4747}
    4848
    49 Test::IData->setup;
     49Test::Nebulous->setup;
    5050
    5151{
    5252    # key, volume
    53     my $uri = $idata->create_object( "foo" );
     53    my $uri = $neb->create_object( "foo" );
    5454
    55     my $locations = $idata->find_instances( "foo", "node01" );
     55    my $locations = $neb->find_instances( "foo", "node01" );
    5656
    5757    is( $uri, $locations->[0], "URIs match" );
    5858}
    5959
    60 Test::IData->setup;
     60Test::Nebulous->setup;
    6161
    6262{
    6363    # key
    64     my $uri1 = $idata->create_object( "foo" );
    65     my $uri2 = $idata->replicate_object( "foo" );
     64    my $uri1 = $neb->create_object( "foo" );
     65    my $uri2 = $neb->replicate_object( "foo" );
    6666
    67     my $locations = $idata->find_instances( "foo", "node01" );
     67    my $locations = $neb->find_instances( "foo", "node01" );
    6868
    6969    ok( eq_set( [$uri1, $uri2], $locations ), "URIs match" );
    … …  
    7171
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     $idata->find_instances( "foo" );
     76    $neb->find_instances( "foo" );
    7777};
    7878like( $@, qr/no instances found/, "storage object does not exist" );
    7979
    80 Test::IData->setup;
     80Test::Nebulous->setup;
    8181
    8282eval {
    83     $idata->find_instances();
     83    $neb->find_instances();
    8484};
    8585like( $@, qr/1 - 2 were expected/, "no params" );
    8686
    87 Test::IData->setup;
     87Test::Nebulous->setup;
    8888
    8989eval {
    90     $idata->find_instances( "foo", 'read', 3 );
     90    $neb->find_instances( "foo", 'read', 3 );
    9191};
    9292like( $@, qr/1 - 2 were expected/, "too many params" );
    9393
    94 Test::IData->cleanup;
     94Test::Nebulous->cleanup;

  • trunk/Nebulous/t/08_server_delete_instance.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 08_server_delete_instance.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 08_server_delete_instance.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     my $uri = $idata->create_object( "foo" );
     29    my $uri = $neb->create_object( "foo" );
    3030
    31     ok( $idata->delete_instance( $uri ), "delete instance" );
     31    ok( $neb->delete_instance( $uri ), "delete instance" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     my $uri1 = $idata->create_object( "foo" );
    38     my $uri2 = $idata->replicate_object( "foo" );
     37    my $uri1 = $neb->create_object( "foo" );
     38    my $uri2 = $neb->replicate_object( "foo" );
    3939
    40     ok( $idata->delete_instance( $uri1 ), "delete instance" );
     40    ok( $neb->delete_instance( $uri1 ), "delete instance" );
    4141
    42     my $locations = $idata->find_instances( "foo" );
     42    my $locations = $neb->find_instances( "foo" );
    4343
    4444    is( $locations->[0], $uri2, "instance remains" );
    4545
    46     ok( $idata->delete_instance( $uri2 ), "delete instance" );
     46    ok( $neb->delete_instance( $uri2 ), "delete instance" );
    4747
    4848    eval {
    49         $idata->find_instances( "foo" );
     49        $neb->find_instances( "foo" );
    5050    };
    5151    like( $@, qr/no instances found/, "storage object was deleted" );
    5252}
    5353
    54 Test::IData->setup;
     54Test::Nebulous->setup;
    5555
    5656eval {
    57     $idata->delete_instance( "file:/foo" );
     57    $neb->delete_instance( "file:/foo" );
    5858};
    5959like( $@, qr/no instance is associated with uri/, "uri does not exist" );
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363eval {
    64     $idata->delete_instance();
     64    $neb->delete_instance();
    6565};
    6666like( $@, qr/1 was expected/, "no params" );
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     $idata->delete_instance( "foo", 2 );
     71    $neb->delete_instance( "foo", 2 );
    7272};
    7373like( $@, qr/1 was expected/, "too many params" );
    7474
    75 Test::IData->cleanup;
     75Test::Nebulous->cleanup;

  • trunk/Nebulous/t/09_server_stat_object.t

    r3016 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 09_server_stat_object.t,v 1.4 2005-01-15 04:02:12 jhoblitt Exp $
     5# $Id: 09_server_stat_object.t,v 1.5 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     my $uri = $idata->create_object( "foo" );
     29    my $uri = $neb->create_object( "foo" );
    3030
    31     my $info = $idata->stat_object( "foo" );
     31    my $info = $neb->stat_object( "foo" );
    3232
    3333    is( scalar @$info, 8, "number of columns" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     my $uri = $idata->create_object( "foo", 9, "node01", "foobar" );
     39    my $uri = $neb->create_object( "foo", 9, "node01", "foobar" );
    4040
    41     my $info = $idata->stat_object( "foo" );
     41    my $info = $neb->stat_object( "foo" );
    4242
    4343    is( scalar @$info, 8,                       "number of columns" );
    … …  
    5252}
    5353
    54 Test::IData->setup;
     54Test::Nebulous->setup;
    5555
    5656eval {
    57     $idata->stat_object( "foo" );
     57    $neb->stat_object( "foo" );
    5858};
    5959like( $@, qr/no storage object found/, "object does not exist" );
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363eval {
    64     $idata->stat_object();
     64    $neb->stat_object();
    6565};
    6666like( $@, qr/1 was expected/, "no params" );
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     $idata->stat_object( "foo", 2 );
     71    $neb->stat_object( "foo", 2 );
    7272};
    7373like( $@, qr/1 was expected/, "too many params" );
    7474
    75 Test::IData->cleanup;
     75Test::Nebulous->cleanup;

  • trunk/Nebulous/t/10_client_new.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 10_client_new.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 10_client_new.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    2828
    29     isa_ok( $idata, "PS::IPP::IData::Client" );
     29    isa_ok( $neb, "Nebulous::Client" );
    3030}
    3131
    32 Test::IData->setup;
     32Test::Nebulous->setup;
    3333
    3434{
    35     my $idata = PS::IPP::IData::Client->new(
    36         proxy => "http://$hostport/idata",
    37         uri   => "http://example.com/PS/IPP/IData/Client",
     35    my $neb = Nebulous::Client->new(
     36        proxy => "http://$hostport/nebulous",
     37        uri   => "http://example.com/PS/IPP/Nebulous/Client",
    3838    );
    3939
    40     isa_ok( $idata, "PS::IPP::IData::Client" );
     40    isa_ok( $neb, "Nebulous::Client" );
    4141}
    4242
    43 Test::IData->setup;
     43Test::Nebulous->setup;
    4444
    4545eval {
    46     PS::IPP::IData::Client->new;
     46    Nebulous::Client->new;
    4747};
    4848like( $@, qr/Mandatory parameter/, "no proxy" );
    4949
    50 Test::IData->setup;
     50Test::Nebulous->setup;
    5151
    5252eval {
    53     PS::IPP::IData::Client->new(
     53    Nebulous::Client->new(
    5454        proxy => "foo",
    5555        dog => "do"
    … …  
    5858like( $@, qr/not listed in the validation options/, "bad param" );
    5959
    60 Test::IData->cleanup;
     60Test::Nebulous->cleanup;

  • trunk/Nebulous/t/11_client_create.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 11_client_create.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 11_client_create.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    2929
    30     my $fh = $idata->create( "foo" );
     30    my $fh = $neb->create( "foo" );
    3131
    3232    is( ref $fh, 'GLOB', "good filehandle" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key, class
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    4242
    43     my $fh = $idata->create( "foo", 0 );
     43    my $fh = $neb->create( "foo", 0 );
    4444
    4545    is( ref $fh, 'GLOB', "good filehandle" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    5151    # key, class, volume
    52     my $idata = PS::IPP::IData::Client->new(
    53         proxy => "http://$hostport/idata",
     52    my $neb = Nebulous::Client->new(
     53        proxy => "http://$hostport/nebulous",
    5454    );
    5555
    56     my $fh = $idata->create( "foo", 0, "node01" );
     56    my $fh = $neb->create( "foo", 0, "node01" );
    5757
    5858    is( ref $fh, 'GLOB', "good filehandle" );
    5959}
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363{
    6464    # key, class, volume, comment
    65     my $idata = PS::IPP::IData::Client->new(
    66         proxy => "http://$hostport/idata",
     65    my $neb = Nebulous::Client->new(
     66        proxy => "http://$hostport/nebulous",
    6767    );
    6868
    69     my $fh = $idata->create( "foo", 0, "node01", "this is foo" );
     69    my $fh = $neb->create( "foo", 0, "node01", "this is foo" );
    7070
    7171    is( ref $fh, 'GLOB', "good filehandle" );
    7272}
    7373
    74 Test::IData->setup;
     74Test::Nebulous->setup;
    7575
    7676{
    77     my $idata = PS::IPP::IData::Client->new(
    78         proxy => "http://$hostport/idata",
     77    my $neb = Nebulous::Client->new(
     78        proxy => "http://$hostport/nebulous",
    7979    );
    8080
    81     $idata->create( "foo" );
    82     is( $idata->create( "foo" ), undef, "object already exists" );
     81    $neb->create( "foo" );
     82    is( $neb->create( "foo" ), undef, "object already exists" );
    8383}
    8484
    85 Test::IData->setup;
     85Test::Nebulous->setup;
    8686
    8787eval {
    88     my $idata = PS::IPP::IData::Client->new(
    89         proxy => "http://$hostport/idata",
     88    my $neb = Nebulous::Client->new(
     89        proxy => "http://$hostport/nebulous",
    9090    );
    9191
    92     $idata->create();
     92    $neb->create();
    9393};
    9494like( $@, qr/2 - 4 were expected/, "no params" );
    9595
    96 Test::IData->setup;
     96Test::Nebulous->setup;
    9797
    9898eval {
    99     my $idata = PS::IPP::IData::Client->new(
    100         proxy => "http://$hostport/idata",
     99    my $neb = Nebulous::Client->new(
     100        proxy => "http://$hostport/nebulous",
    101101    );
    102102
    103     $idata->create( 1, 2, 3, 4, 5 );
     103    $neb->create( 1, 2, 3, 4, 5 );
    104104};
    105105like( $@, qr/2 - 4 were expected/, "too many params" );
    106106
    107 Test::IData->cleanup;
     107Test::Nebulous->cleanup;

  • trunk/Nebulous/t/12_client_replicate.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 12_client_replicate.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 12_client_replicate.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
     29    $neb->create( "foo" );
    3030
    31     my $uri = $idata->replicate( "foo" );
     31    my $uri = $neb->replicate( "foo" );
    3232
    3333    ok( $uri, "good replication" );
    … …  
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key, $volume
    41     my $idata = PS::IPP::IData::Client->new(
    42         proxy => "http://$hostport/idata",
     41    my $neb = Nebulous::Client->new(
     42        proxy => "http://$hostport/nebulous",
    4343    );
    44     $idata->create( "foo" );
     44    $neb->create( "foo" );
    4545
    46     my $uri = $idata->replicate( "foo", "node01" );
     46    my $uri = $neb->replicate( "foo", "node01" );
    4747
    4848    ok( $uri, "good replication" );
    … …  
    5050}
    5151
    52 Test::IData->setup;
     52Test::Nebulous->setup;
    5353
    5454{
    5555    # key, $volume
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->create( "foo" );
     59    $neb->create( "foo" );
    6060
    61     my $uri1 = $idata->replicate( "foo", "node01" );
    62     my $uri2 = $idata->replicate( "foo", "node02" );
     61    my $uri1 = $neb->replicate( "foo", "node01" );
     62    my $uri2 = $neb->replicate( "foo", "node02" );
    6363
    6464    ok( $uri1, "good replication" );
    … …  
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $idata = PS::IPP::IData::Client->new(
    74         proxy => "http://$hostport/idata",
     73    my $neb = Nebulous::Client->new(
     74        proxy => "http://$hostport/nebulous",
    7575    );
    76     my $uri = $idata->replicate( "foo" );
     76    my $uri = $neb->replicate( "foo" );
    7777
    7878    is( $uri, undef, "storage object does not exist" );
    7979}
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     my $idata = PS::IPP::IData::Client->new(
    85         proxy => "http://$hostport/idata",
     84    my $neb = Nebulous::Client->new(
     85        proxy => "http://$hostport/nebulous",
    8686    );
    87     $idata->replicate();
     87    $neb->replicate();
    8888};
    8989like( $@, qr/1 - 2 were expected/, "no params" );
    9090
    91 Test::IData->setup;
     91Test::Nebulous->setup;
    9292
    9393eval {
    94     my $idata = PS::IPP::IData::Client->new(
    95         proxy => "http://$hostport/idata",
     94    my $neb = Nebulous::Client->new(
     95        proxy => "http://$hostport/nebulous",
    9696    );
    97     $idata->replicate( 1, 2, 3 );
     97    $neb->replicate( 1, 2, 3 );
    9898};
    9999like( $@, qr/1 - 2 were expected/, "too many params" );
    100100
    101 Test::IData->cleanup;
     101Test::Nebulous->cleanup;

  • trunk/Nebulous/t/13_client_cull.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 13_client_cull.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 13_client_cull.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
    30     $idata->replicate( "foo" );
     29    $neb->create( "foo" );
     30    $neb->replicate( "foo" );
    3131
    32     my $uri = $idata->cull( "foo" );
     32    my $uri = $neb->cull( "foo" );
    3333
    3434    ok( $uri, "good cull" );
    … …  
    3636}
    3737
    38 Test::IData->setup;
     38Test::Nebulous->setup;
    3939
    4040SKIP: {
    … …  
    4242
    4343    # key, $volume
    44     my $idata = PS::IPP::IData::Client->new(
    45         proxy => "http://$hostport/idata",
     44    my $neb = Nebulous::Client->new(
     45        proxy => "http://$hostport/nebulous",
    4646    );
    47     $idata->create( "foo" );
    48     $idata->replicate( "foo", "node01" );
     47    $neb->create( "foo" );
     48    $neb->replicate( "foo", "node01" );
    4949
    50     my $uri = $idata->cull( "foo", "node01" );
     50    my $uri = $neb->cull( "foo", "node01" );
    5151
    5252    ok( $uri, "good cull" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    5959    # key
    60     my $idata = PS::IPP::IData::Client->new(
    61         proxy => "http://$hostport/idata",
     60    my $neb = Nebulous::Client->new(
     61        proxy => "http://$hostport/nebulous",
    6262    );
    63     $idata->create( "foo" );
     63    $neb->create( "foo" );
    6464
    65     $idata->replicate( "foo", "node01" );
    66     $idata->replicate( "foo", "node02" );
     65    $neb->replicate( "foo", "node01" );
     66    $neb->replicate( "foo", "node02" );
    6767
    68     my $uri1 = $idata->cull( "foo" );
    69     my $uri2 = $idata->cull( "foo" );
     68    my $uri1 = $neb->cull( "foo" );
     69    my $uri2 = $neb->cull( "foo" );
    7070
    7171    ok( $uri1, "good cull" );
    … …  
    7575}
    7676
    77 Test::IData->setup;
     77Test::Nebulous->setup;
    7878
    7979SKIP: {
    … …  
    8181
    8282    # key, $volume
    83     my $idata = PS::IPP::IData::Client->new(
    84         proxy => "http://$hostport/idata",
     83    my $neb = Nebulous::Client->new(
     84        proxy => "http://$hostport/nebulous",
    8585    );
    86     $idata->create( "foo" );
     86    $neb->create( "foo" );
    8787
    88     $idata->replicate( "foo", "node01" );
    89     $idata->replicate( "foo", "node02" );
     88    $neb->replicate( "foo", "node01" );
     89    $neb->replicate( "foo", "node02" );
    9090
    91     my $uri1 = $idata->cull( "foo", "node01" );
    92     my $uri2 = $idata->cull( "foo", "node02" );
     91    my $uri1 = $neb->cull( "foo", "node01" );
     92    my $uri2 = $neb->cull( "foo", "node02" );
    9393
    9494    ok( $uri1, "good cull" );
    … …  
    9898}
    9999
    100 Test::IData->setup;
     100Test::Nebulous->setup;
    101101
    102102{
    103     my $idata = PS::IPP::IData::Client->new(
    104         proxy => "http://$hostport/idata",
     103    my $neb = Nebulous::Client->new(
     104        proxy => "http://$hostport/nebulous",
    105105    );
    106     my $uri = $idata->cull( "foo" );
     106    my $uri = $neb->cull( "foo" );
    107107
    108108    is( $uri, undef, "storage object does not exist" );
    109109}
    110110
    111 Test::IData->setup;
     111Test::Nebulous->setup;
    112112
    113113eval {
    114     my $idata = PS::IPP::IData::Client->new(
    115         proxy => "http://$hostport/idata",
     114    my $neb = Nebulous::Client->new(
     115        proxy => "http://$hostport/nebulous",
    116116    );
    117     $idata->cull();
     117    $neb->cull();
    118118};
    119119like( $@, qr/1 was expected/, "no params" );
    120120
    121 Test::IData->setup;
     121Test::Nebulous->setup;
    122122
    123123eval {
    124     my $idata = PS::IPP::IData::Client->new(
    125         proxy => "http://$hostport/idata",
     124    my $neb = Nebulous::Client->new(
     125        proxy => "http://$hostport/nebulous",
    126126    );
    127     $idata->cull( 1, 2 );
     127    $neb->cull( 1, 2 );
    128128};
    129129like( $@, qr/1 was expected/, "too many params" );
    130130
    131 Test::IData->cleanup;
     131Test::Nebulous->cleanup;

  • trunk/Nebulous/t/14_client_lock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 14_client_lock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 14_client_lock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key, type
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
    28     );
    29     $idata->create( "foo" );
    30 
    31     ok( $idata->lock( "foo", "read" ), "read lock" );
    32 }
    33 
    34 Test::IData->setup;
    35 
    36 {
    37     # key, type, timeout
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
    40     );
    41     $idata->create( "foo" );
    42 
    43     ok( $idata->lock( "foo", "read", 10 ), "read lock" );
    44 }
    45 
    46 Test::IData->setup;
    47 
    48 {
    49     my $idata = PS::IPP::IData::Client->new(
    50         proxy => "http://$hostport/idata",
    51     );
    52     $idata->create( "foo" );
    53 
    54     ok( $idata->lock( "foo", "read" ), "read lock" );
    55     ok( $idata->lock( "foo", "read" ), "read lock" );
    56 }
    57 
    58 Test::IData->setup;
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
     28    );
     29    $neb->create( "foo" );
     30
     31    ok( $neb->lock( "foo", "read" ), "read lock" );
     32}
     33
     34Test::Nebulous->setup;
     35
     36{
     37    # key, type, timeout
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
     40    );
     41    $neb->create( "foo" );
     42
     43    ok( $neb->lock( "foo", "read", 10 ), "read lock" );
     44}
     45
     46Test::Nebulous->setup;
     47
     48{
     49    my $neb = Nebulous::Client->new(
     50        proxy => "http://$hostport/nebulous",
     51    );
     52    $neb->create( "foo" );
     53
     54    ok( $neb->lock( "foo", "read" ), "read lock" );
     55    ok( $neb->lock( "foo", "read" ), "read lock" );
     56}
     57
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, type
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
    64     );
    65     $idata->create( "foo" );
    66 
    67     ok( $idata->lock( "foo", "write" ), "write lock" );
    68 }
    69 
    70 Test::IData->setup;
    71 
    72 {
    73     # key, type, timeout
    74     my $idata = PS::IPP::IData::Client->new(
    75         proxy => "http://$hostport/idata",
    76     );
    77     $idata->create( "foo" );
    78 
    79     ok( $idata->lock( "foo", "write", 10 ), "write lock" );
    80 }
    81 
    82 Test::IData->setup;
    83 
    84 {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
    87     );
    88 
    89     is( $idata->lock( "foo", "read" ), undef, "storage object does not exist" );
    90 }
    91 
    92 Test::IData->setup;
    93 
    94 {
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
    97     );
    98 
    99     is( $idata->lock( "foo", "write" ), undef, "storage object does not exist" );
    100 }
    101 
    102 Test::IData->setup;
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
     64    );
     65    $neb->create( "foo" );
     66
     67    ok( $neb->lock( "foo", "write" ), "write lock" );
     68}
     69
     70Test::Nebulous->setup;
     71
     72{
     73    # key, type, timeout
     74    my $neb = Nebulous::Client->new(
     75        proxy => "http://$hostport/nebulous",
     76    );
     77    $neb->create( "foo" );
     78
     79    ok( $neb->lock( "foo", "write", 10 ), "write lock" );
     80}
     81
     82Test::Nebulous->setup;
     83
     84{
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
     87    );
     88
     89    is( $neb->lock( "foo", "read" ), undef, "storage object does not exist" );
     90}
     91
     92Test::Nebulous->setup;
     93
     94{
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
     97    );
     98
     99    is( $neb->lock( "foo", "write" ), undef, "storage object does not exist" );
     100}
     101
     102Test::Nebulous->setup;
    103103
    104104diag "testing a spinlock, this will be a litle slow...";
    … …  
    109109
    110110    # key, type, timeout
    111     my $idata = PS::IPP::IData::Client->new(
    112         proxy => "http://$hostport/idata",
    113     );
    114     $idata->create( "foo" );
    115 
    116     $idata->lock( "foo", "read" );
    117     $idata->lock( "foo", "write" );
     111    my $neb = Nebulous::Client->new(
     112        proxy => "http://$hostport/nebulous",
     113    );
     114    $neb->create( "foo" );
     115
     116    $neb->lock( "foo", "read" );
     117    $neb->lock( "foo", "write" );
    118118
    119119    alarm 0;
    … …  
    121121like( $@, qr/timeout/, "default spinlock" );
    122122
    123 Test::IData->setup;
     123Test::Nebulous->setup;
    124124
    125125diag "testing a spinlock, this will be a litle slow...";
    … …  
    130130
    131131    # key, type, timeout
    132     my $idata = PS::IPP::IData::Client->new(
    133         proxy => "http://$hostport/idata",
    134     );
    135     $idata->create( "foo" );
    136 
    137     $idata->lock( "foo", "read" );
    138     unless ( $idata->lock( "foo", "write" ) ) {
     132    my $neb = Nebulous::Client->new(
     133        proxy => "http://$hostport/nebulous",
     134    );
     135    $neb->create( "foo" );
     136
     137    $neb->lock( "foo", "read" );
     138    unless ( $neb->lock( "foo", "write" ) ) {
    139139        alarm 0;
    140140        die "gaveup";
    … …  
    145145like( $@, qr/gaveup/, "default spinlock" );
    146146
    147 Test::IData->setup;
     147Test::Nebulous->setup;
    148148
    149149diag "testing a spinlock, this will be a litle slow...";
    … …  
    154154
    155155    # key, type, timeout
    156     my $idata = PS::IPP::IData::Client->new(
    157         proxy => "http://$hostport/idata",
    158     );
    159     $idata->create( "foo" );
    160 
    161     $idata->lock( "foo", "read" );
    162     $idata->lock( "foo", "write", 5 );
     156    my $neb = Nebulous::Client->new(
     157        proxy => "http://$hostport/nebulous",
     158    );
     159    $neb->create( "foo" );
     160
     161    $neb->lock( "foo", "read" );
     162    $neb->lock( "foo", "write", 5 );
    163163
    164164    alarm 0;
    … …  
    166166like( $@, qr/timeout/, "specified spinlock" );
    167167
    168 Test::IData->setup;
     168Test::Nebulous->setup;
    169169
    170170diag "testing a spinlock, this will be a litle slow...";
    … …  
    175175
    176176    # key, type, timeout
    177     my $idata = PS::IPP::IData::Client->new(
    178         proxy => "http://$hostport/idata",
    179     );
    180     $idata->create( "foo" );
    181 
    182     $idata->lock( "foo", "read" );
    183     unless ( $idata->lock( "foo", "write", 5 ) ) {
     177    my $neb = Nebulous::Client->new(
     178        proxy => "http://$hostport/nebulous",
     179    );
     180    $neb->create( "foo" );
     181
     182    $neb->lock( "foo", "read" );
     183    unless ( $neb->lock( "foo", "write", 5 ) ) {
    184184        alarm 0;
    185185        die "gaveup";
    … …  
    191191like( $@, qr/gaveup/, "specified spinlock" );
    192192
    193 Test::IData->setup;
    194 
    195 {
    196     my $idata = PS::IPP::IData::Client->new(
    197         proxy => "http://$hostport/idata",
    198     );
    199     $idata->create( "foo" );
    200 
    201     $idata->lock( "foo", "write" );
    202     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
    203 }
    204 
    205 Test::IData->setup;
    206 
    207 {
    208     my $idata = PS::IPP::IData::Client->new(
    209         proxy => "http://$hostport/idata",
    210     );
    211     $idata->create( "foo" );
    212 
    213     $idata->lock( "foo", "read" );
    214     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
    215 }
    216 
    217 Test::IData->setup;
    218 
    219 {
    220     my $idata = PS::IPP::IData::Client->new(
    221         proxy => "http://$hostport/idata",
    222     );
    223     $idata->create( "foo" );
    224 
    225     $idata->lock( "foo", "write" );
    226     is( $idata->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
    227 }
    228 
    229 Test::IData->setup;
    230 
    231 eval {
    232     my $idata = PS::IPP::IData::Client->new(
    233         proxy => "http://$hostport/idata",
    234     );
    235 
    236     $idata->lock();
     193Test::Nebulous->setup;
     194
     195{
     196    my $neb = Nebulous::Client->new(
     197        proxy => "http://$hostport/nebulous",
     198    );
     199    $neb->create( "foo" );
     200
     201    $neb->lock( "foo", "write" );
     202    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
     203}
     204
     205Test::Nebulous->setup;
     206
     207{
     208    my $neb = Nebulous::Client->new(
     209        proxy => "http://$hostport/nebulous",
     210    );
     211    $neb->create( "foo" );
     212
     213    $neb->lock( "foo", "read" );
     214    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
     215}
     216
     217Test::Nebulous->setup;
     218
     219{
     220    my $neb = Nebulous::Client->new(
     221        proxy => "http://$hostport/nebulous",
     222    );
     223    $neb->create( "foo" );
     224
     225    $neb->lock( "foo", "write" );
     226    is( $neb->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
     227}
     228
     229Test::Nebulous->setup;
     230
     231eval {
     232    my $neb = Nebulous::Client->new(
     233        proxy => "http://$hostport/nebulous",
     234    );
     235
     236    $neb->lock();
    237237};
    238238like( $@, qr/2 - 3 were expected/, "no params" );
    239239
    240 Test::IData->setup;
    241 
    242 eval {
    243     my $idata = PS::IPP::IData::Client->new(
    244         proxy => "http://$hostport/idata",
    245     );
    246 
    247     $idata->lock( "foo" );
     240Test::Nebulous->setup;
     241
     242eval {
     243    my $neb = Nebulous::Client->new(
     244        proxy => "http://$hostport/nebulous",
     245    );
     246
     247    $neb->lock( "foo" );
    248248};
    249249like( $@, qr/2 - 3 were expected/, "not enough params" );
    250250
    251 Test::IData->setup;
    252 
    253 eval {
    254     my $idata = PS::IPP::IData::Client->new(
    255         proxy => "http://$hostport/idata",
    256     );
    257 
    258     $idata->lock( "foo", "both" );
     251Test::Nebulous->setup;
     252
     253eval {
     254    my $neb = Nebulous::Client->new(
     255        proxy => "http://$hostport/nebulous",
     256    );
     257
     258    $neb->lock( "foo", "both" );
    259259};
    260260like( $@, qr/is read or write/, "not read or write" );
    261261
    262 Test::IData->setup;
    263 
    264 eval {
    265     my $idata = PS::IPP::IData::Client->new(
    266         proxy => "http://$hostport/idata",
    267     );
    268 
    269     $idata->lock( "foo", 'read', 3, "bar" );
     262Test::Nebulous->setup;
     263
     264eval {
     265    my $neb = Nebulous::Client->new(
     266        proxy => "http://$hostport/nebulous",
     267    );
     268
     269    $neb->lock( "foo", 'read', 3, "bar" );
    270270};
    271271like( $@, qr/2 - 3 were expected/, "too many params" );
    272272
    273 Test::IData->cleanup;
     273Test::Nebulous->cleanup;

  • trunk/Nebulous/t/15_client_unlock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 15_client_unlock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 15_client_unlock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
    29     $idata->lock( "foo", "read" );
     28    $neb->create( "foo" );
     29    $neb->lock( "foo", "read" );
    3030
    31     ok( $idata->unlock( "foo", "read" ), "read unlock" );
     31    ok( $neb->unlock( "foo", "read" ), "read unlock" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     my $idata = PS::IPP::IData::Client->new(
    38         proxy => "http://$hostport/idata",
     37    my $neb = Nebulous::Client->new(
     38        proxy => "http://$hostport/nebulous",
    3939    );
    40     $idata->create( "foo" );
    41     $idata->lock( "foo", "read" );
    42     $idata->lock( "foo", "read" );
     40    $neb->create( "foo" );
     41    $neb->lock( "foo", "read" );
     42    $neb->lock( "foo", "read" );
    4343
    44     ok( $idata->unlock( "foo", "read" ), "read unlock" );
    45     ok( $idata->unlock( "foo", "read" ), "read unlock" );
     44    ok( $neb->unlock( "foo", "read" ), "read unlock" );
     45    ok( $neb->unlock( "foo", "read" ), "read unlock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    54     $idata->create( "foo" );
    55     $idata->lock( "foo", "write" );
     54    $neb->create( "foo" );
     55    $neb->lock( "foo", "write" );
    5656
    57     ok( $idata->unlock( "foo", "write" ), "write unlock" );
     57    ok( $neb->unlock( "foo", "write" ), "write unlock" );
    5858}
    5959
    60 Test::IData->setup;
     60Test::Nebulous->setup;
    6161
    6262{
    63     my $idata = PS::IPP::IData::Client->new(
    64         proxy => "http://$hostport/idata",
     63    my $neb = Nebulous::Client->new(
     64        proxy => "http://$hostport/nebulous",
    6565    );
    6666
    67     is( $idata->unlock( "foo", "read" ), undef, "storage object does not exist" );
     67    is( $neb->unlock( "foo", "read" ), undef, "storage object does not exist" );
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $idata = PS::IPP::IData::Client->new(
    74         proxy => "http://$hostport/idata",
     73    my $neb = Nebulous::Client->new(
     74        proxy => "http://$hostport/nebulous",
    7575    );
    7676
    77     is( $idata->unlock( "foo", "write" ), undef, "storage object does not exist" );
     77    is( $neb->unlock( "foo", "write" ), undef, "storage object does not exist" );
    7878}
    7979
    80 Test::IData->setup;
     80Test::Nebulous->setup;
    8181
    8282{
    83     my $idata = PS::IPP::IData::Client->new(
    84         proxy => "http://$hostport/idata",
     83    my $neb = Nebulous::Client->new(
     84        proxy => "http://$hostport/nebulous",
    8585    );
    86     $idata->create( "foo" );
     86    $neb->create( "foo" );
    8787
    88     is( $idata->unlock( "foo", "read" ), undef, "no lock set" );
     88    is( $neb->unlock( "foo", "read" ), undef, "no lock set" );
    8989}
    9090
    91 Test::IData->setup;
     91Test::Nebulous->setup;
    9292
    9393{
    94     my $idata = PS::IPP::IData::Client->new(
    95         proxy => "http://$hostport/idata",
     94    my $neb = Nebulous::Client->new(
     95        proxy => "http://$hostport/nebulous",
    9696    );
    97     $idata->create( "foo" );
     97    $neb->create( "foo" );
    9898
    99     is( $idata->unlock( "foo", "write" ), undef, "no lock set" );
     99    is( $neb->unlock( "foo", "write" ), undef, "no lock set" );
    100100}
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104{
    105     my $idata = PS::IPP::IData::Client->new(
    106         proxy => "http://$hostport/idata",
     105    my $neb = Nebulous::Client->new(
     106        proxy => "http://$hostport/nebulous",
    107107    );
    108     $idata->create( "foo" );
    109     $idata->lock( "foo", "write" );
     108    $neb->create( "foo" );
     109    $neb->lock( "foo", "write" );
    110110
    111     is( $idata->unlock( "foo", "read" ), undef, "read unlock under write lock" );
     111    is( $neb->unlock( "foo", "read" ), undef, "read unlock under write lock" );
    112112}
    113113
    114 Test::IData->setup;
     114Test::Nebulous->setup;
    115115
    116116{
    117     my $idata = PS::IPP::IData::Client->new(
    118         proxy => "http://$hostport/idata",
     117    my $neb = Nebulous::Client->new(
     118        proxy => "http://$hostport/nebulous",
    119119    );
    120     $idata->create( "foo" );
    121     $idata->lock( "foo", "read" );
     120    $neb->create( "foo" );
     121    $neb->lock( "foo", "read" );
    122122
    123     is( $idata->unlock( "foo", "write" ), undef, "write unlock under read lock" );
     123    is( $neb->unlock( "foo", "write" ), undef, "write unlock under read lock" );
    124124}
    125125
    126 Test::IData->setup;
     126Test::Nebulous->setup;
    127127
    128128eval {
    129     my $idata = PS::IPP::IData::Client->new(
    130         proxy => "http://$hostport/idata",
     129    my $neb = Nebulous::Client->new(
     130        proxy => "http://$hostport/nebulous",
    131131    );
    132132
    133     $idata->unlock();
     133    $neb->unlock();
    134134};
    135135like( $@, qr/2 were expected/, "no params" );
    136136
    137 Test::IData->setup;
     137Test::Nebulous->setup;
    138138
    139139eval {
    140     my $idata = PS::IPP::IData::Client->new(
    141         proxy => "http://$hostport/idata",
     140    my $neb = Nebulous::Client->new(
     141        proxy => "http://$hostport/nebulous",
    142142    );
    143143
    144     $idata->unlock( "foo" );
     144    $neb->unlock( "foo" );
    145145};
    146146like( $@, qr/2 were expected/, "not enough params" );
    147147
    148 Test::IData->setup;
     148Test::Nebulous->setup;
    149149
    150150eval {
    151     my $idata = PS::IPP::IData::Client->new(
    152         proxy => "http://$hostport/idata",
     151    my $neb = Nebulous::Client->new(
     152        proxy => "http://$hostport/nebulous",
    153153    );
    154154
    155     $idata->unlock( "foo", "both" );
     155    $neb->unlock( "foo", "both" );
    156156};
    157157like( $@, qr/is read or write/, "not read or write" );
    158158
    159 Test::IData->setup;
     159Test::Nebulous->setup;
    160160
    161161eval {
    162     my $idata = PS::IPP::IData::Client->new(
    163         proxy => "http://$hostport/idata",
     162    my $neb = Nebulous::Client->new(
     163        proxy => "http://$hostport/nebulous",
    164164    );
    165165
    166     $idata->unlock( "foo", 'read', 3 );
     166    $neb->unlock( "foo", 'read', 3 );
    167167};
    168168like( $@, qr/2 were expected/, "too many params" );
    169169
    170 Test::IData->cleanup;
     170Test::Nebulous->cleanup;

  • trunk/Nebulous/t/16_client_find_instances.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 16_client_find_instances.t,v 1.5 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 16_client_find_instances.t,v 1.6 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
     29    $neb->create( "foo" );
    3030
    31     my $locations = $idata->find_instances( "foo" );
     31    my $locations = $neb->find_instances( "foo" );
    3232
    3333    is( scalar @$locations, 1, "found 1" );
    … …  
    3636}
    3737
    38 Test::IData->setup;
     38Test::Nebulous->setup;
    3939
    4040{
    4141    # key
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    45     $idata->create( "foo" );
    46     $idata->replicate( "foo" );
     45    $neb->create( "foo" );
     46    $neb->replicate( "foo" );
    4747
    48     my $locations = $idata->find_instances( "foo" );
     48    my $locations = $neb->find_instances( "foo" );
    4949
    5050    is( scalar @$locations, 2, "found 2" );
    … …  
    5555}
    5656
    57 Test::IData->setup;
     57Test::Nebulous->setup;
    5858
    5959{
    6060    # key, volume
    61     my $idata = PS::IPP::IData::Client->new(
    62         proxy => "http://$hostport/idata",
     61    my $neb = Nebulous::Client->new(
     62        proxy => "http://$hostport/nebulous",
    6363    );
    64     $idata->create( "foo" );
     64    $neb->create( "foo" );
    6565
    66     my $locations = $idata->find_instances( "foo", "node01" );
     66    my $locations = $neb->find_instances( "foo", "node01" );
    6767
    6868    is( scalar @$locations, 1, "found 1" );
    … …  
    7171}
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575{
    7676    # key
    77     my $idata = PS::IPP::IData::Client->new(
    78         proxy => "http://$hostport/idata",
     77    my $neb = Nebulous::Client->new(
     78        proxy => "http://$hostport/nebulous",
    7979    );
    80     $idata->create( "foo" );
    81     $idata->replicate( "foo" );
     80    $neb->create( "foo" );
     81    $neb->replicate( "foo" );
    8282
    83     my $locations = $idata->find_instances( "foo", "node01" );
     83    my $locations = $neb->find_instances( "foo", "node01" );
    8484
    8585    is( scalar @$locations, 2, "found 2" );
    … …  
    9090}
    9191
    92 Test::IData->setup;
     92Test::Nebulous->setup;
    9393
    9494{
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
    9797    );
    9898
    99     is( $idata->find_instances( "foo" ), undef, "storage object does not exist" );
     99    is( $neb->find_instances( "foo" ), undef, "storage object does not exist" );
    100100}
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104eval {
    105     my $idata = PS::IPP::IData::Client->new(
    106         proxy => "http://$hostport/idata",
     105    my $neb = Nebulous::Client->new(
     106        proxy => "http://$hostport/nebulous",
    107107    );
    108108
    109     $idata->find_instances();
     109    $neb->find_instances();
    110110};
    111111like( $@, qr/1 - 2 were expected/, "no params" );
    112112
    113 Test::IData->setup;
     113Test::Nebulous->setup;
    114114
    115115eval {
    116     my $idata = PS::IPP::IData::Client->new(
    117         proxy => "http://$hostport/idata",
     116    my $neb = Nebulous::Client->new(
     117        proxy => "http://$hostport/nebulous",
    118118    );
    119119
    120     $idata->find_instances( "foo", 'read', 3 );
     120    $neb->find_instances( "foo", 'read', 3 );
    121121};
    122122like( $@, qr/1 - 2 were expected/, "too many params" );
    123123
    124 Test::IData->cleanup;
     124Test::Nebulous->cleanup;

  • trunk/Nebulous/t/17_client_find.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 17_client_find.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 17_client_find.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     my $uri = $idata->create( "foo" );
     29    my $uri = $neb->create( "foo" );
    3030
    31     my $path = $idata->find( "foo" );
     31    my $path = $neb->find( "foo" );
    3232
    3333    ok( -e $path, "file exists" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    4242
    43     my $path = $idata->find( "foo" );
     43    my $path = $neb->find( "foo" );
    4444
    4545    ok( ! -e $path, "file doesn't exist" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050eval {
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    5454
    55     $idata->find();
     55    $neb->find();
    5656};
    5757like( $@, qr/1 was expected/, "no params" );
    5858
    59 Test::IData->setup;
     59Test::Nebulous->setup;
    6060
    6161eval {
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
    6464    );
    6565
    66     $idata->find( "foo", "bar" );
     66    $neb->find( "foo", "bar" );
    6767};
    6868like( $@, qr/1 was expected/, "too many params" );
    6969
    70 Test::IData->cleanup;
     70Test::Nebulous->cleanup;

  • trunk/Nebulous/t/18_client_open.t

    r2896 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 18_client_open.t,v 1.1 2005-01-05 01:41:05 jhoblitt Exp $
     5# $Id: 18_client_open.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
    30     my $fh = $idata->open( "foo", 'read' );
     29    $neb->create( "foo" );
     30    my $fh = $neb->open( "foo", 'read' );
    3131
    3232    is( ref $fh, 'GLOB', "good filehandle" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    42     $idata->create( "foo" );
    43     my $fh = $idata->open( "foo", 'write' );
     42    $neb->create( "foo" );
     43    my $fh = $neb->open( "foo", 'write' );
    4444
    4545    is( ref $fh, 'GLOB', "good filehandle" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    5454
    55     is( ref $idata->open( "foo", 'write' ), 'GLOB', "create new object" );
     55    is( ref $neb->open( "foo", 'write' ), 'GLOB', "create new object" );
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060{
    61     my $idata = PS::IPP::IData::Client->new(
    62         proxy => "http://$hostport/idata",
     61    my $neb = Nebulous::Client->new(
     62        proxy => "http://$hostport/nebulous",
    6363    );
    6464
    65     is( $idata->open( "foo", 'read' ), undef, "can't create new object" );
     65    is( $neb->open( "foo", 'read' ), undef, "can't create new object" );
    6666}
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     my $idata = PS::IPP::IData::Client->new(
    72         proxy => "http://$hostport/idata",
     71    my $neb = Nebulous::Client->new(
     72        proxy => "http://$hostport/nebulous",
    7373    );
    74     $idata->open( "foo", 'bar' );
     74    $neb->open( "foo", 'bar' );
    7575};
    7676like( $@, qr/is read or write/, "2nd params not read or write" );
    7777
    78 Test::IData->setup;
     78Test::Nebulous->setup;
    7979
    8080eval {
    81     my $idata = PS::IPP::IData::Client->new(
    82         proxy => "http://$hostport/idata",
     81    my $neb = Nebulous::Client->new(
     82        proxy => "http://$hostport/nebulous",
    8383    );
    84     $idata->open();
     84    $neb->open();
    8585};
    8686like( $@, qr/2 were expected/, "no params" );
    8787
    88 Test::IData->setup;
     88Test::Nebulous->setup;
    8989
    9090eval {
    91     my $idata = PS::IPP::IData::Client->new(
    92         proxy => "http://$hostport/idata",
     91    my $neb = Nebulous::Client->new(
     92        proxy => "http://$hostport/nebulous",
    9393    );
    94     $idata->open( 1, 'read', 3 );
     94    $neb->open( 1, 'read', 3 );
    9595};
    9696like( $@, qr/2 were expected/, "too many params" );
    9797
    98 Test::IData->cleanup;
     98Test::Nebulous->cleanup;

  • trunk/Nebulous/t/19_client_delete.t

    r2913 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 19_client_delete.t,v 1.2 2005-01-05 22:27:22 jhoblitt Exp $
     5# $Id: 19_client_delete.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->delete( "foo" ), "delete object" );
     30    ok( $neb->delete( "foo" ), "delete object" );
    3131
    32     my $locations = $idata->find_instances( "foo" );
     32    my $locations = $neb->find_instances( "foo" );
    3333
    3434    is( $locations, undef, "no instances" );
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    40     my $idata = PS::IPP::IData::Client->new(
    41         proxy => "http://$hostport/idata",
     40    my $neb = Nebulous::Client->new(
     41        proxy => "http://$hostport/nebulous",
    4242    );
    43     $idata->create( "foo" );
    44     $idata->replicate( "foo" );
     43    $neb->create( "foo" );
     44    $neb->replicate( "foo" );
    4545
    46     ok( $idata->delete( "foo" ), "delete object" );
     46    ok( $neb->delete( "foo" ), "delete object" );
    4747
    48     my $locations = $idata->find_instances( "foo" );
     48    my $locations = $neb->find_instances( "foo" );
    4949
    5050    is( $locations, undef, "no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555{
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    5959
    60     is( $idata->delete( "foo" ), undef, "delete non-existant object" );
     60    is( $neb->delete( "foo" ), undef, "delete non-existant object" );
    6161}
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->delete();
     69    $neb->delete();
    7070};
    7171like( $@, qr/1 was expected/, "no params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->delete( "foo", 2 );
     79    $neb->delete( "foo", 2 );
    8080};
    8181like( $@, qr/1 was expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous/t/20_client_copy.t

    r2878 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 20_client_copy.t,v 1.1 2005-01-04 02:13:21 jhoblitt Exp $
     5# $Id: 20_client_copy.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->copy( "foo", "foobar" ), "copied object" );
     30    ok( $neb->copy( "foo", "foobar" ), "copied object" );
    3131
    32     my $locations1 = $idata->find_instances( "foobar" );
    33     my $locations2 = $idata->find_instances( "foobar" );
     32    my $locations1 = $neb->find_instances( "foobar" );
     33    my $locations2 = $neb->find_instances( "foobar" );
    3434
    3535    is( scalar @$locations1, 1, "old object has an instances" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    4545
    46     ok( ! $idata->copy( "foo", "foobar" ), "copy non-existant object" );
     46    ok( ! $neb->copy( "foo", "foobar" ), "copy non-existant object" );
    4747
    48     my $locations = $idata->find_instances( "foobar" );
     48    my $locations = $neb->find_instances( "foobar" );
    4949
    5050    is( $locations, undef, "new object has no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555eval {
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->copy();
     59    $neb->copy();
    6060};
    6161like( $@, qr/2 were expected/, "no params" );
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->copy( "foo" );
     69    $neb->copy( "foo" );
    7070};
    7171like( $@, qr/2 were expected/, "not enough params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->copy( "foo", "bar", "baz" );
     79    $neb->copy( "foo", "bar", "baz" );
    8080};
    8181like( $@, qr/2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous/t/21_client_move.t

    r2881 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 21_client_move.t,v 1.1 2005-01-04 02:48:31 jhoblitt Exp $
     5# $Id: 21_client_move.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->move( "foo", "foobar" ), "move object" );
     30    ok( $neb->move( "foo", "foobar" ), "move object" );
    3131
    32     my $locations1 = $idata->find_instances( "foo" );
    33     my $locations2 = $idata->find_instances( "foobar" );
     32    my $locations1 = $neb->find_instances( "foo" );
     33    my $locations2 = $neb->find_instances( "foobar" );
    3434
    3535    is( $locations1, undef, "old object has no instances" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    4545
    46     ok( ! $idata->move( "foo", "foobar" ), "move non-existant object" );
     46    ok( ! $neb->move( "foo", "foobar" ), "move non-existant object" );
    4747
    48     my $locations = $idata->find_instances( "foobar" );
     48    my $locations = $neb->find_instances( "foobar" );
    4949
    5050    is( $locations, undef, "new object has no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555eval {
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->move();
     59    $neb->move();
    6060};
    6161like( $@, qr/2 were expected/, "no params" );
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->move( "foo" );
     69    $neb->move( "foo" );
    7070};
    7171like( $@, qr/2 were expected/, "not enough params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->move( "foo", "bar", "baz" );
     79    $neb->move( "foo", "bar", "baz" );
    8080};
    8181like( $@, qr/2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous/t/22_client_delete_instance.t

    r2882 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 22_client_delete_instance.t,v 1.1 2005-01-04 03:14:19 jhoblitt Exp $
     5# $Id: 22_client_delete_instance.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     my $locations = $idata->find_instances( "foo" );
     30    my $locations = $neb->find_instances( "foo" );
    3131
    32     my $uri = $idata->delete_instance( @$locations[0] );
     32    my $uri = $neb->delete_instance( @$locations[0] );
    3333
    3434    is( $uri, @$locations[0], "delete instance" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    45     $idata->create( "foo" );
    46     $idata->replicate( "foo" );
     45    $neb->create( "foo" );
     46    $neb->replicate( "foo" );
    4747
    48     my $uri1 = $idata->find_instances( "foo" )->[0];
     48    my $uri1 = $neb->find_instances( "foo" )->[0];
    4949
    50     ok( $idata->delete_instance( $uri1 ), "delete instance" );
     50    ok( $neb->delete_instance( $uri1 ), "delete instance" );
    5151
    52     my $uri2 = $idata->find_instances( "foo" )->[0];
     52    my $uri2 = $neb->find_instances( "foo" )->[0];
    5353
    5454    isnt( $uri1, $uri2, "other instance remains" );
    5555
    56     ok( $idata->delete_instance( $uri2 ), "delete instance" );
     56    ok( $neb->delete_instance( $uri2 ), "delete instance" );
    5757
    58     my $locations = $idata->find_instances( "foo" );
     58    my $locations = $neb->find_instances( "foo" );
    5959
    6060    is( $locations, undef, "no remaning instances" );
    … …  
    6262
    6363{
    64     my $idata = PS::IPP::IData::Client->new(
    65         proxy => "http://$hostport/idata",
     64    my $neb = Nebulous::Client->new(
     65        proxy => "http://$hostport/nebulous",
    6666    );
    67     my $uri = $idata->delete_instance( "file:/foo" );
     67    my $uri = $neb->delete_instance( "file:/foo" );
    6868
    6969    is( $uri, undef, "uri does not exist" );
    7070}
    7171
    72 Test::IData->setup;
     72Test::Nebulous->setup;
    7373
    7474eval {
    75     my $idata = PS::IPP::IData::Client->new(
    76         proxy => "http://$hostport/idata",
     75    my $neb = Nebulous::Client->new(
     76        proxy => "http://$hostport/nebulous",
    7777    );
    78     $idata->delete_instance();
     78    $neb->delete_instance();
    7979};
    8080like( $@, qr/1 was expected/, "no params" );
    8181
    82 Test::IData->setup;
     82Test::Nebulous->setup;
    8383
    8484eval {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
    8787    );
    88     $idata->delete_instance( "foo", 2 );
     88    $neb->delete_instance( "foo", 2 );
    8989};
    9090like( $@, qr/1 was expected/, "too many params" );
    9191
    92 Test::IData->cleanup;
     92Test::Nebulous->cleanup;

  • trunk/Nebulous/t/23_client_stat.t

    r3016 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 23_client_stat.t,v 1.2 2005-01-15 04:02:12 jhoblitt Exp $
     5# $Id: 23_client_stat.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     my $info = $idata->stat( "foo" );
     30    my $info = $neb->stat( "foo" );
    3131
    3232    is( scalar @$info, 8, "number of columns" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
    4040    );
    41     $idata->create( "foo", 9, "node01", "foobar" );
     41    $neb->create( "foo", 9, "node01", "foobar" );
    4242
    43     my $info = $idata->stat( "foo" );
     43    my $info = $neb->stat( "foo" );
    4444
    4545    is( scalar @$info, 8,                       "number of columns" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    59     my $idata = PS::IPP::IData::Client->new(
    60         proxy => "http://$hostport/idata",
     59    my $neb = Nebulous::Client->new(
     60        proxy => "http://$hostport/nebulous",
    6161    );
    62     my $info = $idata->stat( "foo" );
     62    my $info = $neb->stat( "foo" );
    6363
    6464    is( $info, undef, "object does not exist" );
    6565}
    6666
    67 Test::IData->setup;
     67Test::Nebulous->setup;
    6868
    6969eval {
    70     my $idata = PS::IPP::IData::Client->new(
    71         proxy => "http://$hostport/idata",
     70    my $neb = Nebulous::Client->new(
     71        proxy => "http://$hostport/nebulous",
    7272    );
    73     $idata->stat();
     73    $neb->stat();
    7474};
    7575like( $@, qr/1 was expected/, "no params" );
    7676
    77 Test::IData->setup;
     77Test::Nebulous->setup;
    7878
    7979eval {
    80     my $idata = PS::IPP::IData::Client->new(
    81         proxy => "http://$hostport/idata",
     80    my $neb = Nebulous::Client->new(
     81        proxy => "http://$hostport/nebulous",
    8282    );
    83     $idata->stat( "foo", 2 );
     83    $neb->stat( "foo", 2 );
    8484};
    8585like( $@, qr/1 was expected/, "too many params" );
    8686
    87 Test::IData->cleanup;
     87Test::Nebulous->cleanup;

  • trunk/Nebulous/t/Test/Nebulous.pm

    r4437 r4440  
    11# Copyright (C) 2004  Joshua Hoblitt
    22#
    3 # $Id: Nebulous.pm,v 1.3 2005-06-30 01:41:40 jhoblitt Exp $
     3# $Id: Nebulous.pm,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    44
    5 package Test::IData;
     5package Test::Nebulous;
    66
    77use strict;

  • trunk/Nebulous/t/apache_03_server_create_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    2626    # key
    27     my $uri = $idata->create_object( "foo" )->result;
     27    my $uri = $neb->create_object( "foo" )->result;
    2828
    2929    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    3737    # key, class
    38     my $uri = $idata->create_object( "foo", 0 )->result;
    39     $idata->delete_instance( $uri );
     38    my $uri = $neb->create_object( "foo", 0 )->result;
     39    $neb->delete_instance( $uri );
    4040
    4141    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4444}
    4545
    46 Test::IData->setup;
     46Test::Nebulous->setup;
    4747
    4848{
    4949    # key, class, volume
    50     my $uri = $idata->create_object( "foo", 0, "node01" )->result;
    51     $idata->delete_instance( $uri );
     50    my $uri = $neb->create_object( "foo", 0, "node01" )->result;
     51    $neb->delete_instance( $uri );
    5252
    5353    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, class, volume, comment
    62     my $uri = $idata->create_object( "foo", 0, "node01", "this is foo" )->result;
    63     $idata->delete_instance( $uri );
     62    my $uri = $neb->create_object( "foo", 0, "node01", "this is foo" )->result;
     63    $neb->delete_instance( $uri );
    6464
    6565    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     $idata->create_object( "foo" );
    74     my $response = $idata->create_object( "foo" );
     73    $neb->create_object( "foo" );
     74    my $response = $neb->create_object( "foo" );
    7575
    7676    like( $response->faultstring, qr/Duplicate entry/, "object already exists" );
    7777}
    7878
    79 Test::IData->setup;
     79Test::Nebulous->setup;
    8080
    8181{
    82     my $response = $idata->create_object();
     82    my $response = $neb->create_object();
    8383
    8484    like( $response->faultstring, qr/2 - 4 were expected/, "no params" );
    8585}
    8686
    87 Test::IData->setup;
     87Test::Nebulous->setup;
    8888
    8989{
    90     my $response = $idata->create_object( 1, 2, 3, 4, 5 );
     90    my $response = $neb->create_object( 1, 2, 3, 4, 5 );
    9191
    9292    like( $response->faultstring, qr/2 - 4 were expected/, "too many params" );
    9393}
    9494
    95 Test::IData->cleanup;
     95Test::Nebulous->cleanup;

  • trunk/Nebulous/t/apache_04_server_replicate_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    2626    # key
    27     $idata->create_object( "foo" );
    28     my $uri = $idata->replicate_object( "foo" )->result;
     27    $neb->create_object( "foo" );
     28    my $uri = $neb->replicate_object( "foo" )->result;
    2929
    3030    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key, $volume
    39     $idata->create_object( "foo" );
    40     my $uri = $idata->replicate_object( "foo", "node01" )->result;
     39    $neb->create_object( "foo" );
     40    my $uri = $neb->replicate_object( "foo", "node01" )->result;
    4141
    4242    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4545}
    4646
    47 Test::IData->setup;
     47Test::Nebulous->setup;
    4848
    4949{
    5050    # key, $volume
    51     $idata->create_object( "foo" );
    52     my $uri1 = $idata->replicate_object( "foo", "node01" )->result;
    53     my $uri2 = $idata->replicate_object( "foo", "node02" )->result;
     51    $neb->create_object( "foo" );
     52    my $uri1 = $neb->replicate_object( "foo", "node01" )->result;
     53    my $uri2 = $neb->replicate_object( "foo", "node02" )->result;
    5454
    5555    ok( -e _get_file_path( $uri1 ), "file exists" );
    … …  
    6060}
    6161
    62 Test::IData->setup;
     62Test::Nebulous->setup;
    6363
    6464{
    65     my $response = $idata->replicate_object();
     65    my $response = $neb->replicate_object();
    6666
    6767    like( $response->faultstring, qr/1 - 2 were expected/, "no params" );
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $response = $idata->replicate_object( 1, 2, 3 );
     73    my $response = $neb->replicate_object( 1, 2, 3 );
    7474
    7575    like( $response->faultstring, qr/1 - 2 were expected/, "too many params" );
    7676}
    7777
    78 Test::IData->setup;
     78Test::Nebulous->setup;
    7979
    8080{
    81     my $response = $idata->replicate_object( "foo" );
     81    my $response = $neb->replicate_object( "foo" );
    8282
    8383    like( $response->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    8484}
    8585
    86 Test::IData->cleanup;
     86Test::Nebulous->cleanup;

  • trunk/Nebulous/t/apache_05_server_lock_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    26     $idata->create_object( "foo" );
     26    $neb->create_object( "foo" );
    2727
    28     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
     28    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
    2929}
    3030
    31 Test::IData->setup;
     31Test::Nebulous->setup;
    3232
    3333{
    34     $idata->create_object( "foo" );
     34    $neb->create_object( "foo" );
    3535
    36     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
    37     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
     36    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
     37    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
    3838}
    3939
    40 Test::IData->setup;
     40Test::Nebulous->setup;
    4141
    4242{
    43     $idata->create_object( "foo" );
     43    $neb->create_object( "foo" );
    4444
    45     ok( $idata->lock_object( "foo", "write" )->result, "write lock" );
     45    ok( $neb->lock_object( "foo", "write" )->result, "write lock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $result = $idata->lock_object( "foo", "read" );
     51    my $result = $neb->lock_object( "foo", "read" );
    5252
    5353    like( $result->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    59     my $result = $idata->lock_object( "foo", "write" );
     59    my $result = $neb->lock_object( "foo", "write" );
    6060
    6161    like( $result->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    6262}
    6363
    64 Test::IData->setup;
     64Test::Nebulous->setup;
    6565
    6666{
    67     $idata->create_object( "foo" );
     67    $neb->create_object( "foo" );
    6868
    69     $idata->lock_object( "foo", "write" );
    70     my $result = $idata->lock_object( "foo", "write" );
     69    $neb->lock_object( "foo", "write" );
     70    my $result = $neb->lock_object( "foo", "write" );
    7171
    7272    like( $result->faultstring, qr/can not write lock twice/, "can not write lock twice" );
    7373}
    7474
    75 Test::IData->setup;
     75Test::Nebulous->setup;
    7676
    7777{
    78     $idata->create_object( "foo" );
     78    $neb->create_object( "foo" );
    7979
    80     $idata->lock_object( "foo", "read" );
    81     my $result = $idata->lock_object( "foo", "write" );
     80    $neb->lock_object( "foo", "read" );
     81    my $result = $neb->lock_object( "foo", "write" );
    8282
    8383    like( $result->faultstring, qr/can not write lock after read lock/, "can not write lock after read lock" );
    8484}
    8585
    86 Test::IData->setup;
     86Test::Nebulous->setup;
    8787
    8888{
    89     $idata->create_object( "foo" );
     89    $neb->create_object( "foo" );
    9090
    91     $idata->lock_object( "foo", "write" );
    92     my $result = $idata->lock_object( "foo", "read" );
     91    $neb->lock_object( "foo", "write" );
     92    my $result = $neb->lock_object( "foo", "read" );
    9393
    9494    like( $result->faultstring, qr/can not read lock after write lock/, "can not read lock after write lock" );
    9595}
    9696
    97 Test::IData->setup;
     97Test::Nebulous->setup;
    9898
    9999{
    100     my $result = $idata->lock_object();
     100    my $result = $neb->lock_object();
    101101
    102102    like( $result->faultstring, qr/2 were expected/, "no params" );
    103103}
    104104
    105 Test::IData->setup;
     105Test::Nebulous->setup;
    106106
    107107{
    108     my $result = $idata->lock_object( "foo" );
     108    my $result = $neb->lock_object( "foo" );
    109109
    110110    like( $result->faultstring, qr/2 were expected/, "not enough params" );
    111111}
    112112
    113 Test::IData->setup;
     113Test::Nebulous->setup;
    114114
    115115{
    116     my $result = $idata->lock_object( "foo", "both" );
     116    my $result = $neb->lock_object( "foo", "both" );
    117117
    118118    like( $result->faultstring, qr/is read or write/, "not read or write" );
    119119}
    120120
    121 Test::IData->setup;
     121Test::Nebulous->setup;
    122122
    123123{
    124     my $result = $idata->lock_object( "foo", 'read', 3 );
     124    my $result = $neb->lock_object( "foo", 'read', 3 );
    125125
    126126    like( $result->faultstring, qr/2 were expected/, "too many params" );
    127127}
    128128
    129 Test::IData->cleanup;
     129Test::Nebulous->cleanup;

  • trunk/Nebulous/t/conf/extra.conf.in

    r4438 r4440  
    33# this file will be Include-d by @ServerRoot@/httpd.conf
    44
    5 # where PS::IPP::IData::Server::Apache can be found
     5# where Nebulous::Server::Apache can be found
    66# mp2
    77PerlSwitches -I@ServerRoot@/../lib
    … …  
    1414#ScriptSock logs/cgisock
    1515
    16 <Location /idata>
     16<Location /nebulous>
    1717    SetHandler perl-script
    18 #    PerlHandler PS::IPP::IData::Server::Apache
     18#    PerlHandler Nebulous::Server::Apache
    1919    PerlResponseHandler Apache2::SOAP
    20     PerlSetVar dispatch_to "PerlHandler PS::IPP::IData::Server::SOAP"
     20    PerlSetVar dispatch_to "PerlHandler Nebulous::Server::SOAP"
    2121    PerlSetVar options "compress_threshold => 10000"
    2222</Location>

  • trunk/Nebulous/t/conf/startup.pl.in

    r4438 r4440  
    33use Apache::DBI;
    44use DBI;
    5 use PS::IPP::IData::Server::SOAP;
    6 use PS::IPP::IData::Server;
     5use Nebulous::Server::SOAP;
     6use Nebulous::Server;
    77
    88my $dsn     = "DBI:mysql:database=test:host=localhost";
    … …  
    1111
    1212Apache::DBI->connect_on_init( $dsn, $dbuser, $dbpass );
    13 PS::IPP::IData::Server->setup( $dsn, $dbuser, $dbpass );
     13Nebulous::Server->setup( $dsn, $dbuser, $dbpass );
    1414
    15151;
Note: See TracChangeset for help on using the changeset viewer.