File Coverage

blib/lib/App/bif/sync.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package App::bif::sync;
use strict;
use warnings;
use AnyEvent;
use Bif::Sync::Client;
use Bif::Mo;
use Coro;
use DBIx::ThinSQL qw/qv/;

our $VERSION = '0.1.5_5';
extends 'App::bif';

sub run {
    my $self = shift;
    my $opts = $self->opts;
    my $dbw  = $self->dbw;

    # Consider upping PRAGMA cache_size? Or handle that in Bif::Role::Sync?
    my @hubs = $dbw->xhashrefs(
        select     => [ 'h.id', 'n.name', 'h.location', 'n.uuid' ],
        from       => 'hubs h',
        inner_join => 'nodes n',
        on         => 'n.id = h.id',
        $opts->{hub} ? ( where => { 'n.name' => $opts->{hub} } ) : (),
        order_by => 'n.name',
    );

    return $self->err( 'SyncNone', 'no (matching) hubs found' )
      unless @hubs;

    $|++;    # no buffering

    foreach my $hub (@hubs) {
        my $error;
        my $cv = AE::cv;

        my $client = Bif::Sync::Client->new(
            name          => $hub->{name},
            db            => $dbw,
            location      => $hub->{location},
            debug         => $opts->{debug},
            debug_bifsync => $opts->{debug_bifsync},
            on_update     => sub {
                my $client = shift;
                $self->lprint( $client->name . ': ' . $_[0] );
            },
            on_error => sub {
                $error = shift;
                $cv->send;
            },
        );

        my $fh   = select;
        my $coro = async {
            select $fh;

            eval {
                $dbw->txn(
                    sub {
                        $self->start_work(
                            node_id       => $hub->{id},
                            start         => time,
                            start_comment => "sync",
                            billable      => 1,
                            save          => 1,
                        );

                        my @status = $client->sync_hub( $hub->{id} );

                        unless ( $status[0] eq 'HubMatch'
                            or $status[0] eq 'HubSync' )
                        {
                            $dbw->rollback;
                            $error =
"unexpected HubSync/Match status received: @status";
                            return;

                        }

                        if ( $status[0] eq 'HubSync' ) {
                            @status = $client->transfer_hub_changes;
                            if ( $status[0] ne 'TransferHubChanges' ) {
                                $dbw->rollback;
                                $error =
"unexpected TransferHubChanges status received: @status";
                                return;
                            }
                        }

                        print "\n";
                        $self->lprint('');
                        my $hub_id   = $client->hub_id;
                        my @projects = $dbw->xhashrefs(
                            select_distinct =>
                              [ 'p2.id AS id', 'n.path AS path' ],
                            from       => 'projects p',
                            inner_join => 'nodes_tree nt',
                            on         => 'nt.parent = p.id',
                            inner_join => 'projects p2',
                            on         => 'p2.id = nt.child AND p2.local = 1',
                            inner_join => 'nodes n',
                            on         => 'n.id = p2.id',
                            where      => {
                                'p.default_hub_id' => $hub_id,
                            },
                        );

                        foreach my $project (@projects) {
                            $client->name("$hub->{name}\[$project->{path}\]");
                            my $status =
                              $client->sync_project( $project->{id} );
                            if ( $status eq 'ProjectSync' ) {
                                @status =
                                  $client->transfer_project_related_changes;

                                if ( $status[0] ne
                                    'TransferProjectRelatedChanges' )
                                {
                                    $dbw->rollback;
                                    $error =
"unexpected TransferProjectRelatedChanges status received: @status";
                                    return;
                                }
                            }
                            elsif ( $status ne 'ProjectMatch' ) {
                                $dbw->rollback;
                                $error =
"unexpected sync_project status received: $status";
                                return $status;
                            }

                            print "\n";
                            $self->lprint('');
                        }

                        $dbw->xdo(
                            insert_or_replace_into =>
                              [ 'bifkv', qw/key change_id change_id2/ ],
                            select =>
                              [ qv('last_sync'), 'MAX(c.id)', 'MAX(c.id)', ],
                            from => 'changes c',
                        );

                        $self->stop_work(
                            stop    => time,
                            restore => 1,
                        );

                        return;
                    }
                );
            };

            if ($@) {
                $error = $@;
                print "\n";
            }

            return $cv->send;
        };

        $cv->recv;
        $client->disconnect;

        return $self->err( 'Unknown', $error ) if $error;

    }

    # TODO make this dependent on how many changes received/made since the last
    # analyze
    $dbw->do('ANALYZE');

    return $self->ok('Sync');
}

1;

__END__