view release on metacpan or  search on metacpan

lib/App/Oozie/XML.pm  view on Meta::CPAN

        $wf_version = $+{version};
    }

    if (   (   $name       && $name =~ $re_sla_new  )
        || ( ! $wf_version && $path =~ $re_sla_path )
    ) {
        $sla_version = $+{version};
    }

    my @extra_error;

    if ( defined $sla_version && $sla_version < MIN_OOZIE_SLA_VERSION ) {
        push @extra_error,
            'Schema version mismatch for the SLA feature!',
            sprintf(
                'Your sla definition refers to a schema older than the minimum required version of %s (you have defined %s).',
                    MIN_OOZIE_SLA_VERSION,
                    $sla_version,
            ),
        ;
    }

    if ( defined $wf_version && $wf_version < MIN_OOZIE_SCHEMA_VERSION_FOR_SLA ) {
        push @extra_error,
            'Schema version mismatch for the SLA feature!',
            sprintf(
                'Your workflow definition refers to a schema older than the minimum required version of %s (you have defined %s).',
                    MIN_OOZIE_SCHEMA_VERSION_FOR_SLA,
                    $wf_version,
            ),
        ;
    }

    if ( $dumb_conf ) {
        if ( my $forks = $dumb_conf->{fork} ) {
            for my $node ( sort keys %{ $forks } ) {
                my $paths = $forks->{ $node }{path};
                my $total = keys %{ $paths };
                if ( $total < 2 ) {
                    push @extra_error, sprintf <<'NEED_AT_LEAST_TWO', $node;
The fork node `%s` has less than 2 paths. Oozie won't execute such definitions.
Either remove fork node, or change the definiton to have at least 2 paths.
NEED_AT_LEAST_TWO

                }
            }
        }
    }

    return @extra_error;
}

sub localname {
    my ($self) = @_;
    my $type = $XML_NAMESPACE{ $self->prefix };
    return +( XML::Compile::Util::unpack_type( $type ) )[LAST_ELEM];
}

sub is_foreign_prefix {
    my ($self, $prefix) = @_;
    my ($ns, $localname) = XML::Compile::Util::unpack_type($XML_NAMESPACE{$self->prefix});
    my $nsobj = ( $XML_SCHEMA->namespaces->namespace($ns) )[XML_NS_FIRST_POS];
    my %elements =
        map { lc $_ => 1 }
        map { (XML::Compile::Util::unpack_type($_))[XML_UNPACK_LOCALNAME_POS] }
        $nsobj->elements, $nsobj->types;
    return not exists $elements{$prefix};
}

sub xml {
    my ($self) = @_;
    my $data = clone( $self->data );

    my $doc = XML::LibXML::Document->new( '1.0', 'UTF-8' );

    # visit the cloned datastructure
    # and write back the XML for internal "any" nodes
    my @queue = ($data);
    while ( my $this = shift @queue ) {
        if ( is_hashref $this ) {
            for my $prefix ( keys %{ $this } ) {
                if ( exists $XML_NAMESPACE{$prefix} and $self->is_foreign_prefix($prefix) ) {
                    $this->{ $XML_NAMESPACE{$prefix} } =
                      $XML_SCHEMA->writer( $XML_NAMESPACE{$prefix} )
                      ->( $doc, delete $this->{$prefix} );
                }
                elsif ( is_ref $this->{$prefix} ) {
                    push @queue, $this->{$prefix};
                }
            }
        }
        elsif ( is_arrayref $this ) {
            push @queue,
                grep {
                    is_hashref( $_ )  || is_arrayref( $_ )
                } @{ $this };
        }
    }

    return $self->writer->( $doc, $data );
}

sub sniff_doc {
    my($self, $doc) = @_;
    my $logger  = $self->logger;
    my $verbose = $self->verbose;

    my $type = fileno $doc ? 'IO'
             : ( ( $doc =~ m{ \A \s* [<] }xms ) or is_scalarref $doc ) ? 'string'
             : 'location';

    my $xml  = XML::LibXML->load_xml($type => $doc);
    my $root = $xml->documentElement;

    my $namespace = $root->getNamespaceURI;

    if ($namespace) {
        my ($localname, $version) = (split RE_COLON, $namespace )[XML_LOCALNAME_POS, XML_VERSION_POS];
        if ($localname and $version) {
            return $localname, $version;
        }
        else {
            $logger->logdie(
                sprintf q{Can't parse out localname and version from namespace: %s},
                        $namespace,