OEF/Script/AbstractFeeder.pm

#!/usr/bin/perl

##    --------------------------------------------------------------------------------
##    $Id: feed.pl,v 1.4 2003/01/23 14:44:35 janosch Exp $
##    --------------------------------------------------------------------------------
##    $Log: feed.pl,v $
##    --------------------------------------------------------------------------------


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;


# 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 getoptions {
  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_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();
}

my $c_string_default = '';
sub c_string {
  my $value = shift;
  $value ||= "[$c_string_default]";
  return $value;
}

sub tellWhatIAmDoing {
  my $self = shift;
  
  $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" );
  $logger->notice( $ql );
  
  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 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 );

  # trace
    #print Dumper($self);

  # configure the synchronization-object
    $sync->configure(
      source => {
        storage => {
          #handle => $mapiStorage,
          handle => $self->{app}->{$self->{opt}->{source}},
          writeProtected => 1,
        },
      },
      target => {
        storage => {
          #handle => $ldapStorage,
          handle => $self->{app}->{$self->{opt}->{target}},
          idAuthority => 1,
          isChecksumAuthority => 1,
          writeProtected => 0,
        },
      },
      verbose => 1,
    );

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