• Your recent searches
API-ISPManager
25 results

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN 

add_database.pl
add_mailbox.pl
add_www_domain.pl
Changes
lib/API/ISPManager.pm
lib/API/ISPManager/backup.pm
lib/API/ISPManager/db.pm
lib/API/ISPManager/diskpreset.pm
lib/API/ISPManager/dns.pm
lib/API/ISPManager/domain.pm
lib/API/ISPManager/file.pm
lib/API/ISPManager/ftp.pm
lib/API/ISPManager/ip.pm
lib/API/ISPManager/mailbox.pm
lib/API/ISPManager/misc.pm
lib/API/ISPManager/order.pm
lib/API/ISPManager/preset.pm
lib/API/ISPManager/services.pm
lib/API/ISPManager/software.pm
lib/API/ISPManager/stat.pm
lib/API/ISPManager/user.pm
lib/API/ISPManager/vds.pm
lib/API/ISPManager/vdspreset.pm
Makefile.PL
MANIFEST			This list of files
README
runtests.sh
t/01-test.t
t/02-files.t
upload_file.pl
vdsmanager.pl
META.yml                                 Module meta-data (added by MakeMaker)

META.yml  view on Meta::CPAN 

--- #YAML:1.0
name:               API-ISPManager
version:            0.07
abstract:           interface to the ISPManager Hosting Panel API ( http://ispsystem.com )
author:
    - nrg <nrg@cpan.org>
license:            unknown
distribution_type:  module
configure_requires:
    ExtUtils::MakeMaker:  0
build_requires:
    ExtUtils::MakeMaker:  0
requires:
    Crypt::SSLeay:   0
    Exporter::Lite:  0
    Getopt::Long:    0
    XML::Simple:     0
no_index:
    directory:
        - t
        - inc
generated_by:       ExtUtils::MakeMaker version 6.50
meta-spec:

README  view on Meta::CPAN 

   make test
   make install

INSTALLTION on Debian

apt-get install libwww-perl make libxml-simple-perl libnet-ssleay-perl libcrypt-ssleay-perl libexporter-lite-perl libtest-simple-perl
cpan API::ISPManager

DEPENDENCIES

This module requires these other modules and libraries:

  blah blah blah

COPYRIGHT AND LICENCE

Put the correct copyright and licence information here.

Copyright (C) 2008 by nrg

This library is free software; you can redistribute it and/or modify

add_database.pl  view on Meta::CPAN 

$API::ISPManager::DEBUG = '';

my %connection_params = (
    username => $login,
    password => $password,
    host     => $host,
    path     => 'manager',
);


my $db_creation_result = API::ISPManager::db::create( {
    %connection_params,
    name        => $db_name,
    dbtype      => 'MySQL',
    dbencoding  => 'default',
    dbuser      => 'newuser', 
    dbusername  => $db_user,
    dbpassword  => $db_pass,
    dbconfirm   => $db_pass,
} );


if ($db_creation_result) {
    print "$db_name success added!\n";
} else {
    warn Dumper($API::ISPManager::last_answer);
}

add_mailbox.pl  view on Meta::CPAN 

$API::ISPManager::DEBUG = '';

my %connection_params = (
    username => $login,
    password => $password,
    host     => $host,
    path     => 'manager',
);


my $mailbox_creation_result = API::ISPManager::mailbox::create( {
    %connection_params,
    quota   => 0,
    name    => $name,   
    domain  => $domain,
    passwd  => $mailbox_pass,
    confirm => $mailbox_pass,
} );


if ($mailbox_creation_result) {
    print "$mailbox_name success added!\n";
} else {
    warn Dumper($API::ISPManager::last_answer);
}

add_www_domain.pl  view on Meta::CPAN 

    username => $login,
    password => $password,
    host     => $host,
    path     => 'manager',
);

my $user_params = API::ISPManager::misc::usrparam( { %connection_params } );
$email = $user_params->{email};
die "Cannot get user email from panel!\n" unless $email;

my $domain_creation_result = API::ISPManager::domain::create( {
    %connection_params,
    domain  => $domain,
    alias   => "www.$domain",
    owner   => $login,
    admin   => $email,
    ip      => $ip,
    ssi     => 'on',
    php     => 'phpfcgi',
    ssl     => 'on',
    sslport => 443,
    docroot => $docroot,
} );

if ($domain_creation_result) {
    print "$domain success added!\n";
} else {
    warn Dumper($API::ISPManager::last_answer);
}

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


# Main packages
use API::ISPManager::ip;
use API::ISPManager::user;
use API::ISPManager::domain;
use API::ISPManager::mailbox;

# Addition packages
use API::ISPManager::backup;
use API::ISPManager::db;
use API::ISPManager::preset;
use API::ISPManager::stat;
use API::ISPManager::services;
use API::ISPManager::ftp;
use API::ISPManager::misc;
use API::ISPManager::file;

# VDSManager
use API::ISPManager::vds;
use API::ISPManager::diskpreset;
use API::ISPManager::vdspreset;

# BillManager
use API::ISPManager::software;
use API::ISPManager::order;

our @EXPORT    = qw/get_auth_id refs is_success get_data query_abstract is_ok get_error/;
our @EXPORT_OK = qw//;
our $VERSION   = 0.07;
our $DEBUG     = '';

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

 ### Get all panel IP
 my $ip_list = API::ISPManager::ip::list( $connection_params );

 unless ($ip_list && ref $ip_list eq 'ARRAY' && scalar @$ip_list) {
    die 'Cannot get ip list from ISP';
 }

 my $ip  = $ip_list->[0];
 my $dname  = 'perlaround.ru';

 my $client_creation_result = API::ISPManager::user::create( {
    %{ $connection_params },
    name      => 'user_login',
    passwd    => 'user_password',
    ip        => '11.11.22.33', 
    preset    => 'template_name',
    domain    => $dname,
 });

 # Switch off account:
 my $suspend_result = API::ISPManager::user::disable( {
    %{ $connection_params },
    elid => $use_login,
 } );

 unless ( $suspend_result ) {
    die "Cannot  suspend account";
 }



 # Switch on account
 my $resume_result = API::ISPManager::user::enable( {
    %{ $connection_params },
    elid => $user_login,
 } );

 unless ( $resume_result ) {
    die "Cannot  suspend account";
 }



 # Delete account
 my $delete_result = API::ISPManager::user::delete( {
    %{ $connection_params },
    elid => $login,
 } );

 unless ( $delete_result ) {
    die "Cannot delete account";
 }


=cut

# Last raw answer from server 
our $last_answer = ''; 

# Public!

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

}

# Make query string
# STATIC(HASHREF: params)
sub mk_query_string {
    my $params = shift;

    return '' unless $params &&
        ref $params eq 'HASH' && %$params ;

    my $result = join '&', map { "$_=$params->{$_}" } sort keys %$params;
    warn $result if $DEBUG;

    return $result;
}

# Kill slashes at start / end string
# STATIC(STRING:input_string)
sub kill_start_end_slashes {
    my $str = shift;

    for ($str) {
        s/^\/+//sgi;
        s/\/+$//sgi;

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

sub mk_query_to_server {
    my $query_string = shift;

    return '' unless $query_string;
    warn "Query string: $query_string\n" if $DEBUG;

    my $ua = LWP::UserAgent->new;
    $ua->agent("Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)");
    # Don`t working without this string!

    my $response = $ua->get($query_string);

    if ($response->is_success) {
        my $content = $response->content;

        if ($response->header('content-type') eq 'text/xml') {
            # allow only XML answers
            if ($content && $content =~ /^<\?xml version="\d\.\d" encoding="UTF-8"\?>/s) {
                warn $content if $DEBUG;
                return $content;
            } else {
                return '';
            }
        } else {
            return '';
        }

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

# Possible very stupid sub :)
# STATIC(REF: our_ref)
sub refs {
    my $ref = shift;

    return '' unless $ref;

    return ref $ref;
}

# INTERNAL!!! Check server answer result
# STATIC(data_block)
sub is_success {
    my $data_block = shift;

    if ( ref $data_block eq 'HASH' && ! $data_block->{error} && $data_block->{data} ) {
        return 1;
    } else {
        return '';
    }
}

lib/API/ISPManager/db.pm  view on Meta::CPAN 


    }

    return $server_answer;
}


sub create {
   my $params = shift;
    
    my $result = API::ISPManager::query_abstract(
        params          => { %$params, sok => 'yes' },
        func            => 'db.edit',
        allowed_fields  => [ qw( host path allow_http  sok name dbtype owner dbencoding dbuser dbusername dbpassword dbconfirm dbuserhost ) ],
    );

    $API::ISPManager::last_answer = $result;     

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}


package API::ISPManager::db_user;

use API::ISPManager;

lib/API/ISPManager/diskpreset.pm  view on Meta::CPAN 

package API::ISPManager::diskpreset;

use API::ISPManager;

sub create {


}


sub edit {

lib/API/ISPManager/diskpreset.pm  view on Meta::CPAN 

}

sub get {

}


sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'disktempl',
        allowed_fields => [ qw( host path allow_http ) ],
    );

    my $disk_templ = $result->{elem};
    
    return $disk_templ;
}


sub delete {


}

lib/API/ISPManager/domain.pm  view on Meta::CPAN 

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'wwwdomain'
    );
}

# Create domain
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'wwwdomain.edit', 
        allowed_fields => [  qw( host path allow_http     domain alias sok name owner ip docroot cgi php ssi ror ssl sslport admin ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Edit domain data
sub edit {

}

lib/API/ISPManager/file.pm  view on Meta::CPAN 

    );
}

# Create file or directory
# IN: filetype (0 - file, 1 - directory, zip ......)
# IN: plid - parent directory (optional, equal to docroot when empty)
# IN: name - parent directory for created file
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' },
        func   => 'file.new',
        elid   => '',
        allowed_fields => [  qw( host path allow_http sok filetype name elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Delete file or directory
# IN: plid - parent directory (optional, equal to docroot when empty)
# IN: elid - parent directory for created file
sub delete {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.delete', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Copy file or directory
# IN: plid - destination
# IN: elid - file/direcory to be copied
sub copy {
    my $params = shift;
    $params->{elid} = '//c/' . $params->{elid};
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.paste', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Move file or directory
# IN: plid - destination
# IN: elid - file/direcory to be moved
sub move {
    my $params = shift;
    $params->{elid} = '//x/' . $params->{elid};
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.paste', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Move file or directory
# IN: plid - parent directory
# IN: elid - archive to be extracted
sub extract {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'file.extract', 
        allowed_fields => [  qw( host path allow_http elid plid ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Edit file or directory
sub edit {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' },
        func   => 'file.attr', 
        allowed_fields => [  qw( host path allow_http elid plid sok name uid gid recursive mode pur puw pux pgr pgx por pox) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Upload file
sub upload {
    my $params = shift;

lib/API/ISPManager/file.pm  view on Meta::CPAN 

        my $ua = LWP::UserAgent->new;
        $ua->agent("Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)");
        my $url = 'https://server8.hosting.reg.ru/mancgi/upload';

        my $query_string = API::ISPManager::mk_full_query_string( {
            ( auth => $auth_id ), 
            func => $func_name,
            %$params_raw,
        } );  
               
        my $response = $ua->post(
            'https://' . $params->{host} . '/mancgi/upload',
			Content_Type => 'form-data',
			Content => [                
                filename => [$params->{file}],
                sok => 'ok',
                auth => $auth_id,    
                plid => $params->{plid},                               
            ]
        );

        
        if ($response->is_success) {
            return 1;
        }
        else {
            return '';
        }
    }
    else {
        return '';
    }
}

lib/API/ISPManager/ftp.pm  view on Meta::CPAN 

package API::ISPManager::ftp;

use strict;
use warnings;

use API::ISPManager;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'ftp',
        allowed_fields => [ qw( host path allow_http     su authinfo) ], # TODO: hack with authinfo!!!
    );

    return $result;
}


sub create  {


}

sub edit {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'ftp.edit',
        allowed_fields => [  qw( host path allow_http     sok elid su passwd name) ],
    );

    return $result;

}


sub delete {


}

1;

lib/API/ISPManager/mailbox.pm  view on Meta::CPAN 

    return API::ISPManager::query_abstract(
        params => $params,
        func   => 'email'
    );
}

# Create domain
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'email.edit', 
        allowed_fields => [  qw( host path allow_http  sok name domain aliases passwd confirm quota forward rmlocal greylist spamassassin note ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Edit email data
sub edit {

}

lib/API/ISPManager/misc.pm  view on Meta::CPAN 

use strict;
use warnings;

use API::ISPManager;

sub reload {
    my $params = shift;

    my $server_answer = API::ISPManager::query_abstract(
        params      => $params,
        func        => 'restart',
    );

    if ( $server_answer && $server_answer->{elem} && ref $server_answer->{elem} eq 'HASH' ) {
        return { data =>  $server_answer->{elem} };
    }

    return $server_answer;
}

sub usrparam {

lib/API/ISPManager/order.pm  view on Meta::CPAN 


use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'order',
    );

    if ($result && ref $result eq 'HASH' && $result->{elem}) {
        return $result->{elem};
    } 

    return $result;
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'user.edit', 
        allowed_fields => [  qw( host path allow_http     sok name domain email preset ip passwd ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result &&
        ref $result eq 'HASH' &&
        (
            $result->{ok} or
            ( $result->{error} && ref $result->{error} eq 'HASH' && $result->{error}->{code} eq '2' )  # already exists
        )
    ) {
        return 1;  # { success => 1 };
    } else {
        return ''; # { success => '', error => Dumper ($result->{error}) };
    }
#https://ultrasam.ru/ispmanager/ispmgr?out=xml&auth=232143511
#&sok=yes&func=user.edit&name=nrgxxx&ip=78.47.76.69&passwd=qwerty&ftplimit=100&disklimit=200
}

1;

lib/API/ISPManager/preset.pm  view on Meta::CPAN 

package API::ISPManager::preset;

use API::ISPManager;

sub create {


}


sub edit {


}

sub get {
    my $params = shift;
   
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'preset.edit',  
        allowed_fields => [  qw( host path allow_http  elid) ],
    );
  
    if (ref $result->{php} eq 'HASH' ) {
        $result->{php} = 'on';
    }
 
    if (ref $result->{phpmod} eq 'HASH' ) {
        $result->{phpmod} = 'on';
    }

    return '' if $result->{error};

    return $result;
}


sub list {
    my $params = shift;
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'preset',
        allowed_fields => [  qw( host path allow_http ) ],
    );

    my $plans = $result->{elem};
    
    for (keys %$plans) {
        for my $param ( 'ssl', 'ssi', 'php' ) {
            my $val = $plans->{$_}->{$param};

            if ( $val && ref $val eq 'HASH' ) {
                $plans->{$_}->{$param} = 'on';
            }
        } 
    }

lib/API/ISPManager/software.pm  view on Meta::CPAN 


use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'software',
    );

    if ($result && ref $result eq 'HASH' && $result->{elem}) { 
       return $result->{elem};
    }

    return $result;
}

sub get {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params, # чтобы создание разрешить
        func   => 'software.edit',
        allowed_fields => [  qw( host path allow_http    elid ) ],
    );

    return $result;
}

sub renew {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params, # чтобы создание разрешить
        func   => 'software.period',
        allowed_fields => [  qw( host path allow_http    elid ) ],
    );

=head

cost	7.7000
elid	361604
expiredate	2009-10-08
func	software.period
ip	83.222.14.204
licname	testserver1.hosting.reg.ru
payfrom	neworder
period	16
pricename	ISPmanager Pro (without support)
sok	ok

=cut

    return $result;
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'user.edit', 
        allowed_fields => [  qw( host path allow_http     sok name domain email preset ip passwd ) ],
    );

    $API::ISPManager::last_answer = $result;

    if ($result &&
        ref $result eq 'HASH' &&
        (
            $result->{ok} or
            ( $result->{error} && ref $result->{error} eq 'HASH' && $result->{error}->{code} eq '2' )  # already exists
        )
    ) {
        return 1;  # { success => 1 };
    } else {
        return ''; # { success => '', error => Dumper ($result->{error}) };
    }
#https://ultrasam.ru/ispmanager/ispmgr?out=xml&auth=232143511
#&sok=yes&func=user.edit&name=nrgxxx&ip=78.47.76.69&passwd=qwerty&ftplimit=100&disklimit=200
}

1;

lib/API/ISPManager/user.pm  view on Meta::CPAN 

        params => $params,
        func   => 'user',
    );
}

# Âîçâðàùàåò ÷èñëî àêòèâíûõ ïîëüçîâàòåëåé
sub active_user_count {
    my $params = shift;
    my $ans = API::ISPManager::user::list($params);
    
    my $result = 0;
    foreach my $key (keys %{$ans->{elem}}) {
        $result++ unless exists $ans->{elem}->{$key}->{disabled};
    }

    return $result;
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'user.edit', 
        allowed_fields => [  qw( host path allow_http     sok name domain email preset ip passwd ) ],
    );

    $API::ISPManager::last_answer = $result;
    #warn Dumper($API::ISPManager::last_answer);

    if ($result &&
        ref $result eq 'HASH' &&
        (
            $result->{ok} or
            ( $result->{error} && ref $result->{error} eq 'HASH' && $result->{error}->{code} eq '2' && $result->{error}->{obj} eq 'user' )  # already exists
        )
    ) {
        return 1;  # { success => 1 };
    } else {
        return ''; # { success => '', error => Dumper ($result->{error}) };
    }
#https://ultrasam.ru/ispmanager/ispmgr?out=xml&auth=232143511
#&sok=yes&func=user.edit&name=nrgxxx&ip=78.47.76.69&passwd=qwerty&ftplimit=100&disklimit=200
}

# Edit user data
sub edit {
    my $params = shift;
    
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'user.edit',
        allowed_fields => [  qw( host path allow_http     sok elid name domain email preset ip passwd ftplimit disklimit ssl ssi phpmod safemode  maillimit domainlimit webdomainlimit maildomainlimit baselimit baseuserlimit bandwidthlimit phpfcgi) ],
    );

    return $result;
}

# Delete user from panel
sub delete {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.delete');
 
    $API::ISPManager::last_answer = $result;

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Abstract sub for bool ( on | off ) methods
sub abstract_bool_manipulate {
    my ($params, $type) = @_;

    return '' unless $params && $type;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => $type, 
        allowed_fields => [  qw( host path allow_http    elid) ],
    );

    return $result;
}

# Switch-on user account
# elid -- user name =)
sub enable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.enable');

    $API::ISPManager::last_answer = $result;

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Switch off user account
# elid -- user name =)
sub disable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.disable');

    $API::ISPManager::last_answer = $result;

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

1;

lib/API/ISPManager/vds.pm  view on Meta::CPAN 


use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;

sub list {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vds',
    );

    return $result->{elem};
}

# Создать клиента (возможно, вместе с доменом)
sub create {
    my $params = shift;

    my $result = API::ISPManager::query_abstract(
        params => { %$params, sok => 'yes' }, # чтобы создание разрешить
        func   => 'vds.edit', 
        allowed_fields => [  qw( host path allow_http     
            sok name id ip passwd confirm owner vdspreset disktempl pvtdisk extns ispmgr
            disk mem  cpu proc desc traf note 
        ) ],
    );

    $API::ISPManager::last_answer = $result;

    return $result;

    if ($result &&
        ref $result eq 'HASH' &&
        (
            $result->{ok} or
            ( $result->{error} && ref $result->{error} eq 'HASH' && $result->{error}->{code} eq '2' )  # already exists
        )
    ) {
        return 1;  # { success => 1 };
    } else {
        return ''; # { success => '', error => Dumper ($result->{error}) };
    }
#https://ultrasam.ru/ispmanager/ispmgr?out=xml&auth=232143511
#&sok=yes&func=user.edit&name=nrgxxx&ip=78.47.76.69&passwd=qwerty&ftplimit=100&disklimit=200
}

# Edit user data
sub edit {
    my $params = shift;
    
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vds.edit',
        allowed_fields => [  qw( host path allow_http     sok elid name domain email preset ip passwd ftplimit disklimit ssl ssi phpmod safemode  maillimit domainlimit webdomainlimit maildomainlimit baselimit baseuserlimit bandwidthlimit) ],
    );

    return $result;
}

# Delete user from panel
sub delete {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'user.delete');

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Abstract sub for bool ( on | off ) methods
sub abstract_bool_manipulate {
    my ($params, $type) = @_;

    return '' unless $params && $type;

    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => $type, 
        allowed_fields => [  qw( host path allow_http    elid) ],
    );

    return $result;
}

# Switch-on user account
# elid -- user name =)
sub enable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'vds.enable');

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

# Switch off user account
# elid -- user name =)
sub disable {
    my $params = shift;

    my $result = abstract_bool_manipulate($params, 'vds.disable');

    if ($result && ref $result eq 'HASH' && $result->{ok}) {
        return 1;
    } else {
        return '';
    }
}

1;

lib/API/ISPManager/vdspreset.pm  view on Meta::CPAN 

package API::ISPManager::vdspreset;

use API::ISPManager;

sub create {


}


sub edit {


}

sub get {
    my $params = shift;
   
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vdspreset.edit',  
        allowed_fields => [  qw( host path allow_http  elid) ],
    );
  
    return $result;
}


sub list {
    my $params = shift;
    my $result = API::ISPManager::query_abstract(
        params => $params,
        func   => 'vdspreset',
        allowed_fields => [  qw( host path allow_http ) ],
    );

    my $plans = $result->{elem};
    
    return $plans;
}


sub delete {


}

runtests.sh  view on Meta::CPAN 

#!/bin/bash

./add_database.pl server5.hosting.reg.ru user_0000434578 oBffquIb db_name111 db_usersss45555 pass
#./add_www_domain.pl server5.hosting.reg.ru user_0000434578 oBffquIb suxx777.us
#./add_mailbox.pl server5.hosting.reg.ru user_0000434578 oBffquIb t1est@server6-host1.regrutestuser.ru qqqq
exit 0

perl -Ilib ./vdsmanager.pl --host=127.0.0.1 --username=admin  --password=qqqq  \
 --nodeid=1 --vpspassword=qwerty --owner=admin --preset=OVZ-1 --os=centos-5-x86_64 \
 --name=mymegavps7.ru

t/01-test.t  view on Meta::CPAN 

            'uptime' => '55 days 14 hours 5 minutes',
            'swap'   => '999992 kB',
            'mem'    => '393364 kB',
        }
    },
    'sysinfo test'
);

my $fake_usagestat = <<DOC;
<?xml version="1.0" encoding="UTF-8"?>
<doc><elem><name>disk</name><value used="1817" limit="4950"/></elem><elem><name>reseller</name><value used="1" limit="0"/></elem><elem><name>user</name><value used="20" limit="0"/></elem><elem><name>bandwidth</name><value used="8170" limit="170000000...
DOC

is_deeply( API::ISPManager::stat::usagestat( { %correct_params }, $fake_usagestat ), {
        'data' => {
            'ftpuser' => {
                'used' => '20',
                'limit' => '70220'
            },
            'disk' => {
                'used' => '1817',

t/01-test.t  view on Meta::CPAN 

                'limit' => '1700000000'
            },
            'databaseuser' => {
                'used' => '17',
                'limit' => '70026'
            },
            'user' => {
                'used' => '20',
                'limit' => '0'
            },
            'reseller' => {
                'used' => '1',
                'limit' => '0'
            },
            'wwwdomain' => {
                'used' => '20',
                'limit' => '70022'
            }
        }
    },
    'usagestat test'

t/01-test.t  view on Meta::CPAN 

    my $ip  = $ip_list->[0];
    
    if ($ip) {
        diag $ip;

        diag Dumper( API::ISPManager::user::create( {
            %correct_params,
            name      => 'nrgxxxxxapi',
            passwd    => 'qwerty',
            ip        => $ip, 
            preset    => 'Host-1',
            domain    => 'nrg.name',
        } ) );

        diag Dumper( API::ISPManager::ftp::list( {
            %correct_params,
            authinfo => 'username:password',
            su       => 'su_as_username',
        } ) );

t/02-files.t  view on Meta::CPAN 

    elid => "$now",  
    plid => '',    
} );

# Çàãðóçêà ôàéëà
$now = time;
open my $fh, '>', $now or die "Can't open $now for writing: $!";
print {$fh} 'hello world';
close $fh;

my $upload_result = API::ISPManager::file::upload( {
    %connection_params,
    plid => '',
    file => $now,
} );

@expected_file_list = @original_file_list;
push @expected_file_list, $now;
@real_file_list = get_file_list('', '');
ok(union_equal(\@expected_file_list, \@real_file_list), 'file upload');

t/02-files.t  view on Meta::CPAN 

} );

# Ðàñïàêîâêà àðõèâà
`tar -czf $now.tar.gz $now`;
API::ISPManager::file::upload( {
    %connection_params,
    plid => '',
    file => "$now.tar.gz",
} );

my $extract_result = API::ISPManager::file::extract( {
    %connection_params,
    plid => '',
    elid => "$now.tar.gz",
} );

@expected_file_list = @original_file_list;
push @expected_file_list, $now;
push @expected_file_list, "$now.tar.gz";
@real_file_list = get_file_list('', '');
ok(union_equal(\@expected_file_list, \@real_file_list), 'file extract');

t/02-files.t  view on Meta::CPAN 

unlink "$now.tar.gz";

# Ïîëó÷åíèå ñïèñêà ôàéëîâ â âèäå ìàññèâà
sub get_file_list {
    my ($plid, $elid) = @_;
    my $answer = API::ISPManager::file::list( { 
        %connection_params, 
        plid => $plid, 
        elid => $elid,
    } );
    my @result;
    if (ref($answer->{elem}) eq 'ARRAY') {
        foreach my $elem (@{$answer->{elem}}) {
            push @result, $elem->{name}->{content};
        }
    }
    else {
        push @result, $answer->{elem}->{name}->{content};
    }
    return @result;
}

# Ñðàâíåíèå äâóõ ìàññèâîâ êàê ìíîæåñòâ - ò.å. áåç ó÷åòà ïîðÿäêà ÷èñëà
# ýëåìåíòîâ è ÷èñëà èõ ïîâòîðåíèé
sub union_equal {
    my ($a, $b) = @_;
    return union_part_of($a, $b) && union_part_of($b, $a);
}

sub union_part_of {
    my ($a, $b) = @_;
    my $result = 1;
    for (my $i = 0; $i < scalar @{$a} && $result; $i++) {
        my $sub_result = 0;
        for (my $j = 0; $j < scalar @{$b} && !$sub_result; $j++) {
            $sub_result = $sub_result || ${$b}[$j] eq ${$a}[$i];
        }
        $result = $result && $sub_result;
    }
    
    return $result;
}

upload_file.pl  view on Meta::CPAN 

$API::ISPManager::DEBUG = 1;

my %connection_params = (
    username => $login,
    password => $password,
    host     => $host,
    path     => 'manager',
);


my $upload_result = API::ISPManager::file::upload( {
    %connection_params,
    plid => $plid,
    file => $filename,
} );


if ($upload_result) {
    print "file success uploaded!\n";
} else {
    warn Dumper($API::ISPManager::last_answer);
}

vdsmanager.pl  view on Meta::CPAN 

#!/usr/bin/perl

use strict;
use warnings;

use API::ISPManager;
use Data::Dumper;
use Getopt::Long;

my ($username, $password, $host);
my ($var_node_id, $name, $vps_password, $os, $owner, $preset);

my $result = GetOptions (
    'username=s'    => \$username,
    'password=s'    => \$password,
    'host=s'        => \$host,
    'nodeid=s'      => \$var_node_id,
    'vpspassword=s' => \$vps_password,
    'owner=s'       => \$owner,
    'preset=s'      => \$preset,
    'os=s'          => \$os,
    'name=s'        => \$name,
);

die 'Required command line parameter missing!' unless $result;

# Конфигурация скрипта
my $connection_params = {
    username => $username,
    password => $password,
    host     => $host,
    path     => 'manager/vdsmgr',
};

#
#  name        => 'mymegavps6.ru',  # тут хочет доменку и ничего другого
#  password    => 'qwerty',
#  os          => 'centos-5-x86_64',
#  owner       => 'admin',
#  preset      => 'OVZ-1',
#  node_id     => '1',              # номер Ноды
#


# Создаем ВПС
# Добавить автоформирование veid
# N -- номер впса
# N001, N002, N003.... N999 
# просто передаем параметром номер и все, отдельный параметр как и пароль и все такое

my $create_result = create_vps(
    name        => $name,           # тут хочет доменку и ничего другого
    password    => $vps_password,
    os          => $os,
    owner       => $owner,
    preset      => $preset,
    node_id     => $var_node_id,    # номер Ноды
);

### warn Dumper($create_result);

if ( $create_result && $create_result->{ok} && $create_result->{ip} && $create_result->{veid} ) {
    print "$create_result->{ip}|$create_result->{veid}\n";
    exit 0; # всё окей!
} else {
    print "error\n";
    exit 1;
}

# Проверка существования дискового шаблона
sub check_disk_preset {
    my $disk_preset_name = shift;
    return '' unless $disk_preset_name;

    my $disk_templates =
        API::ISPManager::diskpreset::list( $connection_params );

    return '' unless $disk_templates && ref $disk_templates eq 'HASH';

    # List all disk templates
    my @list = keys %$disk_templates;

    for (@list) {
        # If this preset exists and ok:
        my $preset_ok = 
            $disk_preset_name eq $_        &&
            $disk_templates->{$_}          &&
            $disk_templates->{$_}->{state} &&
            $disk_templates->{$_}->{state} eq 'ok';

        return 1 if $preset_ok;
    }

    return '';
}


# Проверяем корректность переданного шаблона ВПС
sub check_vps_preset {
    my $disk_preset_name = shift;
    return '' unless $disk_preset_name;

    my $disk_templates =
        API::ISPManager::vdspreset::list( $connection_params );

    return '' unless $disk_templates && ref $disk_templates eq 'HASH';

    # List all VPS templates
    my @list = keys %$disk_templates;

    for (@list) {
        # If this preset exists:
        my $preset_ok = 
            $disk_preset_name eq $_ &&
            $disk_templates->{$_};

        return 1 if $preset_ok;
    }

    return '';
}


# Получаем детализацию тарифа ВПС
sub get_vps_preset_details {
    my $preset_name = shift;
    return '' unless $preset_name;

    my $vds_template_details = API::ISPManager::vdspreset::get( {
        %$connection_params ,
        elid => $preset_name
    } );

    # Фильтруем только нужные параметры тарифа
    my $clean_plan_details = { };
    my @required_params = qw(disk mem cpu proc desc traf);


    for (@required_params) {

        unless ( $vds_template_details->{$_} ) {

vdsmanager.pl  view on Meta::CPAN 

}

# Создаем ВПС
sub create_vps {
    my %params = @_;

    my $all_params_ok =
        $params{password} &&
        $params{os}       &&
        $params{owner}    &&
        $params{preset}   &&
        $params{node_id};
    
    unless ($all_params_ok)  {
        warn "Required parameter missing!\n";
        return '';
    }

    # Блок проверки входных параметров

    my $disk_preset = $params{os};

    unless ( check_disk_preset($disk_preset) ) {
        warn "Disk preset incorrect!\n";
        return '';
    }


    my $vps_preset = $params{preset};

    unless ( check_vps_preset($vps_preset) ) {
        warn "VPS preset incorrect!\n";
        return '';
    }


    # Выгружаем подробности тарифа
    my $vps_preset_details = get_vps_preset_details( $vps_preset );

    unless ($vps_preset_details && ref $vps_preset_details eq 'HASH') {
        warn "Cannot get preset details!\n";
        return '';
    }


    my $node_id = $params{node_id};

    unless ($node_id =~ m/^\d$/) {
        warn "In Node ID only numbers allowed!\n";
        return '';
    }

vdsmanager.pl  view on Meta::CPAN 

    unless ($vps_name) {
        $vps_name = "ovz${veid}.fastvps.ru"
    }


    # Эти параметры пока проверять не будем
    my $server_password = $params{password};
    my $owner           = $params{owner};


    my $create_vps_result = API::ISPManager::vds::create( {
        %$connection_params,
        name       => $vps_name,
        id         => $veid,
        passwd     => $server_password,
        confirm    => $server_password,
        owner      => $owner,
        vdspreset  => $vps_preset,
        disktempl  => $disk_preset,

        %$vps_preset_details, # параметры ВПС тарифа
    } );

    if ($create_vps_result && ref $create_vps_result eq 'HASH' ) {
        return {
            %$create_vps_result,
            veid => $veid,
        }
    } else {
        return '';
    }
}


__DATA__
остыпало ошибку:



( run in 0.964 second using v1.01-cache-2.11-cpan-49f99fa48dc )