view release on metacpan or  search on metacpan

lib/App/Oozie/Deploy/Template.pm  view on Meta::CPAN

                    join( q{ or }, @{ $self->possible_readme_file_names } ),
            ),
        );
        ${ $validation_errors_ref }++;
        ${ $total_errors_ref }++;
    }
    else {
        $logger->debug( sprintf 'Has a %s', $has_readme )
            if $self->verbose;
    }

    return;
}

sub _create_meta_includes {
    my $self   = shift;
    my $opt    = shift;
    my $logger = $self->logger;

    if ( ! $self->write_ownership_to_workflow_xml ) {
        if ( $self->verbose ) {
            $logger->debug('write_ownership_to_workflow_xml is false. Skipping ...');
        }
        return;
    }

    die 'Options need to be a hashref!' if ! $opt || ! is_hashref $opt;

    my $source_dir = $opt->{source_dir};
    my $meta_file  = $opt->{source_file};
    my $dest_dir   = $opt->{dest_dir};

    if ( ! -d $source_dir ) {
        die sprintf 'source_dir=%s is not a directory!', $source_dir;
    }

    if ( ! -d $dest_dir ) {
        die sprintf 'dest_dir=%s is not a directory!', $dest_dir;
    }

    $logger->info(
        sprintf '%s exists and the data in there will be populated into workflow.xml',
                    $meta_file,
    );

    my $rs = $self->meta->maybe_decode( $meta_file ) || return;

    my @define;

    if ( $self->_create_wf_directive( $dest_dir, $rs ) ) {
        push @define,
                [
                    $self->meta->wf_directive_var,
                    $self->meta->wf_directive,
                ];
    }

    return @define;
}

sub _xml_escape {
    my($self, $input) = @_;
    return XML::LibXML::Document
            ->new('1.0', 'UTF-8')
            ->createTextNode( $input )
            ->toString;
}

sub _freeze_ttvar {
    my $self       = shift;
    my $tt_varname = shift;
    my $var        = shift;

    my $d   = Data::Dumper->new( [ $var ], [ $tt_varname ] );
    my $lin = $d->Dump;
    $lin =~ s{ \A [\$] }{}xms;
    return $lin;
}

sub _create_wf_directive {
    my $self        = shift;
    my $dest_dir    = shift;
    my $rs          = shift;
    my $tt_varname  = 'oozie_lineage';
    my $key_prefix  = 'bigdatameta';
    my $tt_variable = do {
        my %tot =   map  { $_ => scalar @{ $rs->{lineage}{ $_ } } }
                    grep { is_arrayref $rs->{lineage}{ $_ } }
                    keys %{ $rs->{lineage} };
        for my $name ( keys %tot ) {
            $rs->{total}{ $name } = $tot{ $name };
        }

        my $flat = Hash::Flatten->new->flatten( $rs );
        my $var  = [
            map {
                +{
                    key   => $key_prefix . q{.} . $_,
                    value => $self->_xml_escape( $flat->{ $_ } ),
                }
            }
            sort { lc $a cmp lc $b }
            keys %{ $flat }
        ];
        $self->_freeze_ttvar( $tt_varname => $var );
    };

    my $var_file = File::Spec->catfile( $dest_dir, $self->meta->wf_directive );

    return $self->_create_directive_file( $var_file, $tt_variable, $tt_varname );
}

sub _create_directive_file {
    my $self = shift;
    my($var_file, $tt_variable, $tt_varname) = @_;

    my $tmpl = <<'TMPL';
[% {% tt_variable %} %]
[% FOREACH entry IN {% tt_varname %}  %]
        <property>
            <name>[%  entry.key   %]</name>
            <value>[% entry.value %]</value>
        </property>
[% END %]
TMPL

    my $tt = Template->new(
        START_TAG => '{%',
        END_TAG   => '%}',
    );

    $tt->process(
        \$tmpl,
        {
            tt_variable => $tt_variable,
            tt_varname  => $tt_varname,
        },
        \my $buf,
    );

    open my $FH, '>', $var_file or die "Can't write to $var_file: $!";
    print $FH "$buf\n";
    if ( ! close $FH ) {
        $self->logger->warn(
            sprintf 'Failed to close %s: %s',,
                        $var_file,
                        $!,
        );
    }

    $self->logger->debug( sprintf 'meta file created as: %s', $var_file )
        if $self->verbose;

    return $var_file;
}

sub _pre_process_ttconfig_into_tempfile {
    my $self   = shift;
    my $opt    = shift || {};