Provision-Unix
view release on metacpan or search on metacpan
- require version 1 of utf8 (weed out ancient perl versions)
- required v2.08 of File::Path (resolve some test failures)
1.04 2011-11-27
- test suite updates b/c Dist::Zilla doesn't make it easy to exclude testing
on win32/cygwin platform.
- not finding a test process running is not a test failure
1.03 2011-11-07
- dependency updates so tests work on perl < 5.8
- chown api changes due to M:T:U import
- when destroying users on Darwin (Mac), flush the cache before testing if the command succeeded.
- when setting a test quota, use the test user.
- quota_set: renamed param username -> user to match use
- dist.ini: added autoprereqs & use utf8
- P:U:DNS:tinydns: added comments for tinydns-data record formats
- P:U:DNS: renamed fully_qualify -> qualify
1.02 Nov 04, 2011
- FreeBSD user functions make secure backups
the disk image from being removed, which causes the reinstall to fail.
- added ram, disk_size to VE creation tests
- deprecate P:U:V:L:OpenVZ::set_nameservers in favor of P:U:V:set_nameservers
- when modifying an OpenVZ VE, use Linux::set_ips method
0.84 Dec 09, 2009
- added ability to pass the following command line arguments to prov_virtual
--modify: ram, disk_size, cpu, nameservers, searchdomain
- added cpu to list of command line arguments of prov_virtual -create
- added gecos (comment) field to xen console users
- chown console users home dir after creation
- strip off any spaces from prov_virtual --action param
0.83 Dec 02, 2009
- skip get_the_date( bump => 1 ) test if day of month > 27
- added additional debug messages to remoteagent
- when creating a xen VE snapshot, skip sync if VE is not running
- declare methods in P:U:V that are eligible to run via remoteagent
- RAM and disk were not being passed properly by prov_virtual CLI RT#1581201
- added get_config method for Xen & OpenVZ classes, returns config file
- added publish_arp method, that updates switch/routers after moving an IP
lib/Provision/Unix/User.pm view on Meta::CPAN
$util->file_write( "$ssh_dir/authorized_keys",
lines => [ $line ],
mode => '0600',
debug => 0,
fatal => 0,
) or return;
if ( $p{username} ) {
my $uid = getpwnam $p{username};
if ( $uid ) {
$util->chown( $ssh_dir, uid => $uid, fatal => 0 );
$util->chown( "$ssh_dir/authorized_keys", uid => $uid, fatal => 0 );
}
else {
my $chown = $util->find_bin( 'chown', debug => 0 );
$util->syscmd( "$chown -R $p{username} $homedir/.ssh", fatal => 0, debug => 0 );
};
};
};
sub is_valid_password {
my ( $self, $pass, $user ) = @_;
my %r = ( error_code => 400 );
lib/Provision/Unix/User/Darwin.pm view on Meta::CPAN
debug => $debug,
);
if ($homedir) {
mkdir $homedir, 0755
or $util->mkdir_system(
dir => $homedir,
mode => '0755',
debug => 0
);
$util->chown( $homedir, uid => $user, gid=>$p_user->{gid}, debug => $debug );
}
return getpwnam($user);
}
sub _create_niutil {
my $self = shift;
my $user = $p_user->{username};
my $debug = $p_user->{debug};
lib/Provision/Unix/User/Darwin.pm view on Meta::CPAN
$util->syscmd( "$dirutil -createprop . /users/$user _shadow_passwd",
debug => $debug,
);
$util->syscmd( "$dirutil -createprop . /users/$user passwd '*'",
debug => $debug,
);
if ($homedir) {
mkdir $homedir, 0755;
$util->chown( $homedir, uid => $user, gid=>$p_user->{gid}, debug => $debug );
}
return getpwnam($user);
}
sub destroy {
my $self = shift;
my %p = validate(
@_,
lib/Provision/Unix/Utility.pm view on Meta::CPAN
or return $log->error( "couldn't chmod $file: $!", %args );
}
# note the conversion of ($mode) to an octal value. Very important!
CORE::chmod( oct($mode), $file ) or
return $log->error( "couldn't chmod $file: $!", %args);
$log->audit("chmod $mode $file");
}
sub chown {
my $self = shift;
my $file = shift;
my %p = validate( @_,
{ 'uid' => { type => SCALAR },
'gid' => { type => SCALAR },
'sudo' => { type => BOOLEAN, optional => 1 },
%std_opts,
}
);
my ( $uid, $gid, $sudo ) = ( $p{uid}, $p{gid}, $p{sudo} );
my %args = ( debug => $p{debug}, fatal => $p{fatal} );
$file or return $log->error( "missing file or dir", %args );
return $log->error( "file $file does not exist!", %args ) if ! -e $file;
$log->audit("chown: preparing to chown $uid $file");
# sudo forces system chown instead of the perl builtin
return $self->chown_system( $file,
%args,
user => $uid,
group => $gid,
) if $sudo;
my ( $nuid, $ngid ); # if uid or gid is not numeric, convert it
if ( $uid =~ /\A[0-9]+\z/ ) {
$nuid = int($uid);
$log->audit(" using $nuid from int($uid)");
lib/Provision/Unix/Utility.pm view on Meta::CPAN
if ( $gid =~ /\A[0-9\-]+\z/ ) {
$ngid = int( $gid );
$log->audit(" using $ngid from int($gid)");
}
else {
$ngid = getgrnam( $gid );
return $log->error( "failed to get gid for $gid", %args) if ! defined $ngid;
$log->audit(" converted $gid to numeric: $ngid");
}
chown( $nuid, $ngid, $file )
or return $log->error( "couldn't chown $file: $!",%args);
return 1;
}
sub chown_system {
my $self = shift;
my $dir = shift;
my %p = validate( @_,
{ 'user' => { type => SCALAR, optional => 0, },
'group' => { type => SCALAR, optional => 1, },
'recurse' => { type => BOOLEAN, optional => 1, },
%std_opts,
}
);
my ( $user, $group, $recurse ) = ( $p{user}, $p{group}, $p{recurse} );
my %args = ( debug => $p{debug}, fatal => $p{fatal} );
$dir or return $log->error( "missing file or dir", %args );
my $cmd = $self->find_bin( 'chown', %args );
$cmd .= " -R" if $recurse;
$cmd .= " $user";
$cmd .= ":$group" if $group;
$cmd .= " $dir";
$log->audit( "cmd: $cmd" );
$self->syscmd( $cmd, %args ) or
return $log->error( "couldn't chown with $cmd: $!", %args);
my $mess;
$mess .= "Recursively " if $recurse;
$mess .= "changed $dir to be owned by $user";
$log->audit( $mess );
return 1;
}
sub clean_tmp_dir {
lib/Provision/Unix/Utility.pm view on Meta::CPAN
type => "text",
) or do {
$log->audit( "$existing is already up-to-date.", %args);
unlink $newfile if $p{clean};
return 2;
};
};
$log->audit("checking $existing", %args);
$self->chown( $newfile,
uid => $uid,
gid => $gid,
sudo => $sudo,
%args
)
if ( $uid && $gid ); # set file ownership on the new file
# set file permissions on the new file
$self->chmod(
file_or_dir => $existing,
mode => $mode,
sudo => $sudo,
%args
)
if ( -e $existing && $mode );
$self->install_if_changed_notify( $notify, $email, $existing, $diffie);
$self->archive_file( $existing, %args) if ( -e $existing && $p{archive} );
$self->install_if_changed_copy( $sudo, $newfile, $existing, $p{clean}, \%args );
$self->chown( $existing,
uid => $uid,
gid => $gid,
sudo => $sudo,
%args
) if ( $uid && $gid ); # set ownership on new existing file
$self->chmod(
file_or_dir => $existing,
mode => $mode,
sudo => $sudo,
lib/Provision/Unix/Utility.pm view on Meta::CPAN
sub is_readable {
my $self = shift;
my $file = shift or die "missing file or dir name\n";
my %p = validate( @_, { %std_opts } );
my %args = ( debug => $p{debug}, fatal => $p{fatal} );
-e $file or return $log->error( "$file does not exist.", %args);
-r $file or return $log->error( "$file is not readable by you ("
. getpwuid($>)
. "). You need to fix this, using chown or chmod.", %args);
return 1;
}
sub is_writable {
my $self = shift;
my $file = shift or die "missing file or dir name\n";
my %p = validate( @_, { %std_opts } );
my %args = ( debug => $p{debug}, fatal => $p{fatal} );
lib/Provision/Unix/Utility.pm view on Meta::CPAN
return $log->error( "failed to create $dir", %args);
}
if ( $p{sudo} ) {
my $sudo = $self->sudo();
$log->audit( "trying $sudo $mkdir -p $dir");
$self->syscmd( "$sudo $mkdir -p $dir", %args);
$log->audit( "setting ownership to $<.");
my $chown = $self->find_bin( 'chown', %args);
$self->syscmd( "$sudo $chown $< $dir", %args);
$self->chmod( dir => $dir, mode => $mode, sudo => $sudo, %args)
if $mode;
return -d $dir ? 1 : 0;
}
$log->audit( "trying mkdir -p $dir" );
# no root and no sudo, just try and see what happens
$self->syscmd( "$mkdir -p $dir", %args ) or return;
lib/Provision/Unix/Utility.pm view on Meta::CPAN
Changes the current working directory to the supplied one. Creates it if it does not exist. Tries to create the directory using perl's builtin mkdir, then the system mkdir, and finally the system mkdir with sudo.
############ cwd_source_dir ###################
# Usage : $util->cwd_source_dir( "/usr/local/src" );
# Purpose : prepare a location to build source files in
# Returns : 0 - failure, 1 - success
# Parameters : S - dir - a directory to build programs in
=item check_homedir_ownership
Checks the ownership on all home directories to see if they are owned by their respective users in /etc/password. Offers to repair the permissions on incorrectly owned directories. This is useful when someone that knows better does something like "ch...
######### check_homedir_ownership ############
# Usage : $util->check_homedir_ownership();
# Purpose : repair user homedir ownership
# Returns : 0 - failure, 1 - success
# Parameters :
# Optional : I - auto - no prompts, just fix everything
# See Also : sysadmin
Comments: Auto mode should be run with great caution. Run it first to see the results and then, if everything looks good, run in auto mode to do the actual repairs.
lib/Provision/Unix/Utility.pm view on Meta::CPAN
my $pidfile = $util->check_pidfile( "/var/run/changeme.pid" );
unless ($pidfile) {
warn "WARNING: couldn't create a process id file!: $!\n";
exit 0;
};
do_a_bunch_of_cool_stuff;
unlink $pidfile;
=item chown_system
The advantage this sub has over a Pure Perl implementation is that it can utilize sudo to gain elevated permissions that we might not otherwise have.
############### chown_system #################
# Usage : $util->chown_system( "/tmp/example", user=>'matt' );
# Purpose : change the ownership of a file or directory
# Returns : 0 - failure, 1 - success
# Parameters : S - dir - the directory to chown
# : S - user - a system username
# Optional : S - group - a sytem group name
# : I - recurse - include all files/folders in directory?
# Comments : Uses the system chown binary
# See Also : n/a
=item clean_tmp_dir
############## clean_tmp_dir ################
# Usage : $util->clean_tmp_dir( dir=>$dir );
# Purpose : clean up old build stuff before rebuilding
# Returns : 0 - failure, 1 - success
# Parameters : S - $dir - a directory or file.
# Throws : die on failure
lib/Provision/Unix/Utility.pm view on Meta::CPAN
arguments optional:
sudo - the output of $util->sudo
fatal - die on errors? (default: on)
debug
result:
0 - failure
1 - success
=item chown
Set the ownership (user and group) of a file. Will use the native perl methods (by default) but can also use system calls and prepend sudo if additional permissions are needed.
$util->chown(
file_or_dir => '/etc/resolv.conf',
uid => 'root',
gid => 'wheel',
sudo => 1
);
arguments required:
file_or_dir - a file or directory to alter permission on
uid - the uid or user name
gid - the gid or group name
lib/Provision/Unix/VirtualOS/Linux/Xen.pm view on Meta::CPAN
shell => -x '/usr/bin/lxxen' ? '/usr/bin/lxxen' : '',
debug => $debug,
gecos => "System User for $ve_name",
)
or return $log->error( "unable to create console user $username", fatal => 0 );
$log->audit("created console user account");
};
my $uid = getpwnam $username;
if ( $uid ) {
$util->chown( dir => $ve_home, uid => $uid, fatal => 0 );
};
foreach ( qw/ .bashrc .bash_profile / ) {
$util->file_write( "$ve_home/$_",
lines => [ "/usr/bin/sudo /usr/sbin/xm console $ve_name", 'exit' ],
fatal => 0,
debug => 0,
)
or $log->error( "failed to configure console login script", fatal => 0 );
}
t/Utility.t view on Meta::CPAN
}
# a dir to create
ok( $util->cwd_source_dir( "$tmp/foo" ), 'cwd_source_dir' );
print "\t\t wd: " . cwd . "\n" if $debug;
# go back to our previous working directory
chdir($cwd) or die;
print "\t\t wd: " . cwd . "\n" if $debug;
# chown_system
my $sudo_bin = $util->find_bin( 'sudo', fatal => 0 );
if ( $UID == 0 && $sudo_bin && -x $sudo_bin ) {
# avoid the possiblity of a sudo call in testing
ok( $util->chown_system( $tmp, user => $<, fatal => 0), 'chown_system');
}
# clean_tmp_dir
TODO: {
my $why = " - no test written yet";
}
ok( $util->clean_tmp_dir( dir => $tmp ), 'clean_tmp_dir' );
print "\t\t wd: " . cwd . "\n" if $debug;
t/Utility.t view on Meta::CPAN
ok( $util->cwd_source_dir( $tmp ), 'cwd_source_dir' );
my $url = "http://www.mail-toaster.org/etc/maildrop-qmail-domain";
ok( $util->get_url( $url ), 'get_url' );
ok( $util->get_url( $url, dir => $tmp ), 'get_url');
}
chdir($cwd);
print "\t\t wd: " . Cwd::cwd . "\n" if $debug;
# chown
my $uid = getpwuid($UID);
my $gid = getgrgid($GID);
my $root = 'root';
my $grep = $util->find_bin( 'grep' );
my $wheel = `$grep wheel /etc/group` ? 'wheel' : 'root';
SKIP: {
skip "the temp file for file_ch* is missing!", 4 if ( !-f $rwtest );
# this one should work
ok( $util->chown( $rwtest,
uid => $uid,
gid => $gid,
sudo => 0,
fatal => 0
),
'chown uid'
);
if ( $UID == 0 ) {
ok( $util->chown( $rwtest,
uid => $root,
gid => $wheel,
sudo => 0,
fatal => 0,
),
'chown user'
);
}
# try a user/group that does not exist
ok( !$util->chown( $rwtest,
uid => 'frobnob6i',
gid => 'frobnob6i',
sudo => 0,
fatal => 0
),
'chown nonexisting uid'
);
# try a user/group that I may not have permission to
if ( $UID != 0 && lc($OSNAME) ne 'irix') {
ok( !$util->chown( $rwtest,
uid => $root,
gid => $wheel,
sudo => 0,
fatal => 0
),
'chown no perms'
);
}
}
# tests system_chown because sudo is set, might cause testers to freak out
# ok ($util->chown( $rwtest, uid=>$uid, gid=>$gid, sudo=>1, fatal=>0 ), 'chown');
# ok ( ! $util->chown( $rwtest, uid=>'frobnob6i', gid=>'frobnob6i', sudo=>1, fatal=>0 ), 'chown');
# ok ( ! $util->chown( $rwtest, uid=>$root, gid=>$wheel, sudo=>1,fatal=>0), 'chown');
# chmod
# get the permissions of the file in octal file mode
my $st = File::stat::stat($rwtest) or warn "No $tmp: $!\n";
my $before = sprintf "%lo", $st->mode & 07777;
#$util->syscmd( "ls -al $rwtest" ); # use ls -al to view perms
# change the permissions to something slightly unique
if ( lc($OSNAME) ne 'irix' ) {
( run in 0.784 second using v1.01-cache-2.11-cpan-5511b514fd6 )