view release on metacpan or  search on metacpan

lib/Muck/FS.pm  view on Meta::CPAN

   }

   carp "mount needs 'dsn' to connect to (e.g. dsn => 'DBI:Pg:dbname=test')" 
      unless ($arg->{'dsn'});
   carp "mount needs 'mount' as mountpoint" unless ($arg->{'mount'});


   # save (some) arguments in self
   foreach ( qw( mount cachedir s3_bucket debug ) ) {
      $self->{$_} = $arg->{$_};
   }

   foreach (qw( aws_access_key_id aws_secret_access_key 
                dsn user password )) {
      carp "mount needs '$_'" unless ($arg->{$_});
   }

   # TODO we choose to add forking in the future, do it here

   ## DB Setup
   $dbh = DBI->connect( $arg->{'dsn'},
                        $arg->{'user'},
                        $arg->{'password'}, 
                        {AutoCommit => 0, RaiseError => 1} ) 
            || die $DBI::errstr;

   # Lets cache our prepared SQL statements in self
   foreach my $s ( @Muck::FS::VFS::statements ) {
      $sth->{$s->{name}} = $dbh->prepare($s->{sql}) || die $dbh->errstr();
   }


   $self->{'dbh'} = $dbh;
   $self->{'sth'} = $sth;

   ## memcached Setup
   if ( $arg->{memcached} ) {
      my $cache = new Cache::Memcached {
         'servers'      => [ "127.0.0.1:11211" ],
         'debug'        => 0,
         'compress_threshold' => 10000,
      };
      $self->{memcached} = $cache;
   }

   ## S3 Setup
   $self->{S3conn} = Muck::FS::S3::AWSAuthConnection->new(
                        $arg->{aws_access_key_id}, 
                        $arg->{aws_secret_access_key});

   ## File Handle Cache Setup
   $self->{Rfh_cache} = {};
   $self->{Wfh_cache} = {};

   $fuse_self = $self;

   Fuse::main(
      mountpoint  => $arg->{'mount'},
      mountopts   => 'allow_other',
      threaded    => '0',
      chown       => \&Muck::FS::VFS::x_chown,
      chmod       => \&Muck::FS::VFS::x_chmod,
      getattr     => \&Muck::FS::VFS::x_getattr,
      getdir      => \&Muck::FS::VFS::x_getdir,
      link        => \&Muck::FS::VFS::x_link,
      mknod       => \&Muck::FS::VFS::x_mknod,
      mkdir       => \&Muck::FS::VFS::x_mkdir,
      open        => \&Muck::FS::VFS::x_open,
      read        => \&Muck::FS::VFS::x_read,
      readlink    => \&Muck::FS::VFS::x_readlink,
      release     => \&Muck::FS::VFS::x_release,
      rename      => \&Muck::FS::VFS::x_rename,
      rmdir       => \&Muck::FS::VFS::x_unlink,
      statfs      => \&Muck::FS::VFS::x_statfs,
      symlink     => \&Muck::FS::VFS::x_symlink,
      truncate    => \&Muck::FS::VFS::x_truncate,
      utime       => \&Muck::FS::VFS::x_utime,
      unlink      => \&Muck::FS::VFS::x_unlink,
      write       => \&Muck::FS::VFS::x_write,
      debug       => ( $arg->{debug} > 2 ? 1 : 0 ),
   );
   
   exit(0) if ($arg->{'fork'});

   return 1;
}

=head2 is_mounted

Check if fuse filesystem is mounted

  if ($mnt->is_mounted) { ... }

=cut

sub is_mounted {
   my $self = shift;

   my $mounted = 0;
   my $mount = $self->{'mount'} || confess "can't find mount point!";
   if (open(MTAB, "/etc/mtab")) {
      while(<MTAB>) {
         $mounted = 1 if (/ $mount fuse /i);
      }
      close(MTAB);
   } else {
      warn "can't open /etc/mtab: $!";
   }

   return $mounted;
}


=head2 umount

Unmount your database as filesystem.

  $mnt->umount;

This will also kill background process which is translating
database to filesystem.