cz_system_info 0.1.0

data/lib/cz_system_info/filesystem/structs.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'rbconfig'
+
+module CzSystemInfo
+  class Filesystem
+    module Structs
+      # The Statfs struct is a subclass of FFI::Struct that corresponds to a struct statfs.
+      class Statfs < FFI::Struct
+        # Private method that will determine the layout of the struct on Linux.
+        def self.linux64?
+          if RUBY_PLATFORM == 'java'
+            ENV_JAVA['sun.arch.data.model'].to_i == 64
+          else
+            RbConfig::CONFIG['host_os'] =~ /linux/i &&
+              (RbConfig::CONFIG['arch'] =~ /64/ || RbConfig::CONFIG['DEFS'] =~ /64/)
+          end
+        end
+
+        private_class_method :linux64?
+
+        # FreeBSD 12.0 MNAMELEN from 88 => 1024.
+        MNAMELEN =
+          if RbConfig::CONFIG['host_os'] =~ /freebsd(.*)/i
+            Regexp.last_match(1).to_f < 12.0 ? 88 : 1024
+          else
+            88
+          end
+
+        case RbConfig::CONFIG['host_os']
+          when /bsd/i
+            layout(
+              :f_version, :uint32,
+              :f_type, :uint32,
+              :f_flags, :uint64,
+              :f_bsize, :uint64,
+              :f_iosize, :int64,
+              :f_blocks, :uint64,
+              :f_bfree, :uint64,
+              :f_bavail, :int64,
+              :f_files, :uint64,
+              :f_ffree, :uint64,
+              :f_syncwrites, :uint64,
+              :f_asyncwrites, :uint64,
+              :f_syncreads, :uint64,
+              :f_asyncreads, :uint64,
+              :f_spare, [:uint64, 10],
+              :f_namemax, :uint32,
+              :f_owner, :int32,
+              :f_fsid,  [:int32, 2],
+              :f_charspare, [:char, 80],
+              :f_fstypename, [:char, 16],
+              :f_mntfromname, [:char, MNAMELEN],
+              :f_mntonname, [:char, MNAMELEN]
+            )
+          when /linux/i
+            if linux64?
+              layout(
+                :f_type, :ulong,
+                :f_bsize, :ulong,
+                :f_blocks, :uint64,
+                :f_bfree, :uint64,
+                :f_bavail, :uint64,
+                :f_files, :uint64,
+                :f_ffree, :uint64,
+                :f_fsid, [:int, 2],
+                :f_namelen, :ulong,
+                :f_frsize, :ulong,
+                :f_flags, :ulong,
+                :f_spare, [:ulong, 4]
+              )
+            else
+              layout(
+                :f_type, :ulong,
+                :f_bsize, :ulong,
+                :f_blocks, :uint32,
+                :f_bfree, :uint32,
+                :f_bavail, :uint32,
+                :f_files, :uint32,
+                :f_ffree, :uint32,
+                :f_fsid, [:int, 2],
+                :f_namelen, :ulong,
+                :f_frsize, :ulong,
+                :f_flags, :ulong,
+                :f_spare, [:ulong, 4]
+              )
+            end
+          else
+            layout(
+              :f_bsize, :uint32,
+              :f_iosize, :int32,
+              :f_blocks, :uint64,
+              :f_bfree, :uint64,
+              :f_bavail, :uint64,
+              :f_files, :uint64,
+              :f_ffree, :uint64,
+              :f_fsid, [:int32, 2],
+              :f_owner, :int32,
+              :f_type, :uint32,
+              :f_flags, :uint32,
+              :f_fssubtype, :uint32,
+              :f_fstypename, [:char, 16],
+              :f_mntonname, [:char, 1024],
+              :f_mntfromname, [:char, 1024],
+              :f_reserved, [:uint32, 8]
+            )
+        end
+      end
+
+      # The Statvfs struct represents struct statvfs from CzSystemInfo/statvfs.h.
+      class Statvfs < FFI::Struct
+        if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach/i
+          layout(
+            :f_bsize, :ulong,
+            :f_frsize, :ulong,
+            :f_blocks, :uint,
+            :f_bfree, :uint,
+            :f_bavail, :uint,
+            :f_files, :uint,
+            :f_ffree, :uint,
+            :f_favail, :uint,
+            :f_fsid, :ulong,
+            :f_flag, :ulong,
+            :f_namemax, :ulong
+          )
+        elsif RbConfig::CONFIG['host'] =~ /bsd/i
+          layout(
+            :f_bavail, :uint64,
+            :f_bfree, :uint64,
+            :f_blocks, :uint64,
+            :f_favail, :uint64,
+            :f_ffree, :uint64,
+            :f_files, :uint64,
+            :f_bsize, :ulong,
+            :f_flag, :ulong,
+            :f_frsize, :ulong,
+            :f_fsid, :ulong,
+            :f_namemax, :ulong
+          )
+        elsif RbConfig::CONFIG['host'] =~ /sunos|solaris/i
+          layout(
+            :f_bsize, :ulong,
+            :f_frsize, :ulong,
+            :f_blocks, :uint64_t,
+            :f_bfree, :uint64_t,
+            :f_bavail, :uint64_t,
+            :f_files, :uint64_t,
+            :f_ffree, :uint64_t,
+            :f_favail, :uint64_t,
+            :f_fsid, :ulong,
+            :f_basetype, [:char, 16],
+            :f_flag, :ulong,
+            :f_namemax, :ulong,
+            :f_fstr, [:char, 32],
+            :f_filler, [:ulong, 16]
+          )
+        elsif RbConfig::CONFIG['host'] =~ /i686/i
+          layout(
+            :f_bsize, :ulong,
+            :f_frsize, :ulong,
+            :f_blocks, :uint,
+            :f_bfree, :uint,
+            :f_bavail, :uint,
+            :f_files, :uint,
+            :f_ffree, :uint,
+            :f_favail, :uint,
+            :f_fsid, :ulong,
+            :f_unused, :int,
+            :f_flag, :ulong,
+            :f_namemax, :ulong,
+            :f_spare, [:int, 6]
+          )
+        else
+          layout(
+            :f_bsize, :ulong,
+            :f_frsize, :ulong,
+            :f_blocks, :uint64,
+            :f_bfree, :uint64,
+            :f_bavail, :uint64,
+            :f_files, :uint64,
+            :f_ffree, :uint64,
+            :f_favail, :uint64,
+            :f_fsid, :ulong,
+            :f_flag, :ulong,
+            :f_namemax, :ulong,
+            :f_spare, [:int, 6]
+          )
+        end
+      end
+
+      # The Mnttab struct represents struct mnnttab from CzSystemInfo/mnttab.h on Solaris.
+      class Mnttab < FFI::Struct
+        layout(
+          :mnt_special, :string,
+          :mnt_mountp, :string,
+          :mnt_fstype, :string,
+          :mnt_mntopts, :string,
+          :mnt_time, :string
+        )
+      end
+
+      # The Mntent struct represents struct mntent from CzSystemInfo/mount.h on Unix.
+      class Mntent < FFI::Struct
+        layout(
+          :mnt_fsname, :string,
+          :mnt_dir, :string,
+          :mnt_type, :string,
+          :mnt_opts, :string,
+          :mnt_freq, :int,
+          :mnt_passno, :int
+        )
+      end
+    end
+  end
+end

data/lib/cz_system_info/filesystem.rb

@@ -0,0 +1,450 @@
+require_relative 'filesystem/constants'
+require_relative 'filesystem/structs'
+require_relative 'filesystem/functions'
+
+# The CzSystemInfo module serves as a namespace only.
+module CzSystemInfo
+  # The Filesystem class serves as an abstract base class. Its methods
+  # return objects of other types. Do not instantiate.
+  class Filesystem
+    include CzSystemInfo::Filesystem::Constants
+    include CzSystemInfo::Filesystem::Structs
+    extend CzSystemInfo::Filesystem::Functions
+
+    private_class_method :new
+
+    # Readable versions of constant names
+    OPT_NAMES = {
+      MNT_RDONLY => 'read-only',
+      MNT_SYNCHRONOUS => 'synchronous',
+      MNT_NOEXEC => 'noexec',
+      MNT_NOSUID => 'nosuid',
+      MNT_NODEV => 'nodev',
+      MNT_UNION => 'union',
+      MNT_ASYNC => 'asynchronous',
+      MNT_CPROTECT => 'content-protection',
+      MNT_EXPORTED => 'exported',
+      MNT_QUARANTINE => 'quarantined',
+      MNT_LOCAL => 'local',
+      MNT_QUOTA => 'quotas',
+      MNT_ROOTFS => 'rootfs',
+      MNT_DONTBROWSE => 'nobrowse',
+      MNT_IGNORE_OWNERSHIP => 'noowners',
+      MNT_AUTOMOUNTED => 'automounted',
+      MNT_JOURNALED => 'journaled',
+      MNT_NOUSERXATTR => 'nouserxattr',
+      MNT_DEFWRITE => 'defwrite',
+      MNT_NOATIME => 'noatime'
+    }.freeze
+
+    private_constant :OPT_NAMES
+
+    # File used to read mount informtion from.
+    if File.exist?('/etc/mtab')
+      MOUNT_FILE = '/etc/mtab'.freeze
+    elsif File.exist?('/etc/mnttab')
+      MOUNT_FILE = '/etc/mnttab'.freeze
+    elsif File.exist?('/proc/mounts')
+      MOUNT_FILE = '/proc/mounts'.freeze
+    else
+      MOUNT_FILE = 'getmntinfo'.freeze
+    end
+
+    private_constant :MOUNT_FILE
+
+    # The error raised if any of the Filesystem methods fail.
+    class Error < StandardError; end
+
+    # Stat objects are returned by the CzSystemInfo::Filesystem.stat method.
+    class Stat
+      # Read-only filesystem
+      RDONLY  = 1
+
+      # Filesystem does not support suid or sgid semantics.
+      NOSUID  = 2
+
+      # Filesystem does not truncate file names longer than +name_max+.
+      NOTRUNC = 3
+
+      # The path of the filesystem.
+      attr_accessor :path
+
+      # The preferred system block size.
+      attr_accessor :block_size
+
+      # The fragment size, i.e. fundamental filesystem block size.
+      attr_accessor :fragment_size
+
+      # The total number of +fragment_size+ blocks in the filesystem.
+      attr_accessor :blocks
+
+      # The total number of free blocks in the filesystem.
+      attr_accessor :blocks_free
+
+      # The number of free blocks available to unprivileged processes.
+      attr_accessor :blocks_available
+
+      # The total number of files/inodes that can be created.
+      attr_accessor :files
+
+      # The total number of files/inodes on the filesystem.
+      attr_accessor :files_free
+
+      # The number of free files/inodes available to unprivileged processes.
+      attr_accessor :files_available
+
+      # The filesystem identifier.
+      attr_accessor :filesystem_id
+
+      # A bit mask of flags.
+      attr_accessor :flags
+
+      # The maximum length of a file name permitted on the filesystem.
+      attr_accessor :name_max
+
+      # The filesystem type, e.g. UFS.
+      attr_accessor :base_type
+
+      alias inodes files
+      alias inodes_free files_free
+      alias inodes_available files_available
+
+      # Creates a new CzSystemInfo::Filesystem::Stat object. This is meant for
+      # internal use only. Do not instantiate directly.
+      #
+      def initialize
+        @path             = nil
+        @block_size       = nil
+        @fragment_size    = nil
+        @blocks           = nil
+        @blocks_free      = nil
+        @blocks_available = nil
+        @files            = nil
+        @files_free       = nil
+        @files_available  = nil
+        @filesystem_id    = nil
+        @flags            = nil
+        @name_max         = nil
+        @base_type        = nil
+      end
+
+      # Returns the total space on the partition.
+      def bytes_total
+        blocks * fragment_size
+      end
+
+      # Returns the total amount of free space on the partition.
+      def bytes_free
+        blocks_free * fragment_size
+      end
+
+      # Returns the amount of free space available to unprivileged processes.
+      def bytes_available
+        blocks_available * fragment_size
+      end
+
+      # Returns the total amount of used space on the partition.
+      def bytes_used
+        bytes_total - bytes_free
+      end
+
+      # Returns the percentage of the partition that has been used.
+      def percent_used
+        100 - (100.0 * bytes_free.to_f / bytes_total.to_f)
+      end
+    end
+
+    # Mount objects are returned by the CzSystemInfo::Filesystem.mounts method.
+    class Mount
+      # The name of the mounted resource.
+      attr_accessor :name
+
+      # The mount point/directory.
+      attr_accessor :mount_point
+
+      # The type of filesystem mount, e.g. ufs, nfs, etc.
+      attr_accessor :mount_type
+
+      # A list of comma separated options for the mount, e.g. nosuid, etc.
+      attr_accessor :options
+
+      # The time the filesystem was mounted. May be nil.
+      attr_accessor :mount_time
+
+      # The dump frequency in days. May be nil.
+      attr_accessor :dump_frequency
+
+      # The pass number of the filessytem check. May be nil.
+      attr_accessor :pass_number
+
+      alias fsname name
+      alias dir mount_point
+      alias opts options
+      alias passno pass_number
+      alias freq dump_frequency
+
+      # Creates a CzSystemInfo::Filesystem::Mount object. This is meant for internal
+      # use only. Do no instantiate directly.
+      #
+      def initialize
+        @name = nil
+        @mount_point = nil
+        @mount_type = nil
+        @options = nil
+        @mount_time = nil
+        @dump_frequency = nil
+        @pass_number = nil
+      end
+    end
+
+    # Returns a CzSystemInfo::Filesystem::Stat object containing information about the
+    # +path+ on the filesystem.
+    #
+    # Examples:
+    #
+    #    # path
+    #    CzSystemInfo::Filesystem.stat("path")
+    #
+    #    # Pathname
+    #    pathname = Pathname.new("path")
+    #    CzSystemInfo::Filesystem.stat(pathname)
+    #
+    #    # File
+    #    file = File.open("file", "r")
+    #    CzSystemInfo::Filesystem.stat(file)
+    #
+    #    # Dir
+    #    dir = Dir.open("/")
+    #    CzSystemInfo::Filesystem.stat(dir)
+    #
+    def self.stat(path)
+      path = path.path if path.respond_to?(:path) # File, Dir
+      path = path.to_s if path.respond_to?(:to_s) # Pathname
+
+      fs = Statvfs.new
+
+      if statvfs(path, fs) < 0
+        raise Error, "statvfs() function failed: #{strerror(FFI.errno)}"
+      end
+
+      obj = CzSystemInfo::Filesystem::Stat.new
+      obj.path = path
+      obj.block_size = fs[:f_bsize]
+      obj.fragment_size = fs[:f_frsize]
+      obj.blocks = fs[:f_blocks]
+      obj.blocks_free = fs[:f_bfree]
+      obj.blocks_available = fs[:f_bavail]
+      obj.files = fs[:f_files]
+      obj.files_free = fs[:f_ffree]
+      obj.files_available = fs[:f_favail]
+      obj.filesystem_id = fs[:f_fsid]
+      obj.flags = fs[:f_flag]
+      obj.name_max = fs[:f_namemax]
+
+      # OSX does things a little differently
+      if RbConfig::CONFIG['host_os'] =~ /darwin|osx|mach/i
+        obj.block_size /= 256
+      end
+
+      if fs.members.include?(:f_basetype)
+        obj.base_type = fs[:f_basetype].to_s
+      end
+
+      obj.freeze
+    end
+
+    # In block form, yields a CzSystemInfo::Filesystem::Mount object for each mounted
+    # filesytem on the host. Otherwise it returns an array of Mount objects.
+    #
+    # Example:
+    #
+    # CzSystemInfo::Filesystem.mounts{ |fs|
+    #   p fs.name        # => '/dev/dsk/c0t0d0s0'
+    #   p fs.mount_time  # => Thu Dec 11 15:07:23 -0700 2008
+    #   p fs.mount_type  # => 'ufs'
+    #   p fs.mount_point # => '/'
+    #   p fs.options     # => local, noowner, nosuid
+    # }
+    #
+    def self.mounts
+      array = block_given? ? nil : []
+
+      if respond_to?(:getmntinfo, true)
+        buf = FFI::MemoryPointer.new(:pointer)
+
+        num = getmntinfo(buf, 2)
+
+        if num == 0
+          raise Error, "getmntinfo() function failed: #{strerror(FFI.errno)}"
+        end
+
+        ptr = buf.get_pointer(0)
+
+        num.times do
+          mnt = Statfs.new(ptr)
+          obj = CzSystemInfo::Filesystem::Mount.new
+          obj.name = mnt[:f_mntfromname].to_s
+          obj.mount_point = mnt[:f_mntonname].to_s
+          obj.mount_type = mnt[:f_fstypename].to_s
+
+          string = ''
+          flags = mnt[:f_flags] & MNT_VISFLAGMASK
+
+          OPT_NAMES.each do |key, val|
+            if flags & key > 0
+              if string.empty?
+                string << val
+              else
+                string << ", #{val}"
+              end
+            end
+            flags &= ~key
+          end
+
+          obj.options = string
+
+          if block_given?
+            yield obj.freeze
+          else
+            array << obj.freeze
+          end
+
+          ptr += Statfs.size
+        end
+      else
+        begin
+          if respond_to?(:setmntent, true)
+            method_name = 'setmntent'
+            fp = setmntent(MOUNT_FILE, 'r')
+          else
+            method_name = 'fopen'
+            fp = fopen(MOUNT_FILE, 'r')
+          end
+
+          if fp.null?
+            raise SystemCallError.new(method_name, FFI.errno)
+          end
+
+          if RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
+            mt = Mnttab.new
+            while getmntent(fp, mt) == 0
+              obj = CzSystemInfo::Filesystem::Mount.new
+              obj.name = mt[:mnt_special].to_s
+              obj.mount_point = mt[:mnt_mountp].to_s
+              obj.mount_type = mt[:mnt_fstype].to_s
+              obj.options = mt[:mnt_mntopts].to_s
+              obj.mount_time = Time.at(Integer(mt[:mnt_time]))
+
+              if block_given?
+                yield obj.freeze
+              else
+                array << obj.freeze
+              end
+            end
+          else
+            while ptr = getmntent(fp)
+              break if ptr.null?
+              mt = Mntent.new(ptr)
+
+              obj = CzSystemInfo::Filesystem::Mount.new
+              obj.name = mt[:mnt_fsname]
+              obj.mount_point = mt[:mnt_dir]
+              obj.mount_type = mt[:mnt_type]
+              obj.options = mt[:mnt_opts]
+              obj.mount_time = nil
+              obj.dump_frequency = mt[:mnt_freq]
+              obj.pass_number = mt[:mnt_passno]
+
+              if block_given?
+                yield obj.freeze
+              else
+                array << obj.freeze
+              end
+            end
+          end
+        ensure
+          if fp && !fp.null?
+            if respond_to?(:endmntent, true)
+              endmntent(fp)
+            else
+              fclose(fp)
+            end
+          end
+        end
+      end
+
+      array
+    end
+
+    # Returns the mount point of the given +file+, or itself if it cannot
+    # be found.
+    #
+    # Example:
+    #
+    #  CzSystemInfo::Filesystem.mount_point('/home/some_user') # => /home
+    #
+    def self.mount_point(file)
+      dev = File.stat(file).dev
+      val = file
+
+      mounts.each do |mnt|
+        mp = mnt.mount_point
+        begin
+          if File.stat(mp).dev == dev
+            val = mp
+            break
+          end
+        rescue Errno::EACCES
+          next
+        end
+      end
+
+      val
+    end
+
+    # Attach the filesystem specified by +source+ to the location (a directory
+    # or file) specified by the pathname in +target+.
+    #
+    # Note that the +source+ is often a pathname referring to a device, but
+    # can also be the pathname of a directory or file, or a dummy string.
+    #
+    # By default this method will assume 'ext2' as the filesystem type, but
+    # you should update this as needed.
+    #
+    # Typically requires admin privileges.
+    #
+    # Example:
+    #
+    #   CzSystemInfo::Filesystem.mount('/dev/loop0', '/home/you/tmp', 'ext4', CzSystemInfo::Filesystem::MNT_RDONLY)
+    #
+    def self.mount(source, target, fstype = 'ext2', flags = 0, data = nil)
+      if mount_c(source, target, fstype, flags, data) != 0
+        raise Error, "mount() function failed: #{strerror(FFI.errno)}"
+      end
+
+      self
+    end
+
+    # Removes the attachment of the (topmost) filesystem mounted on target.
+    # Additional flags may be provided for operating systems that support
+    # the umount2 function. Otherwise this argument is ignored.
+    #
+    # Typically requires admin privileges.
+    #
+    def self.umount(target, flags = nil)
+      if flags && respond_to?(:umount2)
+        function = 'umount2'
+        rv = umount2_c(target, flags)
+      else
+        function = 'umount'
+        rv = umount_c(target)
+      end
+
+      if rv != 0
+        raise Error, "#{function} function failed: " + strerror(FFI.errno)
+      end
+
+      self
+    end
+  end
+end