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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1.1 by joko,
Sun Jan 19 01:23:04 2003 UTC
+revision 1.5 by joko,
Tue Feb 11 05:26:04 2003 UTC
 Line 6
  ##
  ##    ----------------------------------------------------------------------------------------
  ##    $Log$
+ ##    Revision 1.5  2003/02/11 05:26:04  joko
+ ##    + sub _tellWhatIWillDo
+ ##    + re-enabled "branch to execution path for special targets" mechanism
+ ##
+ ##    Revision 1.4  2003/02/09 05:03:02  joko
+ ##    + minor fix regarding namespace of api versioning extension module
+ ##
+ ##    Revision 1.3  2003/02/09 04:59:27  joko
+ ##    + api versioning mechanism
+ ##    + major structure changes
+ ##    - refactored code to sister modules
+ ##
+ ##    Revision 1.2  2003/01/20 16:59:48  joko
+ ##    + cosmetics and debugging
+ ##
  ##    Revision 1.1  2003/01/19 01:23:04  joko
  ##    + new from Data/Transfer/Sync.pm
  ##
  ##    ----------------------------------------------------------------------------------------
  package Data::Transfer::Sync::API;
  use strict;
  use warnings;
+ use base qw( DesignPattern::Bridge );
  use mixin::with qw( Data::Transfer::Sync );
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -   main
  use Data::Dumper;
+ use Hash::Merge qw( merge );
- use Data::Compare::Struct qw( getDifference isEmpty );
- use Data::Transform::Deep qw( merge );
+ use Data::Compare::Struct qw( isEmpty );
  # get logger instance
  my $logger = Log::Dispatch::Config->instance;
- sub _init {
+ sub api_constructor {
    my $self = shift;
+   $logger->debug( __PACKAGE__ . "->api_constructor: Loading API");
+   $self->_loadVersionExtensions();
  }
- sub checkOptions {
-   my $self = shift;
-   my $opts = shift;
-   my $result = 1;
-   # check - do we have a target node?
-   if (!$opts->{target_node}) {
-     $logger->warning( __PACKAGE__ . "->checkOptions: Error while resolving resource metadata - no 'target node' could be determined.");
-     $result = 0;
-   }
-   # check - do we have a mapping?
-   if (!$opts->{mapping} && !$opts->{mapping_module}) {
+ sub _loadVersionExtensions {
-     $logger->warning( __PACKAGE__ . "->checkOptions: Error while resolving resource metadata - no 'mapping' could be determined.");
+   my $self = shift;
-     $result = 0;
+   my $syncVersion = $self->{sync_version};
-   }
+   $syncVersion ||= '';
+   $logger->debug( __PACKAGE__ . "->loadVersionExtensions( version='$syncVersion' )");
-   return $result;
+   #print Dumper($self);
+   #exit;
+   my $module = "API::$syncVersion";
+   $self->load($module);
  }
- sub checkOptionsV2 {
+ sub configure {
    my $self = shift;
- #print Dumper($self->{options});
+   $logger->debug( __PACKAGE__ . "->configure");
-   my $result = 1;
+   my @args = @_;
-   # check - do we have a target node?
+   if (!isEmpty(\@args)) {
-   if (!$self->{options}->{target}->{nodeName}) {
+     my %properties = @_;
-     $logger->warning( __PACKAGE__ . "->checkOptionsV2: No target given - please check metadata declaration.");
+     # merge args to properties
-     $result = 0;
+     #map { $self->{$_} = $properties{$_}; } keys %properties;
-   }
+ #print Dumper($self);
+ #print Dumper(\%properties);
-   # check - do we have a mapping?
+     if ($self->{options}) {
-   if (!$self->{options}->{fieldmap}) {
+     my $options_new = merge($self->{options}, \%properties);
-     $logger->warning( __PACKAGE__ . "->checkOptionsV2: Error while resolving resource metadata - no 'fieldmap' could be determined.");
+ #print Dumper($options_new);
-     $result = 0;
+     $self->{options} = $options_new;
+ #print Dumper($self->{options});
+     } else {
+       $self->{options} = \%properties;
+     }
+     $self->_init();
+     #$self->_initV1();
+   } else {
+     #print "no args!", "\n";
    }
-   # TODO: extend!
-   return $result;
+ #print Dumper($self);
+ #exit;
+   $self->{state}->{configured} = 1;
+   return 1;
  }
- sub prepareOptions {
+ sub setArguments {
    my $self = shift;
-   my $opts = shift;
+   my $args_raw = shift;
+   $self->{args_raw} = $args_raw;
+ }
+ sub readArguments {
+   my $self = shift;
+     my %syncConfig;
+     tie %syncConfig, 'Tie::IxHash';
+     %syncConfig = (
+       map => {
+         moduleName => $self->{args_raw}->{'mapping-module'},
+       },
+       source => {
+         dbKey => $self->{args_raw}->{source},
+         nodeType => $self->{args_raw}->{'source-type'},
+         nodeName => $self->{args_raw}->{'source-node'},
+       },
+       target => {
+         dbKey => $self->{args_raw}->{target},
+         nodeName => $self->{args_raw}->{'target-node'},
+       },
+       process => {
+         mode => $self->{args_raw}->{mode},
+         erase => $self->{args_raw}->{erase},
+         import => $self->{args_raw}->{import},
+         prepare => $self->{args_raw}->{prepare},
+       },
+ #      metadata => {
+ #        config => $self->{config_metadata},
+ #      }
+     );
+   $self->{args} = \%syncConfig;
+ }
- #print Dumper($opts);
+ # TODO: some feature to show off the progress of synchronization (cur/max * 100)
+ sub syncNodes {
+   my $self = shift;
+   my $args = shift;
+   $logger->debug( __PACKAGE__ . "->syncNodes: starting" );
+ #print Dumper($self);
  #exit;
-   $opts->{mode} ||= '';
+ #print Dumper($self->{options});
-   $opts->{erase} ||= 0;
+   $self->_prepareOptions();
-   $opts->{prepare} ||= 0;
-   #$opts->{import} ||= 0;
-   if (!$opts->{source_node}) {
-     $logger->error( __PACKAGE__ . "->prepareOptions failed: Please specify source-node!");
-     return;
-   }
-   $logger->notice( __PACKAGE__ . "->prepareOptions( source_node $opts->{source_node} mode $opts->{mode} erase $opts->{erase} prepare $opts->{prepare} )");
-   #if (!$opts->{mapping} || !$opts->{mapping_module}) {
+ #print Dumper($self->{options});
-   if (!$opts->{mapping}) {
-     $logger->warning( __PACKAGE__ . "->prepareOptions: No mapping supplied - please check key 'mappings' in global configuration or specify additional argument '--mapping'.");
-     #return;
-   }
-   $opts->{mapping_module} ||= $opts->{mapping};
+   if (!$self->checkOptions()) {
-   my $evstring = "use $opts->{mapping_module};";
+     $logger->critical( __PACKAGE__ . "->syncNodes: 'Data::Transfer::Sync::checkOptions' failed.");
-   eval($evstring);
-   if ($@) {
-     $logger->warning( __PACKAGE__ . "->prepareOptions: error while trying to access mapping - $@");
      return;
    }
-   # resolve mapping metadata (returned from sub)
+   if (!$self->{state}->{configured}) {
-   my $mapObject = $opts->{mapping_module}->new();
+     $logger->critical( __PACKAGE__ . "->syncNodes: Synchronization object is not configured/initialized correctly." );
-   #print Dumper($map);
-   my $source_node_name = $opts->{source_node};
-   # check if mapping for certain node is contained in mapping object
-   if (!$mapObject->can($source_node_name)) {
-     $logger->warning( __PACKAGE__ . "->prepareOptions: Can't access mapping for node \"$source_node_name\" - please check $opts->{mapping_module}.");
      return;
    }
-   my $map = $mapObject->$source_node_name;
- #print Dumper($map);
+   #print Dumper($args);
-   # check here if "target" is actually a CODEref - in this case: resolve it - deprecated!!! ???
+   # remember arguments through the whole processing
-   if (ref $map->{target} eq 'CODE') {
+   $self->{args} = $args;
-     $map->{target} = $map->{target}->($source_node_name);
-   }
-   # resolve expressions (on nodename-level) here
-   if ($map->{target} =~ m/^(code|expr):(.+?)$/) {
-     my $target_dynamic_type = $1;
-     my $target_dynamic_expression = $2;
-     if (lc $target_dynamic_type eq 'code') {
- #      $map->{target} = $mapObject->$target_dynamic_expression($map);
-     }
-   }
-   # remove asymmetries from $map (patch keys)
+   # hash to hold and/or fill in metadata required for the processing
-   $map->{source_node} = $map->{source}; delete $map->{source};
+   $self->{meta} = {};
-   $map->{target_node} = $map->{target}; delete $map->{target};
-   $map->{mapping} = $map->{details}; delete $map->{details};
+   # hash to sum up results
-   $map->{direction} = $map->{mode}; delete $map->{mode};
+   # TODO: re-implement! (sync-statistics???)
-   # defaults (mostly for backward-compatibility)
-   $map->{source_node} ||= $source_node_name;
-   $map->{source_ident} ||= 'storage_method:id';
-   $map->{target_ident} ||= 'property:oid';
-   $map->{direction} ||= $opts->{mode};         # | PUSH | PULL | FULL
-   $map->{method} ||= 'checksum';                # | timestamp
-   $map->{source_exclude} ||= [qw( cs )];
-   # merge map to opts
+   # detect synchronization method to determine which optical symbol (directed arrow) to use
-   map { $opts->{$_} = $map->{$_}; } keys %$map;
+   my $mode = $self->{args}->{mode};   # V1
+   $mode ||= $self->{options}->{process}->{mode};    # V2
+   my $direction_arrow = $self->_getDirectedArrow($mode);
+   # determine code versions
+     my $code_metadata_version;
+     # first, try to use version supplied by mapping-metadata
+     $code_metadata_version = $self->{options}->{metadata}->{version};
+     # if not set, inherit from global 'sync_version'
+     $code_metadata_version ||= $self->{sync_version};
+   # load additional code from versioned namespace into current instance
+     my $dynModule = "Metadata::$code_metadata_version";
+     $self->load($dynModule);
- #print Dumper($opts);
+   # build metadata using versioned code and stuff
+     $self->options2metadata();
+     $self->options2metadata_accessor();
+   # branch to execution path for special targets
+   # detect for option 'handler' which could be a CODEref
+     if ($self->{options}->{handler} && ref $self->{options}->{handler} eq 'CODE') {
+       $logger->info( __PACKAGE__ . "->syncNodes: Running (special handler code - no generic sync!) on '$self->{options}->{target}->{dbKey}' with MODE $self->{options}->{process}->{mode}, NODE $self->{options}->{target}->{address}");
+       #print Dumper($self);
+       #exit;
+       # don't do this any more - it wasn't very nice somehow ...
+       #$self->{options}->{handler}->($self->{app}, $self->{options});
+       # .... now: better let the parent application scope handle this via callback
+         # not any more required for this: $self->{app} inside here (which isn't the app we mean here)
+         # required for this: getting the options out of here: establish some getter method! ($self->getOptions(...))
+         # so....
+         #$self->{__bridge}->{parent_ref}->
+       # ahh okay, DesignPattern::Bridge moves closer to some Class::Inner!???
+         # so...
+         # similar like above - but it isn't very nice anyway ...  (no privateness, but: who cares?)
+         #print Dumper($self->{__bridge});
+         # just take the global application instance and
+         # throw it into the context of the mapping module - this is heavy!  ;-) (but again, who cares...)
+         # TODO: handle this more abstract *sometimes*
+         #$self->{options}->{handler}->($self->{__bridge}->{parent}->{app}, $self->{options});
+         $self->{options}->{handler}->($self->{__bridge}->{parent}->{process}, $self->{options});
+       return;
+     }
+   # TODO: execution path branch V2!!!
+     # option1: wrap this via callback to parent scope (like current impl. mechanism)
+     # option2: branch directly from here (this needs refactoring of the sub handler)
+   # tracing
+     #print Dumper($self);
+     #exit;
+   $logger->info( __PACKAGE__ . "->syncNodes: source=$self->{meta}->{source}->{dbKey}/$self->{meta}->{source}->{nodeName} [$self->{meta}->{source}->{nodeType}] $direction_arrow target=$self->{meta}->{target}->{dbKey}/$self->{meta}->{target}->{nodeName} [$self->{meta}->{target}->{nodeType}]" );
+   return if !$self->buildFieldmapping();
+   return if !$self->_touchNodeSet();
+   return if !$self->_prepare_sync();
+   $self->_tellWhatIWillDo();
+   # tracing
+     #print Dumper($self);
+     #print Dumper($self->{args});
+     #print Dumper($self->{options});
+     #print Dumper($self->{meta});
+     #print Dumper($self->{metadata});
+     #exit;
-   # TODO: move this to checkOptions...
+   # finally, tell the core to start the synchronization process
+   $self->_run();
-   # check - do we have a target?
+ }
-   if (!$opts->{target_node}) {
-     $logger->warning( __PACKAGE__ . "->prepareOptions: No target given - please check metadata declaration.");
-     return;
-   }
-   #return $opts;
+ my $c_string_default = '';
-   return 1;
+ sub c_string {
+   my $value = shift;
+   $value ||= "[$c_string_default]";
+   return $value;
+ }
+ sub _tellWhatIWillDo {
+   my $self = shift;
+ #return;
+   # trace
+     #print Dumper($self->{meta});
+     #exit;
+   $c_string_default = 'n/a';
+   my $source = c_string($self->{opt}->{'source'});
+   my $source_node = c_string($self->{opt}->{'source-node'});
+   my $source_type = c_string($self->{opt}->{'source-type'});
+   my $target = c_string($self->{opt}->{'target'});
+   my $target_node = c_string($self->{opt}->{'target-node'});
+   my $target_type = c_string($self->{opt}->{'target-type'});
+   my $mapping_module = c_string($self->{opt}->{'mapping-module'});
+   my $mode = uc c_string($self->{opt}->{'mode'});
+   #my $ql = "$mode INTO $source NODE $source_node TYPE $source_type SELECT NODE $target_node TYPE $target_type FROM $target USING MODULE $mapping_module;";
+   #$logger->notice( __PACKAGE__ . ": $ql" );
+   my $ql = <<EOT;
+   FETCH DATA
+     FROM STORAGE $self->{meta}->{source}->{dbKey}
+     AT NODE $self->{meta}->{source}->{accessorName}.$self->{meta}->{source}->{nodeName}
+     USING IDENTIFIER $self->{meta}->{source}->{IdentProvider}->{method}.$self->{meta}->{source}->{IdentProvider}->{arg}
+   CONVERT DATA
+     CAST FROM $self->{meta}->{source}->{nodeType} TO $self->{meta}->{target}->{nodeType}
+     MAP ATTRIBUTES FROM @{$self->{meta}->{source}->{childnodes}} TO @{$self->{meta}->{target}->{childnodes}}
+   STORE DATA
+     TO STORAGE $self->{meta}->{target}->{dbKey}
+     AT NODE $self->{meta}->{target}->{accessorName}.$self->{meta}->{target}->{nodeName}
+     USING IDENTIFIER $self->{meta}->{target}->{IdentProvider}->{method}.$self->{meta}->{target}->{IdentProvider}->{arg}
+ EOT
+   $logger->notice( $ql );
+   #exit;
+   return;
+   my $actioning = ucfirst $self->{opt}->{'action'} . 'ing';
+   # FIXME: this is weird!
+   my $long = <<EOT;
+     - $actioning data of type $target_type and
+       filtered by $target_node from the storage named $target
+       to the storage named $source - filtered by $source_node.
+     - Will attempt to convert the data to $source_type.
+ EOT
+   chomp($long);
+   $logger->notice( __PACKAGE__ . ": $long" );
  }
- sub prepareOptionsV2 {
+ sub _prepareOptions {
    my $self = shift;
-   my $opts = shift;
+   my $opts = $self->{args};
    # patch options
+     $opts->{source}->{nodeName} ||= '';
+     $opts->{target}->{nodeName} ||= '';
      $opts->{process}->{mode} ||= '';
-     $opts->{process}->{prepare} ||= 0;
      $opts->{process}->{erase} ||= 0;
+     $opts->{process}->{prepare} ||= 0;
+   # defaults (mostly for backward-compatibility to V1 -
+   # but code mungled here out of prepareOptions_V1 from Version::V1)
+     $opts->{metadata}->{syncMethod} ||= 'checksum';                # | timestamp
+     $opts->{source}->{ident} ||= 'storage_method:id';
+     $opts->{source}->{exclude} ||= [qw( cs )];
+     $opts->{target}->{ident} ||= 'property:oid';
+     #$map->{source_node} ||= $source_node_name;
+     #$map->{direction} ||= $opts->{mode};         # | PUSH | PULL | FULL
    # pre-check options
      if (!$self->_preCheckOptions($opts)) {
-       $logger->error( __PACKAGE__ . "->prepareOptionsV2: _preCheckOptions failed.");
+       $logger->error( __PACKAGE__ . "->_prepareOptions: _preCheckOptions failed.");
        return;
      }
    # inform user about option preparation
-   $logger->notice( __PACKAGE__ . "->prepareOptionsV2( mode='$opts->{process}->{mode}', source->node='$opts->{source}->{nodeName}', target->node='$opts->{target}->{nodeName}', erase='$opts->{process}->{erase}', prepare='$opts->{process}->{prepare}' )");
+   $logger->debug( __PACKAGE__ . "->_prepareOptions( source.node='$opts->{source}->{nodeName}', target.node='$opts->{target}->{nodeName}', mode='$opts->{process}->{mode}', e='$opts->{process}->{erase}', p='$opts->{process}->{prepare}' )");
    # try to load mapping-metadata-container
-   #my $mapObject = getNewPerlObjectByPkgName($opts->{map}->{moduleName});
+     # How? Create a new instance of the given
-   my $mapObject = DesignPattern::Object->fromPackage($opts->{map}->{moduleName});
+     # perl module/package name in ->{...}->{moduleName}.
+     # This instance is used later in the innards of the sync,
+     # that's why the module (class) should have a certain layout
+     # enabling the core to use it for gathering metadata while processing.
+     my $mapObject = DesignPattern::Object->fromPackage($opts->{map}->{moduleName});
    # try to resolve map from metadata-container
-Line 205 
 sub prepareOptionsV2 {
+Line 367 
 sub prepareOptionsV2 {
      my $source_nodeType = $opts->{source}->{nodeType};
      # check if mapping for certain node is contained in mapping object
-     if (!$mapObject->can($source_nodeType)) {
+     if (!$mapObject || !$mapObject->can($source_nodeType)) {
-       $logger->warning( __PACKAGE__ . "->prepareOptionsV2: Can't access mapping for source-type=\"$source_nodeType\" - please check \"$opts->{map}->{moduleName}\".");
+       $logger->warning( __PACKAGE__ . "->_prepareOptions: Can't access mapping for source-type=\"$source_nodeType\" - please check \"$opts->{map}->{moduleName}\".");
        return;
      }
      # get map
      my $map = $mapObject->$source_nodeType;
      #print Dumper($map);
- =pod
+     my $map_version = $map->{metadata}->{version};
+     # FIXME: backward compatibility
+     if (!$map_version) {
+       $self->options_to_V2($map);
+     }
+     # trace
+       #print Dumper($map);
+       #exit;
+       #print "ref: ", ref $map->{target}, "\n";
+       #print "target: ", $map->{target}, "\n";
      # check here if "target" is actually a CODEref - in this case: resolve it - deprecated!!! ???
      if (ref $map->{target}->{address} eq 'CODE') {
        $map->{target}->{address} = $map->{target}->{address}->($source_nodeType);
      }
      # resolve expressions (on nodename-level) here
-     if ($map->{target}->{address} =~ m/^(code|expr):(.+?)$/) {
+     elsif ($map->{target}->{address} =~ m/^(code|expr):(.+?)$/) {
        my $target_dynamic_type = $1;
        my $target_dynamic_expression = $2;
        if (lc $target_dynamic_type eq 'code') {
          $map->{target} = $mapObject->$target_dynamic_expression($map);
        }
      }
- =cut
-   #map { $opts->{$_} = $map->{$_}; } keys %$map;
+   # merging - V1
-   my $opts_merged = merge( $opts, $map );
+     #map { $opts->{$_} = $map->{$_}; } keys %$map;
+     # trace
+       #print Dumper($self->{options});
+   # merging - V2
+     # merge local map with local opts
+       # delete undef'd items in $map
+       # enable cloning
+       # FIXME: do we really need cloning here? trade safety/encapsulation for speed?
+       Hash::Merge::set_clone_behavior(1);
+       Hash::Merge::set_behavior( 'RIGHT_PRECEDENT' );
+       #Hash::Merge::set_behavior( 'STORAGE_PRECEDENT' );
+       #Hash::Merge::set_behavior( 'RETAINMENT_PRECEDENT' );
+       # TODO: add an option to Hash::Merge not to overwrite set items with undefined/empty/not assigned ones
+       my $locals_merged = merge( $opts, $map );
+     # trace
+       #print Dumper($opts);
+       #print Dumper($map);
+       #print Dumper($locals_merged);
+       #exit;
+     # merge local-merged ones with instance-wide options
+       Hash::Merge::set_clone_behavior(0);
+       $self->{options} = merge( $self->{options}, $locals_merged );
+     # trace
+       #print Dumper($self->{options});
+       #exit;
-   $self->{options} = $opts_merged;
    $self->{state}->{options_ready} = 1;
    return 1;
  }
- sub configure {
-   my $self = shift;
-   my @args = @_;
-   if (!isEmpty(\@args)) {
-     my %properties = @_;
-     # merge args to properties
-     map { $self->{$_} = $properties{$_}; } keys %properties;
-     $self->_init();
-     $self->_initV1();
-   } else {
-     #print "no args!", "\n";
-   }
-   #print Dumper($self);
-   $self->{state}->{configured} = 1;
-   return 1;
- }
- sub configureV2 {
-   my $self = shift;
-   my @args = @_;
-   if (!isEmpty(\@args)) {
-     my %properties = @_;
-     # merge args to properties
-     #map { $self->{$_} = $properties{$_}; } keys %properties;
-     $self->{options} = merge($self->{options}, \%properties);
-     $self->_init();
-     #$self->_initV1();
-   } else {
-     #print "no args!", "\n";
-   }
- #print Dumper($self);
-   $self->{state}->{configured} = 1;
+ sub _preCheckOptions {
-   return 1;
- }
- # TODO: some feature to show off the progress of synchronization (cur/max * 100)
- sub syncNodes {
    my $self = shift;
-   my $args = shift;
+   my $opts = shift;
-   if (!$self->{state}->{configured}) {
+   # trace
-     $logger->critical( __PACKAGE__ . "->syncNodes: Synchronization object is not configured/initialized correctly." );
+     #print Dumper($opts);
+     #exit;
+   if (!$opts->{process}->{mode}) {
+     $logger->error( __PACKAGE__ . "->_preCheckOptions failed: Please specify \"--action=(load|save)\".");
      return;
    }
-   # remember arguments through the whole processing
+   # the type of the to-be-synced item
-   $self->{args} = $args;
+   if (!$opts->{source}->{nodeType}) {
+     $logger->error( __PACKAGE__ . "->_preCheckOptions failed: Please specify \"source-type\".");
-   $logger->debug( __PACKAGE__ . "->syncNodes: starting" );
+     return;
-   # hash to hold and/or fill in metadata required for the processing
-   $self->{meta} = {};
-   # hash to sum up results
-   my $direction_arrow = '';
-   # detect synchronization method to determine which optical symbol (directed arrow) to use
-   if (lc $self->{args}->{direction} eq 'push') {
-     $direction_arrow = '->';
-   } elsif (lc $self->{args}->{direction} eq 'pull') {
-     $direction_arrow = '<-';
-   } elsif (lc $self->{args}->{direction} eq 'full') {
-     $direction_arrow = '<->';
-   } else {
    }
+   # the name of the (container-) node the items are listed in
-   print Dumper($self);
+   if (!$opts->{source}->{nodeName}) {
-   #exit;
+     $logger->error( __PACKAGE__ . "->_preCheckOptions failed: Please specify \"source-node\".");
+     return;
-   if (!$self->{metadata}->{version} || $self->{metadata}->{version} < 0.2) {
-     $self->_buildMetadataV1();
-   } else {
-     $self->_buildMetadataV1();
-     #$self->_buildMetadataV2();
    }
- #print Dumper($self);
+   # a "map"-declaration which module to use for mapping- and/or lookup-purposes
- #print Dumper($self->{meta});
+   if (!$opts->{map}) {
+     $logger->warning( __PACKAGE__ . "->_preCheckOptions: No mapping supplied - please check key 'map|mappings' in global configuration or specify additional argument '--mapping-module'.");
-   $logger->info( __PACKAGE__ . "->syncNodes: source=$self->{meta}->{source}->{dbkey}/$self->{meta}->{source}->{node} $direction_arrow target=$self->{meta}->{target}->{dbkey}/$self->{meta}->{target}->{node}" );
+     return;
+   }
-   $self->_buildFieldmappingV1();
+   if (!$opts->{map}->{moduleName}) {
+     $logger->warning( __PACKAGE__ . "->_preCheckOptions: Currently only perl-modules can provide mappings: Please specify one with '--mapping-module=My::Mapping::Module'.");
+     return;
+   }
- #print Dumper($self->{meta});
+   return 1;
-   # check partners/nodes: does partner exist / is node available?
-   foreach my $partner (keys %{$self->{meta}}) {
-     # 1. check partners & storages
-     if (!$self->{meta}->{$partner}) {
-       $logger->critical( __PACKAGE__ . "->syncNodes: Could not find partner '$partner' in configuration metadata." );
-       return;
-     }
-     my $dbkey = $self->{meta}->{$partner}->{dbkey};
+ }
- #print Dumper($self->{meta});
-     if (!$self->{meta}->{$partner}->{storage}) {
-       $logger->critical( __PACKAGE__ . "->syncNodes: Could not access storage of partner '$partner' (named '$dbkey'), looks like a configuration-error." );
-       return;
-     }
-     # TODO:
-     # 2. check if partners (and nodes?) are actually available....
-     # eventually pre-check mode of access-attempt (read/write) here to provide an "early-croak" if possible
- #    print Dumper($self->{meta}->{$partner}->{storage}->{locator});
-     my $dbType = $self->{meta}->{$partner}->{storage}->{locator}->{type};
- #print "dbType: $dbType", "\n";
-     # 3. check nodes
-     next if $dbType eq 'DBI';    # HACK for DBD::CSV - re-enable for others
-     # get node-name
- #      print Dumper($self);
-     #print Dumper($self->{meta}->{$partner});
-     #print "��", $self->{meta}->{$partner}->{node}, "\n";
-     my $nodename = $self->{meta}->{$partner}->{node};
-     # check if nodename is actually a CODEref, execute it to get a mapped/filtered target-nodename
- #print "nodename: $nodename", "\n";
+ sub _prepare_sync {
-     $logger->info( __PACKAGE__ . "->syncNodes: Accessing dbType=\"$dbType\", nodename=\"$nodename\"." );
+   my $self = shift;
- =pod
-     #print "----", ref $nodename, "\n";
-     if ($nodename =~ m/CODE/) {
-       print Dumper($self);
-       #exit;
-       $nodename = $nodename->($nodename);
-     }
- =cut
-     if (!$self->{meta}->{$partner}->{storage}->existsChildNode($nodename)) {
-       $logger->critical( __PACKAGE__ . "->syncNodes: Could not reach node \"$nodename\" at partner \"$partner\"." );
-       return;
-     }
-   }
    # TODO:
    #   + if action == PUSH: start processing
    #  -+  if action == PULL: swap metadata and start processing
    #   -  if action == FULL: start processing, then swap metadata and (re-)start processing
- #print Dumper($self->{args});
+   #print "dir: ", $self->{args}->{direction}, "\n";
    # manipulate metainfo according to direction of synchronization
-   if (lc $self->{args}->{direction} eq 'push') {
+   if (lc $self->{options}->{process}->{mode} eq 'push') {
-     # just do it ...
+     # just do it ...    (don't modify any metadata)
-   } elsif (lc $self->{args}->{direction} eq 'pull') {
-     #print "=======SWAP", "\n";
+   } elsif (lc $self->{options}->{process}->{mode} eq 'pull') {
-     # swap
+     # swap source and target metadata
+     # TODO: introduce different mechanism to make more then two partners (descents) possible
      ($self->{meta}->{source}, $self->{meta}->{target}) =
          ($self->{meta}->{target}, $self->{meta}->{source});
-   } elsif (lc $self->{args}->{direction} eq 'full') {
+     #($self->{options}->{source}, $self->{options}->{target}) =
+     #    ($self->{options}->{target}, $self->{options}->{source});
+   } elsif (lc $self->{options}->{process}->{mode} eq 'full') {
+     # TODO:
+     # do a pull first and a push afterwards
+     # this requires us to be called somehow recursively - just one recursion level  ;-)
    } else {
+     # TODO: are there any other synchronization modes besides PULL, PUSH, FULL?
    }
    # import flag means: prepare the source node to be syncable
-Line 422 
 sub syncNodes {
+Line 534 
 sub syncNodes {
      #print "ERASE", "\n";
      $self->_erase_all('target');
    }
+   return 1;
-   $self->_syncNodes();
+ }
+ sub _getDirectedArrow {
+   my $self = shift;
+   my $mode = shift;
+   $mode ||= '';
+   if (lc $mode eq 'push') {
+     return '->';
+   } elsif (lc $mode eq 'pull') {
+     return '<-';
+   } elsif (lc $mode eq 'full') {
+     return '<->';
+   } else {
+     return '';
+   }
  }
 ;

 Legend:



Removed from v.1.1
 


changed lines


 
Added in v.1.5
 Legend:



Removed from v.1.1
 


changed lines


 
Added in v.1.5
-Removed from v.1.1
+Added in v.1.5

MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26