Subversion Repositories DevTools

package Utils;

use File::Basename;

use Data::Dumper;

sub trunc ($) {

	my $file = shift;

	open my $fh, ">$file" or die "Can't write $file: $!\n";

	print $fh '';

	close $fh;

}

sub checkpid ($) {

	my $conf = shift;

	my $pidfile = $conf->{'pidfile'};

	my $logger = $conf->{logger};

	trunc $pidfile unless -f $pidfile;

	open my $fh, $pidfile or $logger->err("Can't read pidfile $pidfile: $!");

	my ($pid) = <$fh>;

	close $fh;

	if (defined $pid) {

		chomp $pid;

		$logger->err("Process with pid $pid already running") if 0 < int $pid && kill 0, $pid;

	}

}

sub writepid ($) {

	my $conf = shift;

	my $logger = $conf->{logger};

	my $pidfile = $conf->{'pidfile'};

	open my $fh, ">$pidfile" or $logger->err("Can't write pidfile: $!");

	print $fh "$$\n";

	close $fh;

}

#-------------------------------------------------------------------------------

# Function        : trimstr

#

# Description     : Trim a string

#

# Inputs          : Array of strings

#

# Returns         : Array of trimmed strings

#

sub trimstr (@) {

	my @str = @_;

	for (@str) {

		chomp;

		s/^[\t\s]+//;

		s/[\t\s]+$//;

	}

	return @str;

}

#-------------------------------------------------------------------------------

# Function        : readconf

#

# Description     : Process config data

#

# Inputs          : $conffile   - Config file to read

#                   $pdata      - Ref to hash of controlling data

#                                 hashed by config item and '.ignore'

#                                 Values are:

#                                   default     - Default value

#                                   mandatory   - Must be present

#                                   fmt         - Format

#                                                   'size'      - convert to block

#                                                   'period'    - convert to time

#                                                   'dir'       - Directory

#                                                   'file'      - File

#                                                   'vfile'     - File. Path must exist

#                                                   'int'       - integer

#                                                   'int_list'  - A list of integers

#                                                   'text'      - Random Text

#                                                   'bool'      - y/n 1/0

#                               .ignore       - Regexp of items to ignore

#

#

#

# Returns         : $conf       - Ref to config data

#                   $errors     - Ref to an array of error messages

#

sub readconf

{

    my ($conffile, $pdata) = @_;

    my @errors;

	my $conf;

    my $ignored;

    if ( open my $fh, $conffile )

    {

	    while (<$fh>) {

		    next if /^[\t\w]+#/;

		    s/#.*//;

		    my ($key, $val) = trimstr split '=', $_, 2;

		    next unless defined $val;

		    $conf->{$key} = $val;

	    }

	    close $fh;

        #

        #   Validate mandatory entries

        #   Insert defaults that are not present

        #

        while ( (my ($key, $entry)) = each %{$pdata} )

        {

            if ( exists $entry{mandatory} && $entry{mandatory}  )

            {

                if ( !exists $conf->{$key} )

                {

                    push @errors, "Mandatory config not found: $key";

                }

            }

            if ( exists $entry{default} )

            {

                if ( !exists $conf->{$key} )

                {

                    $conf->{$key} = $entry{default};

                }

            }

        }

        #

        #   Scan all user items

        #

        my $ignore_re = $pdata->{'.ignore'} ;

        while ( (my ($key, $data)) = each %{$conf} )

        {

            if ( $ignore_re )

            {

                #

                #   Ignore entry is a hash of entries to ignore

                #       Key is RE with a group

                #       Value is the name of config item under which the

                #       data will be stored. The re group will be used to

                #       as the key for the final hash.

                #

                my $done = 0;

                while ( (my ($re, $ename)) = each %{$ignore_re} )

                {

                    if ( $key =~ m~$re~ )

                    {

                        $ignored->{$ename}{$1} = $data;

                        $done = 1;

                    }

                }

                if ( $done )

                {

                    delete $conf->{$key};

                    next;

                }

            }

            if ( !exists $pdata->{$key} )

            {

                push @errors, "Unknown config item: $key";

                next;

            }

            my $fmt = $pdata->{$key}{'fmt'};

            unless ( $fmt )

            {

                push @errors, "Unconfigured config item: $key";

                next;

            }

            if ( $fmt eq 'size' ) {

                $conf->{$key} = toBytes( $data );

            } elsif ( $fmt eq 'period' ) {

                $conf->{$key} = timeToSecs( $data );

            } elsif ( $fmt eq 'dir' ) {

                if ( ! -d $data ) {

                    push @errors, "Directory not found:$key: $data";

                }

            } elsif ( $fmt eq 'file' ) {

                if ( ! -f $data ) {

                    push @errors, "File not found:$key: $data";

                }

            } elsif ( $fmt eq 'vfile' ) {

                 my($filename, $pdir, $suffix) = fileparse($data);

                if ( ! -d $pdir ) {

                    push @errors, "Directory not found:$key: $pdir";

                }

            } elsif ( $fmt eq 'int' ) {

                unless ( $data =~ m~^\d+$~ ) {

                    push @errors, "Invalid Number:$key: $data";

                }

            } elsif ( $fmt eq 'int_list' ) {

                unless ( $data =~ m~^((\d+)[, ]*)*$~ ) {

                    push @errors, "Invalid Number List:$key: $data";

                }

            } elsif ( $fmt eq 'bool' ) {

                $data = lc $data;

                if ( $data eq '1' || $data eq 'y'  || $data eq 'yes') {

                    $conf->{$key} = 1;

                } elsif ( $data eq '0' || $data eq 'n' || $data eq 'no') {

                    $conf->{$key} = 0;

                } else {

                    push @errors, "Invalid Boolean:$key: $data";

                }

            } elsif ( $fmt eq 'text' ) {

            } else {

                push @errors, "Unknown config fmt:$key, $fmt";

            }

        }

    }

    else

    {

        push @errors, "Can't read $conffile: $!";

    }

    #

    #   Merge in ignored entries

    #

    while ( my ($key, $data ) = each %{$ignored})

    {

        $conf->{$key} = $data;

    }

#DebugDumpData('config', $conf );

    return $conf, \@errors;

}

#-------------------------------------------------------------------------------

# Function        : mtime

#

# Description     : Return the modification time of a file

#

# Inputs          : $path

#

# Returns         : modification time

#                   mode

#

sub mtime

{

    my ($path) = @_;

    my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,

       $atime,$mtime,$ctime,$blksize,$blocks) = stat($path);

    return (($mtime || 0), $mode);

}

#-------------------------------------------------------------------------------

# Function        : timeToSecs

#

# Description     : Process a string and convert it to seconds

#                   Handle:

#                       100     -> 100 seconds

#                       100s    -> 100 seconds

#                       5m      -> 5 minutes

#                       10h     -> 10 hours

#                       1d      -> 1 day

#                       1d10h   -> 1d and 10 hours

#

#

# Inputs          : String

#

# Returns         : Seconds

#

sub timeToSecs

{

    my ($src) = @_;

    my $result = 0;

    while ( $src =~ s~(\d+)([smhd])?~~ )

    {

        my $factor = 1;

        my $base = $1;

        my $mode = $2 || 's';

        if ( $mode eq 'd' ) {

            $factor = 24 * 60 * 60;

        } elsif ( $mode eq 'h' ) {

            $factor = 60 * 60;

        } elsif ( $mode eq 'm' ) {

            $factor = 60;

        }

        $result += $base * $factor;

    }

    return $result;

}

#-------------------------------------------------------------------------------

# Function        : toBytes

#

# Description     : Process a string and convert it to a byte count

#                   Handle:

#                       100     -> 100 bytes

#                       10k     -> 10 kilobytes

#                       5m      -> 5 Megabytes

#                       1g      -> 1 Gigabytes

#                       10b     -> 10 Blocks

#

# Inputs          : String

#

# Returns         : Byte Count

#

sub toBytes

{

    my ($src) = @_;

    my $result = 0;

    if ( $src =~ m~(\d+)([kmgb]?)~i )

    {

        my $factor = 1;

        my $base = $1;

        my $mode = lc($2) || '-';

        if ( $mode eq 'g' ) {

            $factor = 1024 * 1024 * 1024;

        } elsif ( $mode eq 'm' ) {

            $factor = 1024 * 1024;

        } elsif ( $mode eq 'k' ) {

            $factor = * 1024;

        } elsif ( $mode eq 'b' ) {

            $factor = 1024;

        }

        $result = $base * $factor;

    }

    return $result;

}

#-------------------------------------------------------------------------------

# Function        : DebugDumpData

#

# Description     : Dump a data structure

#

# Inputs          : $name           - A name to give the structure

#                   @refp           - An array of references

#

# Returns         :

#

sub DebugDumpData

{

    my ($name, @refp) = @_;

    my $ii = 0;

    foreach  ( @refp )

    {

        print Data::Dumper->Dump ( [$_], ["*[Arg:$ii] $name" ]);

        $ii++

    }

}

1;