File Coverage

blib/lib/WWW/ConfixxBackup.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 WWW::ConfixxBackup;

use 5.006001;
use strict;
use warnings;
use WWW::ConfixxBackup::Confixx;
use WWW::ConfixxBackup::FTP;

our $VERSION = '0.1001';

sub new{
    my ($class,%args) = @_;
    my $self = bless {},$class;

    $self->waiter(120);
    $self->file_prefix( '' );

    $self->debug( sub{ print join "\n", @_ } );
    $self->DEBUG(0);

    my @unwanted = (qr/login$/, qr/^backup/, qr/download$/, qr/^_/, qr/errstr/);

    for my $key ( keys %args ){
        next if grep{ $key =~ $_ }@unwanted;
        if( my $sub = $self->can( $key ) ){
            $sub->( $self, $args{$key} );
        }
    }

    return $self;
}# new

sub http_proxy{
    my ($self,$proxy) = @_;

    $self->{_http_proxy} = $proxy if @_ == 2;
    return $self->{_http_proxy};
}

sub ftp_user{
    my ($self,$user) = @_;
    $self->{ftp_user} = $user if(defined $user);
    return $self->{ftp_user};
}# ftp_user

sub ftp_server{
    my ($self,$server) = @_;
    $self->{ftp_server} = $server if(defined $server);
    return $self->{ftp_server};
}# ftp_server

sub ftp_password{
    my ($self,$password) = @_;
    $self->{ftp_password} = $password if(defined $password);
    return $self->{ftp_password};
}#ftp_password

sub user{
    my ($self,$user) = @_;
    if(defined $user){
       $self->ftp_user($user);
       $self->confixx_user($user);
    }
    return $self->ftp_user;
}# user

sub server{
    my ($self,$server) = @_;
    if(defined $server){
        $self->ftp_server($server);
        $self->confixx_server($server);
    }
    return $self->ftp_server;
}# server

sub password{
    my ($self,$password) = @_;
    if(defined $password){
        $self->ftp_password($password);
        $self->confixx_password($password);
    }
    return $self->ftp_password;
}# password

sub confixx_user{
    my ($self,$user) = @_;
    $self->{confixx_user} = $user if(defined $user);
    return $self->{confixx_user};
}# confixx_user

sub confixx_server{
    my ($self,$server) = @_;
    $self->{confixx_server} = $server if(defined $server);
    return $self->{confixx_server};
}# confixx_server

sub confixx_password{
    my ($self,$password) = @_;
    $self->{confixx_password} = $password if(defined $password);
    return $self->{confixx_password};
}# confixx_pasword

sub confixx_version{
    my ($self,$version) = @_;
    $self->{_confixx_version} = $version if defined $version;
    return $self->{_confixx_version};
}

sub available_confixx_versions{
    my ($self) = @_;
    return WWW::ConfixxBackup::Confixx->available_confixx_versions;
}

sub default_confixx_version{
    return WWW::ConfixxBackup::Confixx->default_version;
}

sub login{
    my ($self) = @_;
    $self->_reset_errstr;
    $self->ftp_login     or $self->_add_errstr('' . $self->ftp_server);
    $self->confixx_login or $self->_add_errstr('' . $self->confixx_server);

    unless($self->errstr){
        return 1;
    }

    return;
}# login

sub ftp_login{
    my ($self) = @_;
    $self->{FTP} = WWW::ConfixxBackup::FTP->new(
        user     => $self->ftp_user,
        password => $self->ftp_password,
        server   => $self->ftp_server,
    );
    $self->{FTP}->debug( $self->debug );
    $self->{FTP}->DEBUG( $self->DEBUG );
    $self->{FTP}->login;

    return if ref($self->{FTP}->ftp) ne 'Net::FTP';
    return 1;
}# ftp_login

sub confixx_login{
    my ($self) = @_;
    $self->{CONFIXX} = WWW::ConfixxBackup::Confixx->new(
        user     => $self->confixx_user,
        password => $self->confixx_password,
        server   => $self->confixx_server,
    );
    $self->{CONFIXX}->debug( $self->debug );
    $self->{CONFIXX}->DEBUG( $self->DEBUG );
    $self->{CONFIXX}->proxy( $self->http_proxy ) if $self->http_proxy;
    $self->{CONFIXX}->login;

    if( ref($self->{CONFIXX}->mech) ne 'WWW::Mechanize' ){
        return;
    }
    return 1;
}# confixx_login

sub file_prefix{
    my ($self,$prefix) = @_;

    $self->{__prefix} = $prefix if scalar @_ > 1;
    return $self->{__prefix};
}

sub backup_download{
    my ($self,$path) = @_;

    $path ||= '.';
    $self->_reset_errstr();

    unless($self->{CONFIXX}){
        $self->confixx_login or $self->_add_errstr('Can\'t login to Confixx');
    }

    unless($self->{FTP}){
        $self->ftp_login or $self->_add_errstr('Can\'t login to FTP server');
    }

    $self->{CONFIXX}->confixx_version( $self->confixx_version );
    if(defined $path && $self->{CONFIXX} && $self->{FTP}){
        $self->{CONFIXX}->backup() or $self->_add_errstr('Can\'t create backup');
        sleep($self->{WAIT});
        $self->{FTP}->prefix( $self->file_prefix );
        $self->{FTP}->download($path) or $self->_add_errstr('Can\'t download');
    }

    unless($self->errstr){
        return 1;
    }

    return 0;
}# backup_download

sub _reset_errstr{
    my ($self) = @_;
    $self->{errstr} = '';
}

sub _add_errstr{
    my ($self,$msg) = @_;
    $self->{errstr} .= $msg if(defined $msg);
}

sub errstr{
    my ($self) = @_;
    return $self->{errstr}."\n";
}

sub waiter{
    my ($self,$wait) = @_;
    $self->{WAIT} = $wait if(defined $wait);
    return $self->{WAIT};
}# wait

sub detect_version{
    my ($self) = @_;

    $self->_reset_errstr;

    unless($self->{CONFIXX}){
        $self->confixx_login or
                $self->add_errstr('Can\'t login to Confixx' . $self->confixx_server);
    }
    if($self->{CONFIXX}){
        $self->{CONFIXX}->_detect_version;
        my $version = $self->{CONFIXX}->confixx_version;
        $self->confixx_version( $version );
        return $version;
    }

    return;
}

sub debug{
    my ($self,$coderef) = @_;

    if( @_ == 2 ){
        $self->DEBUG(1);
        $self->{__debug} = $coderef;
    }

    return $self->{__debug};
}

sub DEBUG{
    my ($self,$bool) = @_;

    if( @_ == 2 ){
        $self->{__DEBUG} = $bool;
        $self->{CONFIXX}->DEBUG( $bool ) if $self->{CONFIXX};
        $self->{FTP}->DEBUG( $bool )     if $self->{FTP};
    }

    return $self->{__DEBUG};
}

sub download{
    my ($self,$path) = @_;

    $self->_reset_errstr;

    unless($self->{FTP}){
      $self->ftp_login or
              $self->add_errstr('Can\'t login to FTP server' . $self->ftp_server);
    }
    if($self->{FTP}){
      $self->{FTP}->download($path) or
              $self->add_errst('Can\'t download backup files');
    }

    unless($self->errstr){
        return 1;
    }
    return;
}# download

sub backup{
    my ($self) = @_;

    $self->_reset_errstr;

    unless($self->{CONFIXX}){
        $self->confixx_login or
                $self->add_errstr('Can\'t login to Confixx' . $self->confixx_server);
    }
    if($self->{CONFIXX}){
        $self->{CONFIXX}->confixx_version( $self->confixx_version );
        $self->{CONFIXX}->backup or
                $self->add_errstr('Can\'t create backup');
    }

    unless($self->errstr){
        return 1;
    }
    return 0;
}# backup


# Preloaded methods go here.

1;

__END__