OEF/Script/AbstractFeeder.pm

#!/usr/bin/perl

##    --------------------------------------------------------------------------------
##    $Id: AbstractFeeder.pm,v 1.2 2003/02/11 09:48:57 joko Exp $
##    --------------------------------------------------------------------------------
##    $Log: AbstractFeeder.pm,v $
##    Revision 1.2  2003/02/11 09:48:57  joko
##    - moved notice output out of this module
##    + some fixes
##
##    Revision 1.1  2003/02/09 16:27:06  joko
##    + initial commit
##
##    --------------------------------------------------------------------------------


package OEF::Script::AbstractFeeder;

use strict;
use warnings;

#use base 'OEF::Component::Task';
use base qw( 
  DesignPattern::Object
  DesignPattern::Object::Logger
);


use Data::Dumper;
use Getopt::Long;
use Data::Transfer::Sync;


# get logger instance
my $logger = Log::Dispatch::Config->instance;

sub usage {
  my $self = shift;
  print "\n";
  print <<EOU;
  usage:
    feed.pl --source=<dbkey> --node=<node> --target=<dbkey> --action=<action> [--mapping=]
    
      source:  dbkey links to a configuration resource representing a storage (~= database)
      node:   the name of a node on the first level below the source storage
      target:  dbkey links to a configuration resource representing a storage
      action: <action> is issued on given dbkey as source node
        sync           FULL sync (PULL & PUSH)
        load|save      PULL or PUSH syncs
        import|export  IMPORT and EXPORT syncs
      mapping:  future use: specify name of a perl module / xml file which describes/outlines the mapping
EOU
  exit;
}

sub readoptions {
  my $self = shift;

  GetOptions(
    'source=s' => \$self->{opt}->{source},
    'source-type=s' => \$self->{opt}->{'source-type'},
    'source-node=s' => \$self->{opt}->{'source-node'},
    'target=s' => \$self->{opt}->{target},
    'target-node=s' => \$self->{opt}->{'target-node'},
    'action=s' => \$self->{opt}->{action},
    'mapping-module=s' => \$self->{opt}->{'mapping-module'},
    'prepare' => \$self->{opt}->{prepare},
    'fresh' => \$self->{opt}->{fresh},
    'help' => \&usage,
    # v1-API-spec backward compatibility
    'node=s' => \$self->{opt}->{'node'},
  );
}  

sub getoptions {
  my $self = shift;
  return $self->{opt};
}

sub setoptions {
  my $self = shift;
  my $options = shift;
  # FIXME: is this really true?
  $self->{opt} = $options;
}

sub getoptions_old {
  my $self = shift;
  GetOptions(
    'source=s' => \$self->{opt}->{source},
    'node=s' => \$self->{opt}->{node},
    'target=s' => \$self->{opt}->{target},
    'action=s' => \$self->{opt}->{action},
    'mapping=s' => \$self->{opt}->{mapping},
    'prepare' => \$self->{opt}->{prepare},
    'fresh' => \$self->{opt}->{fresh},
  );
  
  # TODO: use some core function/method (e.g. 'init_hash($hashref, $value, $force = 0)')
  $self->{opt}->{source} ||= '';
  $self->{opt}->{node} ||= '';
  $self->{opt}->{target} ||= '';
  $self->{opt}->{action} ||= '';
  $self->{opt}->{mapping} ||= '';
  $self->{opt}->{prepare} ||= '';
  $self->{opt}->{fresh} ||= '';
  
}


sub set {
  my $self = shift; 
  my $data = { @_ };
  #return bless $self, $class;
  foreach (keys %$data) {
#print $_, "\n";
    $self->{$_} = $data->{$_};
  }
}

sub run {
  my $self = shift;
  $self->_before_run();
  $self->prepare();
  #$self->tellWhatIAmDoing();
  $self->sync();
}

sub prepare {
  my $self = shift;

  # TODO: 
  # - move this to Data::Transfer::Sync::checkOptions!!!
  # - use 'syncable'???

  #if ($self->{app}->{config}->{databases}->{$self->{opt}->{target}}->{syncable}) {

    my $mode = '';
    my $erase = 0;
    my $import = 0;
    $mode = 'PUSH' if $self->{opt}->{action} eq 'save';
    $mode = 'PULL' if $self->{opt}->{action} eq 'load';
    if ($self->{opt}->{action} eq 'import') {
      $mode = 'PULL';
      $erase = 1;
      $import = 1;
    }
    if ($self->{opt}->{action} eq 'export') {
      $mode = 'PUSH';
      $erase = 1;
      #$import = 1;
    }
    $self->{opt}->{mode} = $mode;
    $self->{opt}->{erase} = $erase;
    $self->{opt}->{import} = $import;

}

sub sync {
  my $self = shift;

  # trace
    #print Dumper($self);
    #print Dumper($self->{opt});
    #exit;
  
  # proposal to introduce full backward-compatibility mechanism
  # "just" have many APIs with different versions accessing the very same core ...
    # is api-version specified?
    my $sync_version = $self->{opt}->{sv};
    $sync_version ||= 'V1';

  # create a new synchronization object
    my $sync = Data::Transfer::Sync->new( 'sync_version' => $sync_version, __parent => $self );

  # trace
    #print Dumper($self);
    #print Dumper($self);
    #exit;
    

  # configure the synchronization-object
    $sync->configure(
      source => {
        storage => {
          #handle => $mapiStorage,
          handle => $self->{app}->{$self->{opt}->{source}},
          #isIdentAuthority => $self->{app}->{config}->{{$self->{opt}->{source}},
          #isChecksumAuthority => 1,
          #writeProtected => 1,
        },
      },
      target => {
        storage => {
          #handle => $ldapStorage,
          handle => $self->{app}->{$self->{opt}->{target}},
          #idAuthority => 1,
          #isChecksumAuthority => 1,
          #isWriteProtected => 0,
        },
      },
      verbose => 1,
    );
    
  # TODO:
=pod
  $sync->configure(
    'source.storage.handle' => ...,
    'target.storage.handle' => ...,
  );
=cut

  # trace
    #print Dumper($sync);
    #exit;

  # read, mungle & check the options
    $sync->setArguments($self->{opt});
    $sync->readArguments();

  # trace
    #print Dumper($sync);
    
  # finally, run the sync ...
    $sync->syncNodes();

}


1;
1	joko	1.1	#!/usr/bin/perl
2
3			## --------------------------------------------------------------------------------
4	joko	1.3	## $Id: AbstractFeeder.pm,v 1.2 2003/02/11 09:48:57 joko Exp $
5	joko	1.1	## --------------------------------------------------------------------------------
6	joko	1.2	## $Log: AbstractFeeder.pm,v $
7	joko	1.3	## Revision 1.2 2003/02/11 09:48:57 joko
8			## - moved notice output out of this module
9			## + some fixes
10			##
11	joko	1.2	## Revision 1.1 2003/02/09 16:27:06 joko
12			## + initial commit
13			##
14	joko	1.1	## --------------------------------------------------------------------------------
15
16
17			package OEF::Script::AbstractFeeder;
18
19			use strict;
20			use warnings;
21
22			#use base 'OEF::Component::Task';
23			use base qw(
24			DesignPattern::Object
25			DesignPattern::Object::Logger
26			);
27
28
29			use Data::Dumper;
30			use Getopt::Long;
31	joko	1.3	use Data::Transfer::Sync;
32	joko	1.1
33
34			# get logger instance
35			my $logger = Log::Dispatch::Config->instance;
36
37			sub usage {
38			my $self = shift;
39			print "\n";
40			print <<EOU;
41			usage:
42			feed.pl --source=<dbkey> --node=<node> --target=<dbkey> --action=<action> [--mapping=]
43
44			source: dbkey links to a configuration resource representing a storage (~= database)
45			node: the name of a node on the first level below the source storage
46			target: dbkey links to a configuration resource representing a storage
47			action: <action> is issued on given dbkey as source node
48			sync FULL sync (PULL & PUSH)
49			load\|save PULL or PUSH syncs
50			import\|export IMPORT and EXPORT syncs
51			mapping: future use: specify name of a perl module / xml file which describes/outlines the mapping
52			EOU
53			exit;
54			}
55
56	joko	1.3	sub readoptions {
57	joko	1.1	my $self = shift;
58
59			GetOptions(
60			'source=s' => \$self->{opt}->{source},
61			'source-type=s' => \$self->{opt}->{'source-type'},
62			'source-node=s' => \$self->{opt}->{'source-node'},
63			'target=s' => \$self->{opt}->{target},
64			'target-node=s' => \$self->{opt}->{'target-node'},
65			'action=s' => \$self->{opt}->{action},
66			'mapping-module=s' => \$self->{opt}->{'mapping-module'},
67			'prepare' => \$self->{opt}->{prepare},
68			'fresh' => \$self->{opt}->{fresh},
69			'help' => \&usage,
70			# v1-API-spec backward compatibility
71			'node=s' => \$self->{opt}->{'node'},
72			);
73			}
74	joko	1.3
75			sub getoptions {
76			my $self = shift;
77			return $self->{opt};
78			}
79
80			sub setoptions {
81			my $self = shift;
82			my $options = shift;
83			# FIXME: is this really true?
84			$self->{opt} = $options;
85			}
86	joko	1.1
87			sub getoptions_old {
88			my $self = shift;
89			GetOptions(
90			'source=s' => \$self->{opt}->{source},
91			'node=s' => \$self->{opt}->{node},
92			'target=s' => \$self->{opt}->{target},
93			'action=s' => \$self->{opt}->{action},
94			'mapping=s' => \$self->{opt}->{mapping},
95			'prepare' => \$self->{opt}->{prepare},
96			'fresh' => \$self->{opt}->{fresh},
97			);
98
99			# TODO: use some core function/method (e.g. 'init_hash($hashref, $value, $force = 0)')
100			$self->{opt}->{source} \|\|= '';
101			$self->{opt}->{node} \|\|= '';
102			$self->{opt}->{target} \|\|= '';
103			$self->{opt}->{action} \|\|= '';
104			$self->{opt}->{mapping} \|\|= '';
105			$self->{opt}->{prepare} \|\|= '';
106			$self->{opt}->{fresh} \|\|= '';
107
108			}
109
110
111			sub set {
112			my $self = shift;
113			my $data = { @_ };
114			#return bless $self, $class;
115			foreach (keys %$data) {
116			#print $_, "\n";
117			$self->{$_} = $data->{$_};
118			}
119			}
120
121			sub run {
122			my $self = shift;
123			$self->_before_run();
124			$self->prepare();
125	joko	1.2	#$self->tellWhatIAmDoing();
126	joko	1.1	$self->sync();
127			}
128
129			sub prepare {
130			my $self = shift;
131
132			# TODO:
133			# - move this to Data::Transfer::Sync::checkOptions!!!
134			# - use 'syncable'???
135
136			#if ($self->{app}->{config}->{databases}->{$self->{opt}->{target}}->{syncable}) {
137
138			my $mode = '';
139			my $erase = 0;
140			my $import = 0;
141			$mode = 'PUSH' if $self->{opt}->{action} eq 'save';
142			$mode = 'PULL' if $self->{opt}->{action} eq 'load';
143			if ($self->{opt}->{action} eq 'import') {
144			$mode = 'PULL';
145			$erase = 1;
146			$import = 1;
147			}
148			if ($self->{opt}->{action} eq 'export') {
149			$mode = 'PUSH';
150			$erase = 1;
151			#$import = 1;
152			}
153			$self->{opt}->{mode} = $mode;
154			$self->{opt}->{erase} = $erase;
155			$self->{opt}->{import} = $import;
156
157			}
158
159			sub sync {
160			my $self = shift;
161
162			# trace
163			#print Dumper($self);
164			#print Dumper($self->{opt});
165			#exit;
166
167			# proposal to introduce full backward-compatibility mechanism
168			# "just" have many APIs with different versions accessing the very same core ...
169			# is api-version specified?
170			my $sync_version = $self->{opt}->{sv};
171			$sync_version \|\|= 'V1';
172
173			# create a new synchronization object
174	joko	1.2	my $sync = Data::Transfer::Sync->new( 'sync_version' => $sync_version, __parent => $self );
175	joko	1.1
176			# trace
177			#print Dumper($self);
178	joko	1.2	#print Dumper($self);
179			#exit;
180
181	joko	1.1
182			# configure the synchronization-object
183			$sync->configure(
184			source => {
185			storage => {
186			#handle => $mapiStorage,
187			handle => $self->{app}->{$self->{opt}->{source}},
188	joko	1.2	#isIdentAuthority => $self->{app}->{config}->{{$self->{opt}->{source}},
189			#isChecksumAuthority => 1,
190			#writeProtected => 1,
191	joko	1.1	},
192			},
193			target => {
194			storage => {
195			#handle => $ldapStorage,
196			handle => $self->{app}->{$self->{opt}->{target}},
197	joko	1.2	#idAuthority => 1,
198			#isChecksumAuthority => 1,
199			#isWriteProtected => 0,
200	joko	1.1	},
201			},
202			verbose => 1,
203			);
204	joko	1.2
205			# TODO:
206			=pod
207			$sync->configure(
208			'source.storage.handle' => ...,
209			'target.storage.handle' => ...,
210			);
211			=cut
212	joko	1.1
213			# trace
214			#print Dumper($sync);
215			#exit;
216
217			# read, mungle & check the options
218			$sync->setArguments($self->{opt});
219			$sync->readArguments();
220
221			# trace
222			#print Dumper($sync);
223
224			# finally, run the sync ...
225			$sync->syncNodes();
226
227			}
228
229
230			1;
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26