CPAN-Testers-Backend

 view release on metacpan or  search on metacpan

lib/CPAN/Testers/Backend/Fix/TesterNoname.pm  view on Meta::CPAN

#pod The L<DBI> object connected to the C<metabase> database.
#pod
#pod =cut

has metabase_dbh => (
    is => 'ro',
    isa => InstanceOf['DBI::db'],
    required => 1,
);

sub run( $self, @args ) {
    my ( $email, @name ) = @args;
    die "Email and name are required" unless $email && @name;
    my $name = join " ", @name;

    $self->schema->resultset( 'MetabaseUser' )
        ->search({ email => $email, fullname => 'NONAME' })
        ->update({ fullname => $name });

    $self->schema->resultset( 'Stats' )
        ->search({ tester => sprintf '"%s" <%s>', 'NONAME', $email })

lib/CPAN/Testers/Backend/Migrate/MetabaseCache.pm  view on Meta::CPAN

#pod The L<CPAN::Testers::Schema> to write reports to.
#pod
#pod =cut

has schema => (
    is => 'ro',
    isa => InstanceOf['CPAN::Testers::Schema'],
    required => 1,
);

sub run( $self, @args ) {
    GetOptionsFromArray(
        \@args, \my %opt,
        'force|f',
    );
    if ( $opt{force} && !@args ) {
        $LOG->info( '--force and no IDs specified: Re-processing all cache entries' );
        my $sth = $self->find_entries;
        $self->process_sth( $sth );
    }
    elsif ( @args ) {

lib/CPAN/Testers/Backend/Migrate/MetabaseCache.pm  view on Meta::CPAN

    return 0;
}

#pod =method process_sth
#pod
#pod Process the given statement handle full of reports. Returns the number
#pod of reports processed
#pod
#pod =cut

sub process_sth( $self, $sth ) {
    my $rs = $self->schema->resultset( 'TestReport' );
    my $count = 0;
    while ( my $row = $sth->fetchrow_hashref ) {
        my $fact = $self->parse_metabase_report( $row );
        $rs->insert_metabase_fact( $fact );
        $count++;
    }
    $LOG->info( 'Processed ' . $count . ' entries' );
    return $count;
}

lib/CPAN/Testers/Backend/Migrate/MetabaseCache.pm  view on Meta::CPAN

#pod =method find_unprocessed_entries
#pod
#pod     $sth = $self->find_unprocessed_entries;
#pod
#pod Returns a L<DBI> statement handle on to a list of C<metabase.metabase>
#pod row hashrefs for reports that are not in the main test report table
#pod (managed by L<CPAN::Testers::Schema::Result::TestReport>).
#pod
#pod =cut

sub find_unprocessed_entries( $self ) {
    my @ids;
    my $i = 0;
    my $page = 10000;
    my $current_page = $self->metabase_dbh->selectcol_arrayref(
        'SELECT guid FROM metabase LIMIT ' . $page . ' OFFSET ' . $i
    );
    while ( @$current_page > 0 && @ids < $page ) {
        my %found = map {; $_ => 1 } $self->schema->resultset( 'TestReport' )->search( {
            id => {
                -in => $current_page,

lib/CPAN/Testers/Backend/Migrate/MetabaseCache.pm  view on Meta::CPAN

#pod =method find_entries
#pod
#pod     $sth = $self->find_entries;
#pod     $sth = $self->find_entries( @ids );
#pod
#pod Find all the cache entries to be processed by this module, optionally
#pod limited only to the IDs passed-in. Returns a list of row hashrefs.
#pod
#pod =cut

sub find_entries( $self, @ids ) {
    my ( $where, @values );
    if ( @ids ) {
        $where = " WHERE guid IN (" . join( ', ', ( '?' ) x @ids ) . ")";
        @values = @ids;
    }
    my $sth = $self->metabase_dbh->prepare(
        "SELECT * FROM metabase" . $where
    );
    $sth->execute( @values );
    return $sth;

lib/CPAN/Testers/Backend/Migrate/MetabaseCache.pm  view on Meta::CPAN

#pod This code is stolen from CPAN::Testers::Data::Generator sub load_fact
#pod
#pod =cut

my $zipper = Data::FlexSerializer->new(
    detect_compression  => 1,
    detect_sereal       => 1,
    detect_json         => 1,
);

sub parse_metabase_report( $self, $row ) {
    if ( $row->{fact} ) {
        return $zipper->deserialize( $row->{fact} );
    }

    my $data = $zipper->deserialize( $row->{report} );
    my $struct = {
        metadata => {
            core => {
                $data->{'CPAN::Testers::Fact::TestSummary'}{metadata}{core}->%*,
                guid => $row->{guid},

lib/CPAN/Testers/Backend/Migrate/MetabaseUsers.pm  view on Meta::CPAN

#pod The L<CPAN::Testers::Schema> to write users to.
#pod
#pod =cut

has schema => (
    is => 'ro',
    isa => InstanceOf['CPAN::Testers::Schema'],
    required => 1,
);

sub run( $self, @args ) {
    my @from_users = $self->metabase_dbh->selectall_array( 'SELECT resource,fullname,email FROM testers_email ORDER BY id ASC', { Slice => {} } );

    # Save the last user for this GUID
    my %users;
    for \my %user ( @from_users ) {
        $users{ $user{resource} } = \%user;
    }

    # Update the user in the mapping table
    for \my %user ( values %users ) {

lib/CPAN/Testers/Backend/ProcessReports.pm  view on Meta::CPAN

    required => 1,
);

#pod =method run
#pod
#pod The main method that processes job arguments and performs the task.
#pod Called by L<Beam::Runner> or L<Beam::Minion>.
#pod
#pod =cut

sub run( $self, @args ) {
    GetOptionsFromArray(
        \@args, \my %opt,
        'force|f',
    );

    my @reports;
    if ( $opt{force} && !@args ) {
        $LOG->info( '--force and no IDs specified: Re-processing all reports' );
        @reports = $self->find_reports;
    }

lib/CPAN/Testers/Backend/ProcessReports.pm  view on Meta::CPAN

    $LOG->info("Skipped $skipped unprocessed report(s)") if $skipped;
}

#pod =method find_unprocessed_reports
#pod
#pod Returns a list of L<CPAN::Testers::Schema::Result::TestReport>
#pod objects for reports that are not in the cpanstats table.
#pod
#pod =cut

sub find_unprocessed_reports( $self ) {
    my $schema = $self->schema;
    my $stats = $schema->resultset('Stats');
    my $reports = $schema->resultset('TestReport')->search({
        id => {
            -not_in => $stats->get_column('guid')->as_query,
        },
        report => \[ "->> '\$.environment.language.name'=?", 'Perl 5' ],
    });
    return $reports->all;
}

lib/CPAN/Testers/Backend/ProcessReports.pm  view on Meta::CPAN

#pod
#pod     @reports = $self->find_reports;
#pod     @reports = $self->find_reports( @ids );
#pod
#pod Find all the test reports to be processed by this module, optionally
#pod limited only to the IDs passed-in. Returns a list of
#pod L<CPAN::Testers::Schema::Result::TestReport> objects.
#pod
#pod =cut

sub find_reports( $self, @ids ) {
    my $reports = $self->schema->resultset( 'TestReport' )->search({
        report => \[ "->> '\$.environment.language.name'=?", 'Perl 5' ],
    });
    if ( @ids ) {
        $reports = $reports->search({
            id => {
                -in => \@ids,
            },
        });
    }

lib/CPAN/Testers/Backend/ProcessReports.pm  view on Meta::CPAN

#pod
#pod Write the report to the legacy metabase cache. This cache is used for
#pod some of the web apps and some of the backend processes. Until those
#pod processes are changed to use the new test report format, we need to
#pod maintain the old metabase cache.
#pod
#pod Once the legacy metabase cache is removed, this method can be removed
#pod
#pod =cut

sub write_metabase_cache( $self, $report_row, $stat_row ) {
    my $guid = $report_row->id;
    my $id = $stat_row->id;
    my $created_epoch = $report_row->created->epoch;
    my $report = $report_row->report;

    my $distname = $report->{distribution}{name};
    my $distversion = $report->{distribution}{version};

    my $upload_row = $self->schema->resultset( 'Upload' )->search({
        dist => $distname,

lib/CPAN/Testers/Backend/ProcessReports.pm  view on Meta::CPAN

#pod =method write_builder_update
#pod
#pod     $self->write_builder_update( $stat_row );
#pod
#pod Write entries to the C<page_requests> table to tell the legacy webapp
#pod report builders that they need to update the static data caches for this
#pod distribution and this distribution's author.
#pod
#pod =cut

sub write_builder_update( $self, $stat ) {
    my $upload_row = $self->schema->resultset( 'Upload' )->search({
        dist => $stat->dist,
        version => $stat->version,
    })->first;
    my $sql = 'INSERT INTO page_requests ( type, name, weight, id ) VALUES ( ?, ?, ?, ? )';
    my $sub = sub( $storage, $dbh, @values ) {
        $dbh->do( $sql, {}, @values );
    };
    my $storage = $self->schema->storage;
    $storage->dbh_do( $sub, 'author', $upload_row->author, 1, $stat->id );

lib/CPAN/Testers/Backend/ViewMetabaseCache.pm  view on Meta::CPAN

#pod The L<DBI> object connected to the C<metabase> database.
#pod
#pod =cut

has metabase_dbh => (
    is => 'ro',
    isa => InstanceOf['DBI::db'],
    required => 1,
);

sub run( $self, @args ) {

    my $row = $self->metabase_dbh->selectrow_hashref(
        "SELECT * FROM metabase WHERE guid=?", {}, $args[0],
    );
    my $migrate = "CPAN::Testers::Backend::Migrate::MetabaseCache";

    say "----- Fact column";
    my $fact = $migrate->parse_metabase_report( {
        fact => $row->{fact},
        guid => $row->{guid},