IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 17693


Ignore:
Timestamp:
May 14, 2008, 5:26:11 PM (18 years ago)
Author:
jhoblitt
Message:

overhaul SOAP fault message handling
suppress non-existant key errors from Nebulous::Client->find_instances()

Location:
trunk/Nebulous
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Nebulous/Changes

    r17658 r17693  
    22
    330.09
     4    - overhaul SOAP fault message handling
     5    - suppress non-existant key errors from Nebulous::Client->find_instances()
    46    - in Nebulous::Client->stat(), handle the SOAP quirk of thinking an "undef"
    57      return is a fault (even when no fault code is set).

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

    r17658 r17693  
    11# Copyright (c) 2004-2008  Joshua Hoblitt
    22#
    3 # $Id: Client.pm,v 1.48 2008-05-13 23:05:48 jhoblitt Exp $
     3# $Id: Client.pm,v 1.49 2008-05-15 03:26:11 jhoblitt Exp $
    44
    55package Nebulous::Client;
    … …  
    3838                type        => SCALAR,
    3939                optional    => 1,
    40                 default     => 'warn',
     40                default     => 'fatal',
    4141                callbacks   => {
    4242                    'is valid level' => sub {
    … …  
    115115    my $response = $self->{ 'server' }->create_object( $key, @params );
    116116    if ( $response->fault ) {
    117         $log->error( $response->faultcode, " - ", $response->faultstring );
     117        $self->set_err($response->faultstring);
     118        unless ($response->faultstring =~ /Duplicate entry/) {
     119            $log->logdie("unhandled fault - ", $self->err);
     120        }
     121
    118122        $log->debug( "leaving" );
    119123
    … …  
    151155    my $response = $self->{ 'server' }->create_object( $key, @params );
    152156    if ( $response->fault ) {
    153         $log->error( $response->faultcode, " - ", $response->faultstring );
     157        $self->set_err($response->faultstring);
     158        unless ($response->faultstring =~ /Duplicate entry/) {
     159            $log->logdie("unhandled fault - ", $self->err);
     160        }
     161
    154162        $log->debug( "leaving" );
    155163
    … …  
    204212    my $response = $self->{ 'server' }->replicate_object( $key, @params );
    205213    if ( $response->fault ) {
    206         $log->error( $response->faultcode, " - ", $response->faultstring );
    207         $log->debug( "leaving" );
    208 
    209         return;
     214        $self->set_err($response->faultstring);
     215        $log->logdie("unhandled fault - ", $self->err);
    210216    }
    211217
    … …  
    347353        my $response = $self->{ 'server' }->lock_object( $key, $type );
    348354        if ( $response->fault ) {
    349             $log->error( $response->faultcode, " - ", $response->faultstring );
    350             $log->debug( "leaving" );
    351            
    352             # don't bother to spin lock if the object doesn't exist
    353             if ( $response->faultstring =~ /storage object does not exist/ ) {
     355            $self->set_err($response->faultstring);
     356
     357            # "retry" means we couldn't get a lock because one was already held
     358            # and we should try again
     359            if ( $response->faultstring =~ /retry/ ) {
     360                $log->debug( "failed to get a $type lock..." );
     361                next;
     362            }
     363
     364            if ($response->faultstring =~ /is valid object key/) {
     365                $log->debug( "leaving" );
    354366                return;
    355367            }
    356368
    357             next;
     369            $log->logdie("unhandled fault - ", $self->err);
    358370        }
    359371
    … …  
    398410    my $response = $self->{ 'server' }->unlock_object( $key, $type );
    399411    if ( $response->fault ) {
    400         $log->error( $response->faultcode, " - ", $response->faultstring );
    401         $log->debug( "leaving" );
    402 
    403         return;
     412        $self->set_err($response->faultstring);
     413
     414        # key doesn't exist
     415        if ($response->faultstring =~ /is valid object key/) {
     416            $log->debug( "leaving" );
     417            return;
     418        }
     419
     420        # lock doesn't exist
     421        if ($response->faultstring =~ /non-existant read lock/) {
     422            $log->debug( "leaving" );
     423            return;
     424        }
     425
     426        if ($response->faultstring =~ /non-existant write lock/) {
     427            $log->debug( "leaving" );
     428            return;
     429        }
     430
     431        if ($response->faultstring =~ /can not have a read lock under a write lock/) {
     432            $log->debug( "leaving" );
     433            return;
     434        }
     435
     436        if ($response->faultstring =~ /can not have a write lock under a read lock/) {
     437            $log->debug( "leaving" );
     438            return;
     439        }
     440
     441        $log->logdie("unhandled fault - ", $self->err);
    404442    }
    405443
    … …  
    417455
    418456
    419 sub setxattr_object
     457sub setxattr
    420458{
    421459    my $self = shift;
    … …  
    442480
    443481    my $response = $self->{ 'server' }->setxattr_object( $key, $name, $value, $flags);
    444     if ( $response->fault ) {
    445         $log->error( $response->faultcode, " - ", $response->faultstring );
    446         $log->debug( "leaving" );
    447 
    448         return;
     482    if ($response->fault) {
     483        $self->set_err($response->faultstring);
     484        $log->logdie("unhandled fault - ", $self->err);
    449485    }
    450486
    … …  
    455491
    456492
    457 sub getxattr_object
     493sub getxattr
    458494{
    459495    my $self = shift;
    … …  
    472508    my $response = $self->{ 'server' }->getxattr_object( $key, $name );
    473509    if ( $response->fault ) {
    474         $log->error( $response->faultcode, " - ", $response->faultstring );
    475         $log->debug( "leaving" );
    476 
    477         return;
     510        $self->set_err($response->faultstring);
     511        $log->logdie("unhandled fault - ", $self->err);
    478512    }
    479513
    … …  
    487521
    488522
    489 sub listxattr_object
     523sub listxattr
    490524{
    491525    my $self = shift;
    … …  
    501535    my $response = $self->{ 'server' }->listxattr_object( $key );
    502536    if ( $response->fault ) {
    503         $log->error( $response->faultcode, " - ", $response->faultstring );
    504         $log->debug( "leaving" );
    505 
    506         return;
     537        $self->set_err($response->faultstring);
     538        $log->logdie("unhandled fault - ", $self->err);
    507539    }
    508540
    … …  
    516548
    517549
    518 sub removexattr_object
     550sub removexattr
    519551{
    520552    my $self = shift;
    … …  
    533565    my $response = $self->{ 'server' }->removexattr_object( $key, $name );
    534566    if ( $response->fault ) {
    535         $log->error( $response->faultcode, " - ", $response->faultstring );
    536         $log->debug( "leaving" );
    537 
    538         return;
     567        $self->set_err($response->faultstring);
     568        $log->logdie("unhandled fault - ", $self->err);
    539569    }
    540570
    … …  
    548578    my $self = shift;
    549579
    550     my ( $pattern ) = validate_pos( @_,
     580    my @args = validate_pos( @_,
    551581        {
    552582            type        => SCALAR,
    … …  
    557587    $log->debug( "entered - @_" );
    558588
    559     my $response = $self->{ 'server' }->find_objects( $pattern );
    560     if ( $response->fault ) {
    561         $log->error( $response->faultcode, " - ", $response->faultstring );
    562         $log->debug( "leaving" );
    563 
    564         return;
     589    my $response = $self->{ 'server' }->find_objects( @args );
     590    if ( $response->fault ) {
     591        $self->set_err($response->faultstring);
     592
     593        if ($response->faultstring =~ /no keys found/) {
     594            $log->debug( "leaving" );
     595            return;
     596        }
     597
     598        $log->logdie("unhandled fault - ", $self->err);
    565599    }
    566600
    … …  
    575609    $log->debug( "leaving" );
    576610
    577 # note that no keys found is returned as []
    578 
    579611    return $keys;
    580612}
    … …  
    598630    my $response = $self->{ 'server' }->find_instances( $key, @params );
    599631    if ( $response->fault ) {
    600         $log->error( $response->faultcode, " - ", $response->faultstring );
    601         $log->debug( "leaving" );
    602 
    603         return;
     632        $self->set_err($response->faultstring);
     633        # check to see if this failure is because $key doesn't exist
     634        if ($response->faultstring =~ /is valid object key/) {
     635            $log->debug( "leaving" );
     636            return;
     637        }
     638
     639        $log->logdie("unhandled fault - ", $self->err);
    604640    }
    605641
    … …  
    607643
    608644    $log->debug( "server found: @$uris" );
    609 
    610 #    foreach my $path ( @{ $uris } ) {
    611 #        $path = _get_file_path( $path );
    612 #    }
    613645
    614646    $log->debug( "leaving" );
    … …  
    806838    my $response = $self->{ 'server' }->rename_object( $key, $new_key );
    807839    if ( $response->fault ) {
    808         $log->error( $response->faultcode, " - ", $response->faultstring );
    809         $log->debug( "leaving" );
    810 
    811         return;
     840        $self->set_err($response->faultstring);
     841
     842        if ($response->faultstring =~ /is valid object key/) {
     843            $log->debug( "leaving" );
     844            return;
     845        }
     846
     847        $log->logdie("unhandled fault - ", $self->err);
    812848    }
    813849
    … …  
    839875    my $response = $self->{ 'server' }->delete_instance( $uri );
    840876    if ( $response->fault ) {
    841         $log->error( $response->faultcode, " - ", $response->faultstring );
    842         $log->debug( "leaving" );
    843 
    844         return;
     877        $self->set_err($response->faultstring);
     878
     879        if ($response->faultstring =~ /no instance is associated with uri/) {
     880            $log->debug( "leaving" );
     881            return;
     882        }
     883
     884        $log->logdie("unhandled fault - ", $self->err);
    845885    }
    846886
    … …  
    867907    my $response = $self->{ 'server' }->mounts();
    868908    if ( $response->fault ) {
    869         $log->error( $response->faultcode, " - ", $response->faultstring );
    870         $log->debug( "leaving" );
    871 
    872         return;
     909        $self->set_err($response->faultstring);
     910        $log->logdie("unhandled fault - ", $self->err);
    873911    }
    874912
    … …  
    893931    my $response = $self->{ 'server' }->stat_object( $key );
    894932    if ( $response->fault ) {
    895         $self->set_err( $response->faultcode, " - ", $response->faultstring );
    896         $log->error( $self->err );
    897         $log->debug( "leaving" );
    898 
    899         return;
     933        $self->set_err($response->faultstring);
     934        if ($response->faultstring =~ /is valid object key/) {
     935            $log->debug( "leaving" );
     936            return;
     937        }
     938
     939        $log->logdie("unhandled fault - ", $self->err);
    900940    }
    901941
    … …  
    904944    my $stats = $response->result;
    905945
    906     # SOAP can't actually send back a perl "undef" so what we get is an empty
    907     # string to indicate the key doesn't exist but there is no error.
    908     if ($stats eq "") {
    909         $stats = undef;
    910     }
    911 
    912946    $log->debug( "leaving" );
    913947
    … …  
    926960    my $self = shift;
    927961
    928     $self->{ 'err' } = shift;
     962    my $err_string = shift;
     963
     964    $self->{ 'err' } = $err_string;
     965
     966    local $Log::Log4perl::caller_depth += 1;
     967    $log->error($err_string);
    929968
    930969    return $self;

  • trunk/Nebulous/t/64_client_find_objects.t

    r16232 r17693  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 64_client_find_objects.t,v 1.2 2008-01-25 20:54:04 jhoblitt Exp $
     5# $Id: 64_client_find_objects.t,v 1.3 2008-05-15 03:26:11 jhoblitt Exp $
    66
    77use strict;
    … …  
    3131    my $keys = $neb->find_objects();
    3232
    33     # undef indicates an error
    34     is($keys, undef, 'undef is an error');
     33    # currently returning everything is turned off
     34    is($keys, undef, 'no keys found');
    3535}
    3636
    … …  
    7676    my $keys = $neb->find_objects( "bar" );
    7777
    78     is_deeply($keys, [], 'number of keys found');
     78    is($keys, undef, 'no keys found');
    7979}
    8080
Note: See TracChangeset for help on using the changeset viewer.