Subversion Repositories DevTools

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
6887 dpurdie 1 
########################################################################
2 
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
3 
#
4 
# Module name   : rmMerge_suck.pl
5 
# Module type   : JATS Utility
6 
# Compiler(s)   : Perl
7 
# Environment(s): jats
8 
#
9 
# Description   : Extact package-version data from RM
10 
#
11 
# Usage         : See POD at the end of this file
12 
#
13 
#......................................................................#
14 
 
15 
require 5.008_002;
16 
use strict;
17 
use warnings;
18 
 
19 
use Pod::Usage;
20 
use Getopt::Long;
21 
 
22 
use JatsError;
23 
use JatsRmApi;
24 
use JatsSystem;
25 
use FileUtils;
26 
use ConfigurationFile;
27 
use File::Copy;
28 
use DBI;
29 
my $RM_DB;
30 
my $VERSION = "1.0";
31 
my @newRMCred = ('NEW', 'jdbc:oracle:thin:@auawsards002:1521:RELEASEM', 'RM_READONLY', 'Tp8WmmDKMq2Z');
32 
 
33 
my $opt_reuse=1;
34 
my $opt_help=0;
35 
my $opt_verbose=0;
36 
my $opt_debug=0;
37 
my $opt_outfile;
38 
 
39 
my $pname;
40 
my $pversion;
41 
my $pvid;
42 
our %rmData;
43 
my @keyFields = qw(PV_ID RTAG_ID PROJ_ID PKG_ID CREATOR_ID MODIFIER_ID OWNER_ID LAST_PV_ID BS_ID VCS_TYPE_ID PKG_IDEXT BE_ID BSA_ID BM_ID DPV_ID DPKG_ID DOC_ID TEST_ID USER_ID ACTTYPE_ID NOTE_ID BUILD_ID TESTRUN_ID LICENCE);
44 
my %keyFields = map {$_ => 1} @keyFields;
45 
my %keyFieldsData;
46 
 
47 
 
48 
#-------------------------------------------------------------------------------
49 
# Function        : Mainline Entry Point
50 
#
51 
# Description     :
52 
#
53 
# Inputs          :
54 
#
55 
my $result = GetOptions (
56 
                "help:+"        => \$opt_help,
57 
                "manual:3"      => \$opt_help,
58 
                "verbose:+"     => \$opt_verbose,
59 
                "debug:+"       => \$opt_debug,
60 
                "reuse!"        => \$opt_reuse,
61 
                "outfile:s"     => \$opt_outfile,
62 
                );
63 
 
64 
                #
65 
                #   UPDATE THE DOCUMENTATION AT THE END OF THIS FILE !!!
66 
                #
67 
 
68 
#
69 
#   Process help and manual options
70 
#
71 
pod2usage(-verbose => 0, -message => "Version: $VERSION") if ($opt_help == 1 || ! $result);
72 
pod2usage(-verbose => 1) if ( $opt_help == 2 );
73 
pod2usage(-verbose => 2) if ( $opt_help > 2 );
74 
pod2usage(-verbose => 0, -message => "Version: $VERSION") if ( $#ARGV != 1 );
75 
 
76 
#
77 
#   Configure the error reporting rmMerge_process now that we have the user options
78 
#
79 
ErrorConfig( 'name'    =>'SUCK',
80 
             'verbose' => $opt_verbose,
81 
             'debug' => $opt_debug,
82 
            );
83 
 
84 
#
85 
#
86 
$pname = $ARGV[0];
87 
$pversion = $ARGV[1];
88 
 
89 
#   Generate the output filename
90 
#
91 
$opt_outfile = join('.', $pname, $pversion, 'rminfo', 'txt') unless ($opt_outfile);
92 
my $localDataStore = $opt_outfile;
93 
 
94 
$ENV{GBE_RM_LOCATION} = $newRMCred[1];
95 
$ENV{GBE_RM_USERNAME} = $newRMCred[2];
96 
$ENV{GBE_RM_PASSWORD} = $newRMCred[3];
97 
connectRM(\$RM_DB) unless ( $RM_DB );
98 
 
99 
$pvid = GetPvid();
100 
Error ("Package Version not found: $pname, $pversion") unless defined $pvid;
101 
Message("Extacting: $pname $pversion, PVID: $pvid");
102 
 
103 
#
104 
#   Insert some basic information
105 
#
106 
$rmData{METADATA}{NAME} = $pname;
107 
$rmData{METADATA}{VERSION} = $pversion;
108 
$rmData{METADATA}{PV_ID} = $pvid;
109 
 
110 
GetTableData('PACKAGE_VERSIONS');
111 
GetTableData('PACKAGE_DEPENDENCIES');
112 
GetTableData('PACKAGE_BUILD_ENV');
113 
GetTableData('PACKAGE_BUILD_INFO');
114 
GetTableData('PACKAGE_DOCUMENTS');
115 
GetTableData('PACKAGE_METRICS');
116 
GetTableData('ACTION_LOG');
117 
GetTableData('ADDITIONAL_NOTES');
118 
GetTableData('BUILD_INSTANCES');
119 
GetTableData('LICENCING');
120 
GetTableData('UNIT_TESTS');
121 
GetTableData('RELEASE_COMPONENTS');
122 
GetTableData('JIRA_ISSUES');
123 
 
124 
#
125 
#   Now some indirect information
126 
#       Test Runs - linked by build_id
127 
GetTestRuns();
128 
 
129 
#
130 
#   Have the basic data - don't know about blobs !!!!
131 
#   Need to extract, as text, those fields that are used for linkage purposes
132 
#   PV_IDs, PKG_IDS
133 
#
134 
GetXrefsUsers(qw(CREATOR_ID MODIFIER_ID OWNER_ID USER_ID));
135 
GetXrefsPvid(qw(PV_ID LAST_PV_ID DPV_ID));
136 
GetXrefsPkg(qw(PKG_ID DPKG_ID ));
137 
GetXrefsActType(qw( ACTTYPE_ID ));
138 
GetXrefsRtagId(qw( RTAG_ID ));
139 
GetXrefsLicence(qw( LICENCE ));
140 
 
141 
GetXrefsIgnore(qw( TEST_ID TESTRUN_ID DOC_ID BUILD_ID NOTE_ID));        # Primary keys - ignore
142 
GetXrefsIgnore(qw( BE_ID BM_ID BSA_ID BS_ID VCS_TYPE_ID));              # Assume these have not changed
143 
 
144 
GetPackageHistory();
145 
 
146 
disconnectRM(\$RM_DB);
147 
ErrorDoExit();
148 
saveLocalData();
149 
 
150 
my @unProcessed;
151 
foreach my $tableName (keys %keyFieldsData) {
152 
    foreach my $name ( keys %{$keyFieldsData{$tableName}}) {
153 
        foreach my $key ( keys %{$keyFieldsData{$tableName}{$name}}) {
154 
            push @unProcessed, "$tableName, $name, $key";
155 
        }
156 
    }
157 
}
158 
 
159 
if (@unProcessed) {
160 
    Error("Some the key fields have not been rmMerge_processed", @unProcessed )
161 
}
162 
 
163 
exit 0;
164 
 
165 
#-------------------------------------------------------------------------------
166 
# Function        : GetPackageHistory
167 
#
168 
# Description     : Get significant ( non ripple package versions ) since the Build
169 
#                   system spilt ( pvid = 1150630)
170 
#
171 
# Inputs          :
172 
#
173 
# Returns         :
174 
#
175 
sub GetPackageHistory
176 
{
177 
    Verbose ("GetPackageHistory");
178 
    my $m_sqlstr =  "SELECT pv_id, pkg_version,  Modified_stamp, User_name, Comments" .
179 
                    " FROM ( SELECT * " .
180 
                    "  FROM " .
181 
                    "    (SELECT pv.build_type,pv.last_pv_id AS raw_last_pvid ,pv_id,pv.pkg_version,DECODE(pv.pv_id, pv.last_pv_id, NULL, pv.last_pv_id) AS last_pv_id, comments, to_char(pv.modified_stamp, 'DD-MON-YYYY HH24:MM') as modified_stamp, u.user_name" .
182 
                    "    FROM release_manager.package_versions pv, users u " .
183 
                    "    WHERE u.user_id = pv.modifier_id and pv.PKG_ID IN (SELECT pkg_id FROM release_manager.package_versions pv WHERE pv.pv_id = $pvid ) " .
184 
                    "    ) " .
185 
                    "    START WITH pv_id =  $pvid " .
186 
                    "    CONNECT BY nocycle prior last_pv_id = pv_id " .
187 
                    "  ) WHERE build_type != 'Y'  and pv_id > 1150630";
188 
 
189 
 
190 
    my @row;
191 
    my $tag = 'PV_HISTORY_DATA';
192 
    my $sth = $RM_DB->prepare($m_sqlstr);
193 
    if ( defined($sth) )
194 
    {
195 
        if ( $sth->execute( ) )
196 
        {
197 
            if ( $sth->rows )
198 
            {
199 
                while ( @row = $sth->fetchrow_array )
200 
                {
201 
                    my @data = @row;
202 
                    escapeRowData(\@data);
203 
                    push @{$rmData{$tag}}, \@data;
204 
                }
205 
            }
206 
            $sth->finish();
207 
        }
208 
        else
209 
        {
210 
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
211 
        }
212 
    }
213 
    else
214 
    {
215 
        Error("Prepare failure" );
216 
    }
217 
 
218 
    #
219 
    #   Fudge the META data information
220 
    #
221 
    $tag = 'PV_HISTORY' .  '_NAMES';
222 
    push @{$rmData{$tag}}, [ 'PV_ID', 'NUMBER', 'N', '1' ];
223 
    push @{$rmData{$tag}}, [ 'PKG_VERSION', 'VARCHAR2', 'N', '2' ];
224 
    push @{$rmData{$tag}}, [ 'MODIFIED_STAMP', 'VARCHAR2', 'N', '3' ];
225 
    push @{$rmData{$tag}}, [ 'USER_NAME', 'VARCHAR2', 'N', '4' ];
226 
    push @{$rmData{$tag}}, [ 'COMMENTS', 'VARCHAR2', 'N', '5' ];
227 
}
228 
 
229 
 
230 
#-------------------------------------------------------------------------------
231 
# Function        : GetXrefsCommon
232 
#
233 
# Description     : Common code for getting cross reference data
234 
#
235 
# Inputs          : $refFields      - Ref to fields to rmMerge_process
236 
#                   $tag           - Tag base name
237 
#                   $sql            - Sql fragment
238 
#
239 
# Returns         :
240 
#
241 
sub GetXrefsCommon
242 
{
243 
    my ($refFields, $tag, $sql) = @_;
244 
    my %idList;
245 
 
246 
    foreach my $name (@$refFields) {
247 
        $rmData{XREF_MAP}{$name} = $tag;
248 
    }
249 
 
250 
    foreach my $tableName (keys %keyFieldsData) {
251 
        foreach my $name (@$refFields) {
252 
            foreach my $key ( keys %{$keyFieldsData{$tableName}{$name}}) {
253 
                $idList{ $key} = 1;
254 
            }
255 
        }
256 
    }
257 
    return unless %idList;
258 
 
259 
    #
260 
    #   Get all the table data
261 
    #
262 
    my @row;
263 
    my %xRef;
264 
    my $m_sqlstr = $sql . " in (". join(',',keys %idList) .")";
265 
    my $sth = $RM_DB->prepare($m_sqlstr);
266 
    if ( defined($sth) )
267 
    {
268 
        if ( $sth->execute( ) )
269 
        {
270 
            if ( $sth->rows )
271 
            {
272 
                while ( @row = $sth->fetchrow_array )
273 
                {
274 
                   $xRef{$row[0]} = $row[1];
275 
                }
276 
            }
277 
            $sth->finish();
278 
        }
279 
        else
280 
        {
281 
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
282 
        }
283 
    }
284 
    else
285 
    {
286 
        Error("Prepare failure" );
287 
    }
288 
 
289 
    #
290 
    #   Create data structures
291 
    #
292 
    foreach my $tableName (keys %keyFieldsData) {
293 
        my $tName = $tableName . "_XREF";
294 
        foreach my $name (@$refFields) {
295 
            foreach my $key ( keys %{$keyFieldsData{$tableName}{$name}}) {
296 
                DebugDumpData("Xref", \%xRef) unless exists $xRef{$key};
297 
                ReportError("Cannot locate cross ref for $tableName, $name, $key") unless exists $xRef{$key} ;
298 
                $rmData{$tName}{$tag}{$key} = $xRef{$key};
299 
            }
300 
            delete $keyFieldsData{$tableName}{$name};
301 
        }
302 
    }
303 
}
304 
 
305 
#-------------------------------------------------------------------------------
306 
# Function        : GetXrefsLicence
307 
#
308 
# Description     : Get cross references to other entites
309 
#
310 
# Inputs          : list of keyFieldData keys to rmMerge_process
311 
#
312 
# Returns         :
313 
#
314 
sub GetXrefsLicence
315 
{
316 
    GetXrefsCommon( \@_, 'LICENCE',"select licence, name from release_manager.licences where licence");
317 
}
318 
 
319 
#-------------------------------------------------------------------------------
320 
# Function        : GetXrefsActType
321 
#
322 
# Description     : Get cross references to other entites
323 
#
324 
# Inputs          : list of keyFieldData keys to rmMerge_process
325 
#
326 
# Returns         :
327 
#
328 
sub GetXrefsRtagId
329 
{
330 
    GetXrefsCommon( \@_, 'RTAG_ID',"select rtag_id, rtag_name from release_tags where rtag_id");
331 
}
332 
 
333 
#-------------------------------------------------------------------------------
334 
# Function        : GetXrefsActType
335 
#
336 
# Description     : Get cross references to other entites
337 
#
338 
# Inputs          : list of keyFieldData keys to rmMerge_process
339 
#
340 
# Returns         :
341 
#
342 
sub GetXrefsActType
343 
{
344 
    GetXrefsCommon( \@_, 'ACT_TYPE',"select acttype_id, name from release_manager.action_type where acttype_id");
345 
}
346 
 
347 
#-------------------------------------------------------------------------------
348 
# Function        : GetXrefsIgnore
349 
#
350 
# Description     : Ignore the cross references to other entites
351 
#
352 
# Inputs          : list of keyFieldData keys to rmMerge_process
353 
#
354 
# Returns         :
355 
#
356 
sub GetXrefsIgnore
357 
{
358 
    my (@refFields) = @_;
359 
    foreach my $tableName (keys %keyFieldsData) {
360 
        foreach my $name (@refFields) {
361 
            delete $keyFieldsData{$tableName}{$name};
362 
        }
363 
    }
364 
}
365 
 
366 
#-------------------------------------------------------------------------------
367 
# Function        : GetXrefsPkg
368 
#
369 
# Description     : Get cross references to other entites
370 
#
371 
# Inputs          : list of keyFieldData keys to rmMerge_process
372 
#
373 
# Returns         :
374 
#
375 
sub GetXrefsPkg
376 
{
377 
    GetXrefsCommon( \@_, 'PKG_ID',"select p.pkg_id, p.pkg_name from release_manager.packages p where pkg_id");
378 
}
379 
 
380 
#-------------------------------------------------------------------------------
381 
# Function        : GetXrefsPvid
382 
#
383 
# Description     : Get cross references to other entites
384 
#
385 
# Inputs          : list of keyFieldData keys to rmMerge_process
386 
#
387 
# Returns         :
388 
#
389 
sub GetXrefsPvid
390 
{
391 
    GetXrefsCommon( \@_, 'PV_ID',"select pv.pv_id, p.pkg_name ||'$;'|| pv.pkg_version from release_manager.packages p, release_manager.package_versions pv where p.pkg_id = pv.pkg_id and pv.pv_id");
392 
}
393 
 
394 
#-------------------------------------------------------------------------------
395 
# Function        : GetXrefsUsers
396 
#
397 
# Description     : Get cross references to other entites
398 
#
399 
# Inputs          : list of keyFieldData keys to rmMerge_process
400 
#
401 
# Returns         :
402 
#
403 
sub GetXrefsUsers
404 
{
405 
    GetXrefsCommon( \@_, 'USER_ID',"select user_id, user_name from access_manager.users where user_id");
406 
}
407 
 
408 
 
409 
#-------------------------------------------------------------------------------
410 
# Function        : GetTestRuns
411 
#
412 
# Description     : Get TEST_RUN Data
413 
#
414 
# Inputs          :
415 
#
416 
# Returns         :
417 
#
418 
sub GetTestRuns
419 
{
420 
    my ($tableName) = 'TEST_RUN';
421 
    my (@row);
422 
    my @names;
423 
    Verbose ("GetTestRuns");
424 
 
425 
    #
426 
    #   Get the list of table names
427 
    #
428 
    my $names = GetColumnNames($tableName);
429 
    $rmData{$tableName . '_NAMES'} = $names;
430 
    #
431 
    #   Scan the colums looking for key names
432 
    #
433 
    my %xref;
434 
    my $index = 0;
435 
    foreach my $entry ( @{$names}) {
436 
        my $fname = $entry->[0];
437 
        if ( exists $keyFields{$fname}) {
438 
            $xref{$index} = $fname;
439 
        } elsif ( $fname =~ m~_ID~ ) {
440 
            Error("Consider $fname in $tableName");
441 
        }
442 
        $index++;
443 
    }
444 
 
445 
 
446 
    #
447 
    #   Get all the table data
448 
    #
449 
    my $m_sqlstr = "select tr.* from release_manager.BUILD_INSTANCES bi, release_manager.TEST_RUN tr where tr.build_id = bi.build_id and bi.pv_id = $pvid";
450 
    my $sth = $RM_DB->prepare($m_sqlstr);
451 
    if ( defined($sth) )
452 
    {
453 
        if ( $sth->execute( ) )
454 
        {
455 
            if ( $sth->rows )
456 
            {
457 
                while ( @row = $sth->fetchrow_array )
458 
                {
459 
                    my @data = @row;
460 
                    push @{$rmData{$tableName . '_DATA'}}, \@data;
461 
 
462 
                    #
463 
                    #   Extract key linkage fields as we go
464 
                    #
465 
                    while (my($index, $fname) = each %xref) {
466 
                        my $data = $row[$index];
467 
                        next unless defined $data;
468 
                        next if length($data) == 0;
469 
                        $keyFieldsData{$tableName}{$fname}{$row[$index]} = 1;
470 
                    }
471 
 
472 
                }
473 
            }
474 
            $sth->finish();
475 
        }
476 
        else
477 
        {
478 
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
479 
        }
480 
    }
481 
    else
482 
    {
483 
        Error("Prepare failure" );
484 
    }
485 
}
486 
 
487 
 
488 
#-------------------------------------------------------------------------------
489 
# Function        : GetPvid
490 
#
491 
# Description     : Get the packages pvid
492 
#
493 
# Inputs          :
494 
#
495 
# Returns         : The pvid
496 
#
497 
sub GetPvid
498 
{
499 
 
500 
    my (@row);
501 
    my $pvid;
502 
    Verbose ("GetPvid");
503 
 
504 
    my $m_sqlstr = "select pv_id from packages p, package_versions pv where p.pkg_name = '$pname' and pv.pkg_version = '$pversion' and p.pkg_id = pv.pkg_id";
505 
    my $sth = $RM_DB->prepare($m_sqlstr);
506 
    if ( defined($sth) )
507 
    {
508 
        if ( $sth->execute( ) )
509 
        {
510 
            if ( $sth->rows )
511 
            {
512 
                while ( @row = $sth->fetchrow_array )
513 
                {
514 
                    #print join(' ', @row), "\n";
515 
                    $pvid = $row[0];
516 
                    last;
517 
                }
518 
            }
519 
            $sth->finish();
520 
        }
521 
        else
522 
        {
523 
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
524 
        }
525 
    }
526 
    else
527 
    {
528 
        Error("Prepare failure" );
529 
    }
530 
 
531 
    return $pvid;
532 
}
533 
 
534 
#-------------------------------------------------------------------------------
535 
# Function        : GetTableData
536 
#
537 
# Description     : Get all data from a table for the package
538 
#                   Its pretty dumb
539 
#
540 
# Inputs          : $tableName
541 
#
542 
# Returns         :
543 
#
544 
sub GetTableData
545 
{
546 
    my ($tableName) = @_;
547 
    my (@row);
548 
    my @names;
549 
    Verbose ("GetTableData: $tableName");
550 
 
551 
    #
552 
    #   Get the list of table names
553 
    #
554 
    my $names = GetColumnNames($tableName);
555 
    $rmData{$tableName . '_NAMES'} = $names;
556 
 
557 
    #
558 
    #   Scan the colums looking for key names
559 
    #
560 
    my %xref;
561 
    my $index = 0;
562 
    foreach my $entry ( @{$names}) {
563 
        my $fname = $entry->[0];
564 
        if ( exists $keyFields{$fname}) {
565 
            $xref{$index} = $fname;
566 
        } elsif ( $fname =~ m~_ID~ ) {
567 
            Error("Consider $fname in $tableName");
568 
        }
569 
        $index++;
570 
    }
571 
 
572 
    #
573 
    #   Get all the table data
574 
    #
575 
    my $m_sqlstr = "select * from release_manager.$tableName where pv_id=$pvid";
576 
    my $sth = $RM_DB->prepare($m_sqlstr);
577 
    if ( defined($sth) )
578 
    {
579 
        if ( $sth->execute( ) )
580 
        {
581 
            if ( $sth->rows )
582 
            {
583 
                while ( @row = $sth->fetchrow_array )
584 
                {
585 
                    my @data = @row;
586 
                    escapeRowData(\@data);
587 
                    push @{$rmData{$tableName . '_DATA'}}, \@data;
588 
 
589 
                    #
590 
                    #   Extract key linkage fields as we go
591 
                    #
592 
                    while (my($index, $fname) = each %xref) {
593 
                        my $data = $row[$index];
594 
                        next unless defined $data;
595 
                        next if length($data) == 0;
596 
                        $keyFieldsData{$tableName}{$fname}{$row[$index]} = 1;
597 
                    }
598 
                }
599 
            }
600 
            $sth->finish();
601 
        }
602 
        else
603 
        {
604 
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
605 
        }
606 
    }
607 
    else
608 
    {
609 
        Error("Prepare failure" );
610 
    }
611 
}
612 
 
613 
#-------------------------------------------------------------------------------
614 
# Function        : GetColumnNames
615 
#
616 
# Description     : Get Database information
617 
#
618 
# Inputs          : table to rmMerge_process
619 
#
620 
# Returns         : Ref to an array of data
621 
#
622 
sub GetColumnNames
623 
{
624 
    my ($tableName) = @_;
625 
    my (@row);
626 
    my $found;
627 
    my @names;
628 
    Verbose ("GetColumnNames: $tableName");
629 
 
630 
    my $m_sqlstr = "select COLUMN_NAME, data_type, NULLABLE, COLUMN_ID from ALL_TAB_COLUMNS where TABLE_NAME='$tableName'";
631 
    my $sth = $RM_DB->prepare($m_sqlstr);
632 
    if ( defined($sth) )
633 
    {
634 
        if ( $sth->execute( ) )
635 
        {
636 
            if ( $sth->rows )
637 
            {
638 
                while ( @row = $sth->fetchrow_array )
639 
                {
640 
                    my @data = @row;
641 
                    $names[$row[3]-1] = \@data;
642 
#                    print join(' ', @row), "\n";
643 
                    $found = 1;
644 
                }
645 
            }
646 
            $sth->finish();
647 
        }
648 
        else
649 
        {
650 
            Error("Execute failure: $m_sqlstr", $sth->errstr() );
651 
        }
652 
    }
653 
    else
654 
    {
655 
        Error("Prepare failure" );
656 
    }
657 
 
658 
    Error("Internal. Table not found: $tableName") unless $found;
659 
    return \@names;
660 
}
661 
 
662 
#-------------------------------------------------------------------------------
663 
# Function        : escapeRowData
664 
#
665 
# Description     : Given an array of data items massage the data so that special characters
666 
#                   can be serailaized and deserailised via perl
667 
#
668 
#                   Special chars include: tab,newline, return
669 
#
670 
#                   At the moment there is not cross ref to the type of field
671 
#                   Assume that if it has narsy data init then its a string
672 
#                   and we don't do much to those
673 
#
674 
# Inputs          : $row    - Ref to an array
675 
#
676 
# Returns         : Nothing. Data is rmMerge_processed in place
677 
#
678 
sub escapeRowData
679 
{
680 
    my ($row) = @_;
681 
    foreach my $value ( @$row) {
682 
 
683 
        $value =~ s/([\t\r\n%'])/"%" . uc(sprintf "%2.2x" , unpack("C", $1))/eg;
684 
    }
685 
}
686 
 
687 
 
688 
 
689 
#-------------------------------------------------------------------------------
690 
# Function        : saveLocalData
691 
#
692 
# Description     : Saves a hash of data to disk
693 
#
694 
# Inputs          :
695 
#
696 
# Returns         :
697 
#
698 
sub saveLocalData
699 
{
700 
    #
701 
    #   Dump out the configuration information
702 
    #
703 
    my $fh = ConfigurationFile::New( $localDataStore);
704 
 
705 
    $fh->DumpData( "\n# rmData\n#\n", "rmData", \%rmData );
706 
    $fh->Close();
707 
 
708 
    #DebugDumpData("rmData", \%rmData);
709 
}
710 
 
711 
#-------------------------------------------------------------------------------
712 
# Function        : restoreLocalData
713 
#
714 
# Description     : Read in the locally preserved data
715 
#
716 
# Inputs          :
717 
#
718 
# Returns         :
719 
#
720 
sub restoreLocalData
721 
{
722 
    if (-f $localDataStore) {
723 
        require ( $localDataStore );
724 
    }
725 
}
726 
 
727 
#-------------------------------------------------------------------------------
728 
#   Documentation
729 
#
730 
 
731 
=pod
732 
 
733 
=for htmltoc    GENERAL::ClearCase::
734 
 
735 
=head1 NAME
736 
 
737 
rmMerge_suck - Extract all Package-Version info from RM
738 
 
739 
=head1 SYNOPSIS
740 
 
741 
jats rmMerge_suck [options] PackageName PackageVersion
742 
 
743 
 Options:
744 
    -help              - brief help message
745 
    -help -help        - Detailed help message
746 
    -man               - Full documentation
747 
    -outfile=name      - Name of the output file (optional)
748 
 
749 
=head1 OPTIONS
750 
 
751 
=over 8
752 
 
753 
=item B<-help>
754 
 
755 
Print a brief help message and exits.
756 
 
757 
=item B<-help -help>
758 
 
759 
Print a detailed help message with an explanation for each option.
760 
 
761 
=back
762 
 
763 
=head1 EXAMPLE
764 
 
765 
jats rmMerge_suck PackageName PackageVersion
766 
 
767 
=cut
768 
 
769