mxmount

#!/usr/bin/perl

use Sys::Hostname;
use Data::Dumper;
use Socket;

use warnings;

########################################

my $configfile = "/etc/mxmounts";
my $exports    = "/etc/exports";

########################################

my $tag = "# DO NOT EDIT BELOW THIS LINE # created by /usr/bin/mxmount #";

my $fullhostname;
my $hostname;
my @lines;
my @exports;
my %V;
my %D;

$fullhostname = hostname();
($hostname) = $fullhostname =~ /^(.*?)\./;

%D = ();
%V = (
    DEFAULT_MOUNT_FS       => '',
    DEFAULT_MOUNT_OPTIONS  => '',
    DEFAULT_EXPORT_OPTIONS => '',
    DEFAULT_MOUNT_PREFIX   => '/',
    
    SHORTHOST => $hostname,
    FULLHOST  => $fullhostname,

    NONE => '',
    NULL => ''
);

@lines   = read_file($configfile);
@exports = read_file_raw($exports);

@lines = parse_variables(@lines);

@lines = parse_data(@lines);

foreach(@lines) {
   print STDERR  "skipping: '$_'\n";
}

#print Dumper \%D;

add_data0_if_not_present();

mount_all();
create_exports();

system("exportfs -ra");

sub add_data0_if_not_present {
    my $allmp = $D{$hostname};

    $allmp = [] unless (defined $allmp);

    foreach my $mp (sort { $a->{mountpoint} cmp $b->{mountpoint} } @$allmp ) {
        if ($mp->{label} eq "data0") {
            return;
        }
        if ($mp->{mountpoint} eq "$V{DEFAULT_MOUNT_PREFIX}/$hostname/0") {
            print STDERR "$mp->{mountpoint} already blocked by $mp->{label}\n";
            return;
        }
    }

    #   print "no data0 found\n";
    parse_data("$hostname !data0");
    #   print Dumper $D{$hostname};
}


sub create_exports {
    my $allmp = $D{$hostname};
    my @CMD;

    open(EXPORTS, '>', $exports) or die "can't open $exports: $!";

    foreach my $exp (@exports) {
        chomp($exp);
        next if($exp =~ /^\s*$/);
        last if($exp eq $tag);
        print EXPORTS "$exp\n";
    }

    print EXPORTS "\n$tag\n\n# auch du nicht, donald 8)\n\n";

    foreach my $mp (@$allmp) {
        next if($mp->{noexport});
        @CMD = ($mp->{mountpoint}, $mp->{exportopts});
        
        print join " ", "$exports: ", @CMD, "\n";
        print EXPORTS join " ", @CMD, "\n";
        
    }
    
    close EXPORTS;
}


sub mount_all {
    my $allmp = $D{$hostname};
    my @CMD;
    foreach my $mp (sort { $a->{mountpoint} cmp $b->{mountpoint} } @$allmp) {
        
        @CMD = ();
        
        push @CMD, 'mount', "LABEL=$mp->{label}", $mp->{mountpoint};
        
        if($mp->{fs}) {
            push @CMD, '-t', $mp->{fs};
        }
        if($mp->{mountopts}) {
            push @CMD, '-o', $mp->{mountopts};
        }
        system('mkdir','-p',$mp->{mountpoint});
        print STDERR join " ", @CMD, "\n";
        system(@CMD);
    }
}

sub parse_data {
   my @lines = @_;
   my @invalid = ();
   my @data;
   
   my $rest;

   foreach(@lines) {
       @data = split /\s+/, $_;

       unless($data[1]) {
           push @invalid, $_;
           next;
       }

       my $D = {};
       
       $D->{line} = $_;

       $D->{host}  = $data[0];
       

       $D->{label} = $data[1];
       if($D->{label} =~ /^!(.*)/) {
           $D->{noexport} = 1;
           $D->{label}    = $1;
       }
       
       if($D->{label} =~ /(.*):(.*)/) {
           $D->{label}      = $1;
           $D->{mountpoint} = $2;
       } else {
           if($D->{label} =~ /^X/) {
               $D->{mountpoint} = 'X/' . $D->{label};
               $D->{label} = lc($D->{label});
           } elsif($D->{label} =~ /^C/) {
               $D->{mountpoint} = 'C/' . $D->{label};
               $D->{label} = lc($D->{label});
               if (!$data[3]) {
                   $D->{noexport} = 1;
               }
           } elsif($D->{label} =~ /^data(.*)/) {
               $D->{mountpoint} = $1;
           } else {
               warn "mxmount: unknown shortlabel '$D->{label}'.. skipping..";
               next;
           }
       }
       if($D->{mountpoint} !~ m(^\/)) {
           $D->{mountpoint} = "$V{DEFAULT_MOUNT_PREFIX}/" . $D->{mountpoint};
       }

       $D->{fs}        = 'auto';
       $D->{mountopts} = $data[2] ? $data[2] : $V{DEFAULT_MOUNT_OPTIONS};
       if($D->{mountopts} =~ /\[(.*)\](.*)/) {
           $D->{fs}        = $1;
           $D->{mountopts} = $2;
       }

       $D->{exportopts} = $data[3] ? $data[3] : $V{DEFAULT_EXPORT_OPTIONS};
       
       foreach(qw(host label mountpoint fs mountopts exportopts )) {
           $D->{$_} = expand_variables($D->{$_});
       }
       

       push @{$D{$D->{host}}}, $D;
   }
   return @invalid;
}

sub expand_variables {
    my $s = shift;
    
    foreach my $k (keys %V) {
        $s =~ s/$k/$V{$k}/g;
    }
    
    return $s;
}


sub parse_variables {
   my @lines = @_;
   my @invalid = ();

   my ($key, $value);

   foreach(@lines) {
        if(($key, $value) = /^(\S+)=\s*(.*)$/) {
            $V{$key} = $value;
        } else {
            push @invalid,expand_variables($_);
        }
   }
   return @invalid;
}

sub read_file {
  my $file = shift;
  open F, "$file" or die "can't open $file: $!\n";

  my @lines=();
  my $line="";
  my $cont=0;

  while(<F>) {
    chomp;
    next if(/^\s*#/ or /^\s*$/);
  
    $cont=0;
  
    s/#.*$//;  # remove comments..
  
    $_ = $line . $_;
  
    if(s/\\\s*$//) {
      # line continous in next line..
      $cont=1;
    }

    $line = $_;

    unless($cont) {
      $line =~ s/\s+/ /g;
      $line =~ s/^\s+//;
      $line =~ s/\s+$//;
      push @lines, $line;
      $line="";
    }
  }
  
  close F;
  return @lines;
}

sub read_file_raw {
  my $file = shift;
  my @lines;

  open F, "$file" or return;
  @lines = <F>;
  close F;

  return @lines;
}