API-Plesk

 view release on metacpan or  search on metacpan

lib/API/Plesk.pm  view on Meta::CPAN

    my $ua = new LWP::UserAgent( parse_head => 0 );
    my $req = new HTTP::Request POST => $self->{url};

    if ($self->{secret_key}) {
        $req->push_header(':KEY',  $self->{secret_key});
    } else {
        $req->push_header(':HTTP_AUTH_LOGIN',  $self->{username});
        $req->push_header(':HTTP_AUTH_PASSWD', $self->{password});
    }
    $req->content_type('text/xml; charset=UTF-8');
    $req->content($xml);

    # LWP6 hack to prevent verification of hostname
    $ua->ssl_opts(verify_hostname => 0) if $ua->can('ssl_opts');

    warn $req->as_string   if defined $self->{debug}  &&  $self->{debug} > 1;

    my $res = eval {
        local $SIG{ALRM} = sub { die "connection timeout" };
        alarm $self->{timeout};

lib/API/Plesk/Component.pm  view on Meta::CPAN

# check hosting xml section
sub check_hosting {
    my ( $self, $params, $required ) = @_;

    unless ( $params->{hosting} ) {
        confess "Required hosting!" if $required;
        return;
    }

    my $hosting = $params->{hosting};
    my $type = delete $hosting->{type};
    my $ip = delete $hosting->{ip_address};
    
    #confess "Required ip_address" unless $ip;
    
    if ( $type eq 'vrt_hst' ) {

        $self->check_required_params($hosting, qw(ftp_login ftp_password));

        my @properties;
        for my $key ( sort keys %$hosting ) {
            push @properties, { property => [
                {name => $key}, 
                {value => $hosting->{$key}} 
            ]};
            delete $hosting->{$key};
        }
        push(@properties, { ip_address => $ip }) if $ip;
        $hosting->{$type} = @properties ? \@properties : '';

        return;
    }

    elsif ( $type eq 'std_fwd' or $type eq 'frm_fwd' ) {
        
        confess "Required dest_url field!" unless $hosting->{dest_url};
        
        $hosting->{$type} = {
            dest_url => delete $hosting->{dest_url},
        };
        $hosting->{$type}->{ip_address} = $ip if $ip;

        return;
    }
    elsif ( $type eq 'none' ) {
        $hosting->{$type} = '';
        return;
    }

    confess "Unknown hosting type!";
}

sub prepare_filter {
    my ( $self, $filter, %opts ) = @_;

    my @filter;
    my $sort = $opts{sort_keys} || [keys %$filter];

    for my $key ( @$sort ) {
        if ( ref $filter->{$key} eq 'ARRAY' ) {

lib/API/Plesk/DNS.pm  view on Meta::CPAN

use Carp;

use base 'API::Plesk::Component';

sub add_rec {
    my ( $self, %params ) = @_;
    my $bulk_send = delete $params{bulk_send};

    my @fields = (
        [qw(site-id site-alias-id)],
        'type',
        'host',
        'value'
    );

    $self->check_required_params(\%params, @fields);
    my $data = $self->sort_params(\%params, @fields, 'opt');

    return $bulk_send ? $data : 
        $self->plesk->send('dns', 'add_rec', $data);
}

lib/API/Plesk/Database.pm  view on Meta::CPAN

use warnings;

use Carp;

use base 'API::Plesk::Component';

sub add_db {
    my ( $self, %params ) = @_;
    my $bulk_send = delete $params{bulk_send};

    $self->check_required_params(\%params, qw(webspace-id name type));
     
    return $bulk_send ? \%params : 
        $self->plesk->send('database', 'add-db', \%params);
}

sub del_db {
    my ($self, %filter) = @_;
    my $bulk_send = delete $filter{bulk_send};

    my $data = {

lib/API/Plesk/WebUser.pm  view on Meta::CPAN

use base 'API::Plesk::Component';

#TODO
sub add {
    my ( $self, %params ) = @_;
    my $bulk_send = delete $params{bulk_send};

    $self->check_required_params(\%params, qw(site-id login));

    my $data = $self->sort_params(\%params, qw(site-id login password password-type ftp-quota services));

    return $bulk_send ? $data : 
        $self->plesk->send('webuser', 'add', $data);
}

sub get {
    my ($self, %filter) = @_;
    my $bulk_send = delete $filter{bulk_send};

    my $data = { 

lib/API/Plesk/WebUser.pm  view on Meta::CPAN

        $self->plesk->send('webuser', 'get-prefs', $data);
}

sub set {
    my ( $self, %params ) = @_;
    my $bulk_send = delete $params{bulk_send}; 
    my $filter    = delete $params{filter} || '';
    
    my $data = {
        filter  => $filter,
        values  => $self->sort_params(\%params, qw(password password-type ftp-quota services)),
    };

    return $bulk_send ? $data : 
        $self->plesk->send('webuser', 'set', $data);
}

sub del {
    my ($self, %filter) = @_;
    my $bulk_send = delete $filter{bulk_send}; 

lib/API/Plesk/Webspace.pm  view on Meta::CPAN

use Data::Dumper;

use base 'API::Plesk::Component';

my @gen_setup_fields = qw(
    name
    owner-id
    owner-login
    owner-guid
    owner-external-id
    htype
    ip_address
    status
    external-id
);

my @main_fields = qw(
    gen_setup
    hosting    
    limits     
    prefs      

t/compoment.t  view on Meta::CPAN

    $c->sort_params({key => 1, key2 => 2, key3 => 3, key4 => 4}, [qw(key3 key2)], 'key'),
    [
        {key3 => 3},
        {key  => 1},
    ]
);

eval {
    $c->check_hosting({
        hosting => {
            type => 'vrt_hst',
            ftp_login => 'ert',
            ftp_password => '123',
            ip_address => '12.34.56.78',
        }
    })
};
ok(!$@);

eval {
    $c->check_hosting({
        hosting => {
            type => 'vrt_hst',
            ftp_login => 'ert',
            ftp_password => '123',
        }
    })
};
ok(!$@);

eval {
    $c->check_hosting({
        hosting => {
            type => 'vrt_ht',
            ftp_login => 'ert',
            ftp_password => '123',
        }
    })
};
like($@, qr/Unknown hosting type!/); 

is_deeply(
    $c->prepare_filter({id => [qw(1 2 3)], name => 'id'}, sort_keys => [qw(id name)]),
    [
        { id => 1 },
        { id => 2 },
        { id => 3 },
        { name => 'id' },
    ],
    'prepare_filter'

t/database.t  view on Meta::CPAN

}

my $api = API::Plesk->new( %TestData::plesk_valid_params );

isa_ok($api->database, 'API::Plesk::Database');

is_deeply(
    $api->database->add_db(
        'webspace-id' => 1,
        name => 'test_db',
        type => 'MySQL',
        bulk_send => 1
    ),
    { 
        'webspace-id' => 1,
        name => 'test_db',
        type => 'MySQL',
    },
    'add_db'
);

is_deeply(
    $api->database->del_db(
        name => 'test_db',
        bulk_send => 1
    ),
    { 

t/mock.t  view on Meta::CPAN

$api->mock_error('some error');
is($api->mock_error, 'some error');


$api->mock_response('<packet version="1.6.3.0"><dns><add_rec><result><status>ok</status><id>17</id></result></add_rec></dns></packet>');
$api->mock_error('');

my $res = $api->dns->add_rec(
    'site-id' => 1,
     type     => 'NS',
     host     => 'Mysite.com',
     value    => 'ns.Mysite.com.',
);
is(ref $res, 'API::Plesk::Response');
is($res->id, 17);

t/service-plan.t  view on Meta::CPAN

}

my $api = API::Plesk->new( %TestData::plesk_valid_params );

isa_ok($api->service_plan, 'API::Plesk::ServicePlan');

is_deeply(
    $api->service_plan->set(
        filter => { name => '123' },
        hosting     => {
            type       => 'vrt_hst',
            ftp_login  => '123',
            ftp_password => '123',
            ip_address => '123',
        },
        limits => '',
        bulk_send   => 1,
    ),
    [
        { filter => { name => '123' } },
        { limits => '' },

t/site.t  view on Meta::CPAN

isa_ok($api->site, 'API::Plesk::Site');

is_deeply(
    $api->site->add(
        gen_setup => {
            name => 'test.ru',
            'webspace-name' => 'main.ru',
        },
        hosting => {
            type => 'std_fwd',
            ip_address => '12.34.56.78',
            dest_url => 'fwd.ru',
        },
        bulk_send => 1
    ),
    [ 
        {gen_setup => [
            {name => 'test.ru'},
            {'webspace-name' => 'main.ru'},
        ]},

t/site.t  view on Meta::CPAN

    'add'
);

is_deeply(
    $api->site->set(
        filter => {name => 'test.ru'},
        gen_setup => {
            name => 'test.ru',
        },
        hosting => {
            type => 'vrt_hst',
            ip_address => '12.34.56.78',
            ftp_login => 'qwerty',
            ftp_password => '12345',
            ip_address => '12.34.56.78',
        },
        bulk_send => 1
    ),
    {
        filter => {name => 'test.ru'},
        values => [

t/webspace.t  view on Meta::CPAN

is_deeply(
    $api->webspace->add(
        'plan-name' => '123',
        gen_setup   => {
            name          => '123',
            ip_address    => '123',
            'owner-login' => '123',
        },
        hosting     => {
            type       => 'vrt_hst',
            ftp_login  => '123',
            ftp_password => '123',
            ip_address => '123',
        },
        prefs => { www => 'true' },
        bulk_send   => 1,
    ),
    [
        {
            gen_setup   => [

t/webspace.t  view on Meta::CPAN

is_deeply(
    $api->webspace->set(
        filter => { name => '123' },
        gen_setup   => {
            name          => '123',
            ip_address    => '123',
            'owner-login' => '123',
        },
        hosting     => {
            type       => 'vrt_hst',
            ftp_login  => '123',
            ftp_password => '123',
            ip_address => '123',
        },
        prefs => { www => 'true' },
        bulk_send   => 1,
    ),
    [
        { filter => { name => '123' } },
        { values => [