/[cvs]/nfo/perl/libs/Data/Transfer/Sync.pm
ViewVC logotype

Diff of /nfo/perl/libs/Data/Transfer/Sync.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by joko, Fri Nov 29 04:45:50 2002 UTC revision 1.3 by joko, Sun Dec 1 22:26:59 2002 UTC
# Line 6  Line 6 
6  ##  ##
7  ##    ----------------------------------------------------------------------------------------  ##    ----------------------------------------------------------------------------------------
8  ##    $Log$  ##    $Log$
9    ##    Revision 1.3  2002/12/01 22:26:59  joko
10    ##    + minor cosmetics for logging
11    ##
12    ##    Revision 1.2  2002/12/01 04:43:25  joko
13    ##    + mapping deatil entries may now be either an ARRAY or a HASH
14    ##    + erase flag is used now (for export-operations)
15    ##    + expressions to refer to values inside deep nested structures
16    ##    - removed old mappingV2-code
17    ##    + cosmetics
18    ##    + sub _erase_all
19    ##
20  ##    Revision 1.1  2002/11/29 04:45:50  joko  ##    Revision 1.1  2002/11/29 04:45:50  joko
21  ##    + initial check in  ##    + initial check in
22  ##  ##
# Line 23  use Data::Dumper; Line 34  use Data::Dumper;
34  use misc::HashExt;  use misc::HashExt;
35  use libp qw( md5_base64 );  use libp qw( md5_base64 );
36  use libdb qw( quotesql hash2Sql );  use libdb qw( quotesql hash2Sql );
37  use Data::Transform::OO qw( hash2object );  use Data::Transform::Deep qw( hash2object refexpr2perlref );
38  use Data::Compare::Struct qw( getDifference isEmpty );  use Data::Compare::Struct qw( getDifference isEmpty );
39    
40  # get logger instance  # get logger instance
# Line 147  sub syncNodes { Line 158  sub syncNodes {
158    $logger->info( __PACKAGE__ . "->syncNodes: source=$self->{meta}->{source}->{dbkey}/$self->{meta}->{source}->{node} $direction_arrow target=$self->{meta}->{target}->{dbkey}/$self->{meta}->{target}->{node}" );    $logger->info( __PACKAGE__ . "->syncNodes: source=$self->{meta}->{source}->{dbkey}/$self->{meta}->{source}->{node} $direction_arrow target=$self->{meta}->{target}->{dbkey}/$self->{meta}->{target}->{node}" );
159    
160    # build mapping    # build mapping
161      # incoming: and Array of node map entries (Array or Hash) - e.g.
162      #   [ 'source:item_name' => 'target:class_val' ]
163      #   { source => 'event->startDateTime', target => 'begindate' }
164    foreach (@{$self->{args}->{mapping}}) {    foreach (@{$self->{args}->{mapping}}) {
165      my @key1 = split(':', $_->[0]);      if (ref $_ eq 'ARRAY') {
166      my @key2 = split(':', $_->[1]);        my @entry1 = split(':', $_->[0]);
167      push @{$self->{meta}->{$key1[0]}->{childnodes}}, $key1[1];        my @entry2 = split(':', $_->[1]);
168      push @{$self->{meta}->{$key2[0]}->{childnodes}}, $key2[1];        my $descent = [];
169          my $node = [];
170          $descent->[0] = $entry1[0];
171          $descent->[1] = $entry2[0];
172          $node->[0] = $entry1[1];
173          $node->[1] = $entry2[1];
174          push @{$self->{meta}->{$descent->[0]}->{childnodes}}, $node->[0];
175          push @{$self->{meta}->{$descent->[1]}->{childnodes}}, $node->[1];
176        } elsif (ref $_ eq 'HASH') {
177          foreach my $entry_key (keys %$_) {
178            my $entry_val = $_->{$entry_key};
179            push @{$self->{meta}->{$entry_key}->{childnodes}}, $entry_val;
180          }
181        }
182    
183    }    }
184    
185    # check partners/nodes: does partner exist / is node available?    # check partners/nodes: does partner exist / is node available?
# Line 192  sub syncNodes { Line 220  sub syncNodes {
220      #$self->_erase_all($opts->{source_node});      #$self->_erase_all($opts->{source_node});
221    }    }
222        
223      # erase flag means: erase the target
224      #if ($opts->{erase}) {
225      if ($self->{args}->{erase}) {
226        # TODO: move this method to the scope of the synchronization core and wrap it around different handlers
227        #print "ERASE", "\n";
228        $self->_erase_all('target');
229      }
230    
231    $self->_syncNodes();    $self->_syncNodes();
232    
233  }  }
# Line 427  sub _syncNodes { Line 463  sub _syncNodes {
463    print "\n" if $self->{verbose};    print "\n" if $self->{verbose};
464        
465    # build user-message from some stats    # build user-message from some stats
466      my $msg = "stats: $tc";      my $msg = "statistics: $tc";
467            
468      if ($tc->{error_per_row}) {      if ($tc->{error_per_row}) {
469        $msg .= "\n";        $msg .= "\n";
470        $msg .= "errors:" . "\n";        $msg .= "errors from \"error_per_row\":" . "\n";
471        $msg .= Dumper($tc->{error_per_row});        $msg .= Dumper($tc->{error_per_row});
472      }      }
473            
# Line 572  sub _buildMap { Line 608  sub _buildMap {
608        for (my $mapidx = 0; $mapidx <= $#childnodes; $mapidx++) {        for (my $mapidx = 0; $mapidx <= $#childnodes; $mapidx++) {
609          #my $map_right = $self->{args}->{mapping}->{$key};          #my $map_right = $self->{args}->{mapping}->{$key};
610                    
611            $self->{node}->{source}->{propcache} = {};
612            $self->{node}->{target}->{propcache} = {};
613            
614          # get property name          # get property name
615          $self->{node}->{source}->{propcache}->{property} = $self->{meta}->{source}->{childnodes}->[$mapidx];          $self->{node}->{source}->{propcache}->{property} = $self->{meta}->{source}->{childnodes}->[$mapidx];
616          $self->{node}->{target}->{propcache}->{property} = $self->{meta}->{target}->{childnodes}->[$mapidx];          $self->{node}->{target}->{propcache}->{property} = $self->{meta}->{target}->{childnodes}->[$mapidx];
# Line 589  sub _buildMap { Line 628  sub _buildMap {
628            $self->{node}->{source}->{propcache}->{value} = $self->{node}->{source}->{payload}->{$self->{node}->{source}->{propcache}->{property}};            $self->{node}->{source}->{propcache}->{value} = $self->{node}->{source}->{payload}->{$self->{node}->{source}->{propcache}->{property}};
629          }          }
630          #$self->{node}->{map}->{$key} = $value;          #$self->{node}->{map}->{$key} = $value;
631            
632            # detect expression
633            # for transferring deeply nested structures described by expressions
634            #print "val: $self->{node}->{source}->{propcache}->{value}", "\n";
635            if ($self->{node}->{source}->{propcache}->{property} =~ s/^expr://) {
636              
637              # create an anonymous sub to act as callback target dispatcher
638                my $cb_dispatcher = sub {
639                  #print "===============  CALLBACK DISPATCHER", "\n";
640                  #print "ident: ", $self->{node}->{source}->{ident}, "\n";
641                  #return $self->{node}->{source}->{ident};
642                  
643                };
644              
645    
646    #print Dumper($self->{node});
647              
648              # build callback map for helper function
649              #my $cbmap = { $self->{meta}->{source}->{IdentProvider}->{arg} => $cb_dispatcher };
650              my $cbmap = {};
651              my $value = refexpr2perlref($self->{node}->{source}->{payload}, $self->{node}->{source}->{propcache}->{property}, $cbmap);
652              $self->{node}->{source}->{propcache}->{value} = $value;
653            }
654    
655          # encode values dependent on type of underlying storage here - expand cases...          # encode values dependent on type of underlying storage here - expand cases...
656          my $storage_type = $self->{meta}->{target}->{storage}->{locator}->{type};          my $storage_type = $self->{meta}->{target}->{storage}->{locator}->{type};
657          if ($storage_type eq 'DBI') {          if ($storage_type eq 'DBI') {
658            # ...for sql            # ...for sql
659            $self->{node}->{source}->{propcache}->{value} = quotesql($self->{node}->{source}->{propcache}->{value});            $self->{node}->{source}->{propcache}->{value} = quotesql($self->{node}->{source}->{propcache}->{value});
660          } elsif ($storage_type eq 'Tangram') {          }
661             elsif ($storage_type eq 'Tangram') {
662              # iso? utf8 already possible?
663            
664          } elsif ($storage_type eq 'LDAP') {          } elsif ($storage_type eq 'LDAP') {
665            # TODO: encode utf8 here?            # TODO: encode utf8 here?
666          }          }
# Line 606  sub _buildMap { Line 671  sub _buildMap {
671        }        }
672      }      }
673    
 #print "self->{entry}: ", Dumper($self->{node}), "\n"; exit;  
   
     # for transferring deeply nested structures described by expressions  
     # this currently does not work!  
     # TODO: re-enable this!  
     if ($self->{args}->{mappingV2}) {  
         
       # apply mapping from $self->{args}->{mappingV2} to $self->{node}->{map}  
       foreach my $mapStep (@{$self->{args}->{mappingV2}}) {  
           
         # prepare left/right keys/values  
         my $left_key = $mapStep->{left};  
         my $left_val = _resolveMapStepExpr( $self->{node}->{source}->{payload}, $mapStep->{left} );  
         my $right_key = $mapStep->{right};  
         my $right_val = ( $mapStep->{right} );  
         #print "map: $map_right", "\n";  
           
         if ($mapStep->{method}) {  
           if ($mapStep->{method} eq 'v:1') {  
             $left_val = $left_key;  
           }  
         }  
   
         #$self->{node}->{map}->{$key} = $value;  
         #if ( grep(!/$right_key/, @{$self->{args}->{exclude}}) ) {  
           $self->{node}->{map}->{$right_key} = $self->{R}->quoteSql($left_val);  
         #}  
       }  
     }  
674            
675    # TODO: $logger->dump( ... );    # TODO: $logger->dump( ... );
676    #$logger->debug( "sqlmap:" . "\n" . Dumper($self->{node}->{map}) );    #$logger->debug( "sqlmap:" . "\n" . Dumper($self->{node}->{map}) );
# Line 1063  sub _prepareNode_DummyIdent { Line 1099  sub _prepareNode_DummyIdent {
1099  # TODO: handle this in an abstract way (wipe out use of 'source' and/or 'target' inside core)  # TODO: handle this in an abstract way (wipe out use of 'source' and/or 'target' inside core)
1100  sub _otherSide {  sub _otherSide {
1101    my $self = shift;    my $self = shift;
1102    my $side = shift;    my $descent = shift;
1103    return 'source' if $side eq 'target';    return 'source' if $descent eq 'target';
1104    return 'target' if $side eq 'source';    return 'target' if $descent eq 'source';
1105    return '';    return '';
1106  }  }
1107    
1108    sub _erase_all {
1109      my $self = shift;
1110      my $descent = shift;
1111      #my $node = shift;
1112      my $node = $self->{meta}->{$descent}->{node};
1113      $self->{meta}->{$descent}->{storage}->eraseAll($node);
1114    }
1115    
1116    
1117  =pod  =pod
1118    
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.3
MailToCvsAdmin">MailToCvsAdmin
 ViewVC Help
Powered by ViewVC 1.1.26 RSS 2.0 feed