manageiq-smartstate 0.1.0

data/lib/fs/MetakitFS/test/MkSelectFiles.rb

@@ -0,0 +1,30 @@
+require 'log4r'
+require 'fs/MiqFsUtil'
+require 'fs/MiqFS/MiqFS'
+require 'fs/MetakitFS/MetakitFS'
+require 'fs/MiqFS/modules/LocalFS'
+
+#
+# Formatter to output log messages to the console.
+#
+$stderr.sync = true
+class ConsoleFormatter < Log4r::Formatter
+  def format(event)
+    t = Time.now
+    "#{t.hour}:#{t.min}:#{t.sec}: " + (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+  end
+end
+$log = Log4r::Logger.new 'toplog'
+Log4r::StderrOutputter.new('err_console', :level => Log4r::DEBUG, :formatter => ConsoleFormatter)
+$log.add 'err_console'
+
+dobj = OpenStruct.new
+dobj.mkfile = ARGV[1]
+dobj.create = true
+
+toFs  = MiqFS.new(MetakitFS, dobj)
+fromFs  = MiqFS.new(LocalFS, nil)
+
+cf = MiqFsUtil.new(fromFs, toFs, ARGV[0])
+cf.verbose = true
+cf.update

data/lib/fs/MetakitFS/test/collect_files.yaml

@@ -0,0 +1,70 @@
+--- 
+- 
+  :basedir: "../../../.."
+  :todir: /
+  :include: 
+    # Common
+    - lib/metadata
+    - lib/util
+    - lib/disk
+    - lib/fs
+    - lib/fs/MetakitFS/test/init.rb
+    - lib/db
+    - lib/encryption
+    - lib/VMwareWebService
+    - lib/MiqWebService
+    - lib/blackbox
+    - lib/esx_lib_hooks/miq_lib_hooks.so
+    - lib/MiqVm
+    - lib/VolumeManager
+    # miqhost
+    - host/miqhost/etc
+    - host/miqhost/data
+    - host/miqhost/scheduler
+    - host/miqhost/certs
+    - host/miqhost/miqhost.rb
+    - host/miqhost/expose_services.rb
+    - host/miqhost/MiqHostConfig.rb
+    - host/miqhost/process_queue.rb
+    - host/miqhost/heartbeat.rb
+    - host/miqhost/EmsEventMonitor.rb
+    - host/miqhost/InstallWin.rb
+    - host/miqhost/InstallLinux.rb
+    - host/miqhost/PlatformConfig.rb
+    - host/miqhost/UpdateAgent.rb
+    - host/miqhost/MiqTest.rb
+    - host/miqhost/MiqHostWebServer.rb
+    # miq-cmd
+    - host/miq-cmd/main.rb
+  :exclude: 
+    - !ruby/regexp /\/\.svn/
+    - !ruby/regexp /~$/
+    - !ruby/regexp /\/NTFSCPP/
+    - !ruby/regexp /\/TestVm/
+    - !ruby/regexp /\/mk4test/
+    - !ruby/regexp /\.c$/
+    - !ruby/regexp /\.h$/
+    - !ruby/regexp /\.o$/
+    - !ruby/regexp /\.vhd$/
+    - !ruby/regexp /\.vmdk$/
+    - !ruby/regexp /dos_mbr.img$/
+    - !ruby/regexp /test.rb$/
+    - !ruby/regexp /test$/
+    - !ruby/regexp /\/rdoc$/
+    - !ruby/regexp /\/examples$/
+    - !ruby/regexp /\/doc$/
+    - !ruby/regexp /\/miqCryptInit.rb$/
+    - !ruby/regexp /\/miqbb100.zip$/
+    - !ruby/regexp /\/VMwareWebService\/.*\.wsdl$/
+  :encrypt: 
+    - !ruby/regexp /\.rb$/
+  :noencrypt: 
+    - !ruby/regexp /\/encryption\//
+    - !ruby/regexp /\/etc\//
+    - !ruby/regexp /\/MetakitFS.rb$/
+    - !ruby/regexp /\/init.rb$/
+  :compress: 
+    - !ruby/regexp /miq_lib_hooks.so$/
+    - !ruby/regexp /.*$/
+  :nocompress:
+    - !ruby/regexp /\/init.rb$/

data/lib/fs/MetakitFS/test/init.rb

@@ -0,0 +1,3 @@
+
+puts "__FILE__ = #{__FILE__}"
+puts "rubykit init file"

data/lib/fs/MetakitFS/test/mk2vmdk.rb

@@ -0,0 +1,64 @@
+require 'log4r'
+require 'ostruct'
+require 'disk/MiqDisk'
+
+VMDK  = "/Volumes/WDpassport/Virtual Machines/Red Hat Linux.vmwarevm/payload2.vmdk"
+MKFILE  = "rawmkfs"
+
+#
+# Formatter to output log messages to the console.
+#
+class ConsoleFormatter < Log4r::Formatter
+  def format(event)
+    (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+  end
+end
+$log = Log4r::Logger.new 'toplog'
+$log.level = Log4r::DEBUG
+Log4r::StderrOutputter.new('err_console', :formatter => ConsoleFormatter)
+$log.add 'err_console'
+
+diskInfo = OpenStruct.new
+diskInfo.mountMode = "rw"
+diskInfo.fileName = VMDK
+
+disk = MiqDisk.getDisk(diskInfo)
+
+unless disk
+  puts "Failed to open disk: #{diskInfo.fileName}"
+  exit(1)
+end
+
+puts "Disk type: #{disk.diskType}"
+puts "Disk partition type: #{disk.partType}"
+puts "Disk block size: #{disk.blockSize}"
+puts "Disk start LBA: #{disk.lbaStart}"
+puts "Disk end LBA: #{disk.lbaEnd}"
+puts "Disk start byte: #{disk.startByteAddr}"
+puts "Disk end byte: #{disk.endByteAddr}"
+puts
+
+parts = disk.getPartitions
+
+if parts && !parts.empty?
+  puts "Disk is partitioned, exiting"
+  exit(0)
+end
+
+diskSize = disk.endByteAddr - disk.startByteAddr
+mkSize = File.size(MKFILE)
+diskOffset = diskSize - mkSize
+
+puts "Disk size:   #{diskSize}"
+puts "Mk size:     #{mkSize}"
+puts "Disk offset: #{diskOffset}"
+
+mkf = File.open(MKFILE)
+
+disk.seek(diskOffset)
+while (buf = mkf.read(1024))
+  disk.write(buf, buf.length)
+end
+
+mkf.close
+disk.close

data/lib/fs/MetakitFS/test/mk4test.c

@@ -0,0 +1,92 @@
+
+#include <stdio.h>
+#include <unistd.h>
+#include <mk4.h>
+#include <ruby.h>
+
+const char *MK_FENTRY   = "fentry[fpath:S,ftype:I,fsize:I,ftags:B,fdata:B]";
+const char *MK_HASHVW   = "sec[_H:I,_R:I]";
+
+const char *SAMP_FILE   = "/lib/fs/MetakitFS/test/init.rb";
+
+const char *
+get_exepath(char *argv[])
+{
+	static char exe_path[PATH_MAX];
+#	if defined (WIN)
+		GetModuleFileName(NULL, exe_path, MPATH_MAX);
+#   elif defined (LINUX)
+		char proc_path[MPATH_MAX];
+		int len;
+		
+		sprintf(proc_path, "/proc/%d/exe", getpid());
+		if ((len = readlink(proc_path, exe_path, sizeof(exe_path)-1)) != -1)	{
+			exe_path[len] = '\0';
+		}
+		else	{
+			perror(proc_path);
+			exit(1);
+		}
+#	else
+        char *p;
+        
+        if ((p = getenv("_")) != NULL)    {
+            strcpy(exe_path, p);
+        }
+        else    {
+            strcpy(exe_path, argv[0]);
+        }
+#   endif
+	return(exe_path);
+}
+
+main(int argc, char *argv[])
+{
+    int             findex;
+    long            flen;
+    const t4_byte   *buf_ptr;
+    c4_Row          findRow;
+    c4_Row          row;
+    
+    c4_StringProp   pPath("fpath");
+    c4_IntProp      pType("ftype");
+    c4_IntProp      pSize("fsize");
+    c4_BytesProp    pData("fdata");
+    
+    c4_Storage storage (get_exepath(argv), true);    
+    printf("Descriptiom: %s\n", storage.Description());
+    
+    c4_View vData   = storage.GetAs(MK_FENTRY);
+    c4_View vSec    = storage.GetAs(MK_HASHVW);
+    c4_View vFentry = vData.Hash(vSec, true);
+        
+    pPath.Set(findRow, SAMP_FILE);
+    findex = vFentry.Find(findRow, 0);
+    printf("%s file index = %d\n", SAMP_FILE, findex);
+    
+    if (findex < 0) {
+        printf("File not found: %s\n", SAMP_FILE);
+        exit(1);
+    }
+    
+    row = vFentry.GetAt(findex);
+    printf("File: %s, Size: %d\n", pPath.Get(row), pSize.Get(row));
+    
+    c4_Bytes file_data = pData.Get(row);
+    flen = file_data.Size();
+    printf("c4_Bytes.Size() = %ld\n", flen);
+    
+    buf_ptr = file_data.Contents();
+    
+    ruby_init(); 
+    ruby_init_loadpath();
+        
+    rb_funcall(rb_mKernel, rb_intern("eval"), 3,
+               rb_str_new((const char *)buf_ptr, flen),
+               rb_const_get(rb_mKernel, rb_intern("TOPLEVEL_BINDING")),
+               rb_str_new2("myFile.rb"));
+    
+    ruby_finalize();
+    exit(0);
+}
+

data/lib/fs/MetakitFS/test/mkFsTest.rb

@@ -0,0 +1,113 @@
+require 'ostruct'
+require 'find'
+require 'fileutils'
+
+require 'fs/MiqFS/MiqFS'
+require 'fs/MetakitFS/MetakitFS'
+
+# MK_FILE = "mk4test"
+MK_FILE = "newmkfs"
+FROM_DIR = "../.."
+SAMP_FILE = "/lib/fs/MetakitFS/MetakitFS.rb"
+
+def copyIn(fs, ff, tf)
+  File.open(ff) do |ffo|
+    tfo = fs.fileOpen(tf, "wb")
+    while (buf = ffo.read(1024))
+      tfo.write(buf, buf.length)
+    end
+    tfo.close
+  end
+end
+
+begin
+  # begin
+  #     File.delete(MK_FILE)
+  # rescue
+  # end
+  # FileUtils.cp("hello", MK_FILE)
+
+  dobj = OpenStruct.new
+  dobj.mkfile = MK_FILE
+  dobj.create = true
+
+  unless MetakitFS.supported?(dobj)
+    puts "#{MK_FILE} is not a mkfs"
+    exit
+  end
+
+  mkFS = MiqFS.new(MetakitFS, dobj)
+
+  # Dir.chdir FROM_DIR
+  # Find.find(".") do |path|
+  #     if File.directory? path
+  #         Find.prune if File.basename(path) == ".svn"
+  #         puts "Creating directory: #{path}"
+  #         mkFS.dirMkdir(path)
+  #     else
+  #         next if File.basename(path) == MK_FILE
+  #         puts "Copying file: #{path}"
+  #         copyIn(mkFS, path, path)
+  #     end
+  # end
+
+  puts
+  puts "*****************************"
+  puts
+
+  # puts "fsId = #{mkFS.fsId}"
+  # puts "Tags for /:"
+  # mkFS.tags("/").each { |t| puts "\t#{t}" }
+  # puts
+
+  mkFS.findEach("/") do |path|
+    puts "\t#{path}"
+    mkFS.fileOpen(path) do |_fo|
+      # tags = fo.tags
+      # if !tags.empty?
+      #     puts "\tTAGS:"
+      #     tags.each { |t| puts "\t\t#{t}" }
+      #     puts
+      # end
+    end
+  end
+
+  unless mkFS.hasTagName?("/", "LABEL")
+    puts "*** Adding label..."
+    mkFS.tagAdd("/", "LABEL=MIQPAYLOAD")
+  end
+
+  exit
+
+  puts
+  puts "*****************************"
+  puts
+
+  fo = mkFS.fileOpen(SAMP_FILE)
+  fo.addTag("Rich")
+  fo.addTag("was")
+  fo.addTag("here")
+  fo.close
+
+  puts "FILE: #{SAMP_FILE}"
+  mkFS.fileOpen(SAMP_FILE) do |fo|
+    puts "\tTAGS:"
+    fo.tags.each { |t| puts "\t\t#{t}" }
+    puts
+    puts "***** CONTENTS:"
+    unzipper = Zlib::Inflate.new
+    while (buf = fo.read(1024)).length != 0
+      unzipper << buf
+    end
+    puts unzipper.inflate(nil)
+  end
+
+  fo = mkFS.fileOpen(SAMP_FILE)
+  fo.deleteTag("was")
+  puts "\tTAGS:"
+  fo.tags.each { |t| puts "\t\t#{t}" }
+  fo.close
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/lib/fs/MetakitFS/test/proto.rb

@@ -0,0 +1,97 @@
+require 'mk4rb'
+
+require "fs/MetakitFS/MetakitFS"
+
+TYPE_FILE = 1
+TYPE_DIR  = 2
+
+TEST_DATA = "Hello World\n"
+
+begin
+  pPath = Metakit::StringProp.new "fpath"
+  pType, pSize = Metakit::IntProp[:ftype, :fsize]
+  pData = Metakit::BytesProp.new "fdata"
+
+  Metakit::Storage.open("myfile.dat", 1) do |storage|
+    puts "Description: #{storage.description}"
+    vData   = storage.get_as MetakitFS::MK_FENTRY
+    vSec    = storage.get_as MetakitFS::MK_HASHVW
+    vFentry = vData.hash(vSec, 1)
+
+    row = Metakit::Row.new
+
+    pPath.set row, "/etc/passwd"
+    pType.set row, TYPE_FILE
+    pSize.set row, 0
+    data = Metakit::Bytes.new("", 0)
+    pData.set row, data
+    vFentry.add row
+
+    pPath.set row, "/etc/hosts"
+    vFentry.add row
+
+    storage.commit
+  end # Metakit::Storage.open
+
+  findrow = Metakit::Row.new
+
+  Metakit::Storage.open("myfile.dat", 1) do |storage|
+    puts "Description: #{storage.description}"
+    raise "myfile.dat is not a MetakitFS" if storage.description != "#{MetakitFS::MK_FENTRY},#{MetakitFS::MK_HASHVW}"
+    vData   = storage.get_as MetakitFS::MK_FENTRY
+    vSec    = storage.get_as MetakitFS::MK_HASHVW
+    vFentry = vData.hash(vSec, 1)
+
+    (1..100).each do |n|
+      pPath.set findrow, "/etc/hosts"
+      idxsearch = vFentry.find(findrow, 0)
+      puts "idxsearch = #{idxsearch}"
+      raise "File not found: /etc/hosts" if idxsearch < 0
+
+      r = vFentry[idxsearch]
+      puts "row = #{r}"
+
+      puts "Path: #{pPath.get(r)}"
+      dataRef = pData.ref(r)
+      dsize = pSize.get(r)
+      puts "Data size: #{dsize}"
+
+      ds = "Line: #{n}\n"
+      data = Metakit::Bytes.new(ds, ds.length)
+      dataRef.modify(data, dsize, data.size)
+      # dataRef.modify(data, 8, 0) if n == 99
+      pSize.set(r, dsize + data.size)
+
+      storage.commit
+    end
+
+    puts
+    puts "****************"
+    puts
+
+    pPath.set findrow, "/etc/hosts"
+    idxsearch = vFentry.find(findrow, 0)
+    raise "File not found: /etc/hosts" if idxsearch < 0
+
+    r = vFentry[idxsearch]
+
+    puts "Path: #{pPath.get(r)}"
+    puts "idxsearch = #{idxsearch}"
+    puts "row = #{r}"
+    dataRef = pData.ref(r)
+    dsize = pSize.get(r)
+    puts "Data size: #{dsize}"
+
+    rs = 100
+    rp = 0
+    loop do
+      rb = dataRef.access(rp, rs)
+      break if rb.size == 0
+      print rb.contents
+      rp += rs
+    end
+  end
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/lib/fs/MiqFS/FsProbe.rb

@@ -0,0 +1,39 @@
+module FsProbe
+  MODDIR = File.expand_path(File.join(File.dirname(__FILE__), "modules"))
+
+  PROBE_FILES = Dir.glob(File.join(MODDIR, "*Probe.rb*"))
+  PROBE_FILES.each do |p|
+    p.slice!(0..MODDIR.length)
+    p.chomp!(".enc")
+    p.chomp!(".rb")
+  end
+  # Reorder known probes for optimization
+  PROBE_FILES.unshift("Fat32Probe")    if PROBE_FILES.delete("Fat32Probe")
+  PROBE_FILES.unshift("Reiser4Probe")  if PROBE_FILES.delete("Reiser4Probe")
+  PROBE_FILES.unshift("ReiserFSProbe") if PROBE_FILES.delete("ReiserFSProbe")
+  PROBE_FILES.unshift("Ext4Probe")     if PROBE_FILES.delete("Ext4Probe")
+  PROBE_FILES.unshift("Ext3Probe")     if PROBE_FILES.delete("Ext3Probe")
+  PROBE_FILES.unshift("NTFSProbe")     if PROBE_FILES.delete("NTFSProbe")
+  PROBE_FILES.unshift("XFSProbe")      if PROBE_FILES.delete("XFSProbe")
+
+  def self.getFsMod(dobj, probes = nil)
+    probes = PROBE_FILES if probes.nil?
+    probes = [probes] unless probes.kind_of?(Array)
+
+    fname = dobj.dInfo.fileName || "" rescue ""
+    fname = dobj.dInfo.lvObj.lvName || "" if fname.empty? rescue ""
+    partNum = dobj.partNum
+
+    probes.each do |pmod|
+      $log.debug "MIQ(FsProbe-getFsMod) FS probe attempting [#{pmod}] for [#{fname}] [partition: #{partNum}]"
+      require_relative "modules/#{pmod}"
+      if Object.const_get(pmod).probe(dobj)
+        mod = pmod.chomp("Probe")
+        $log.info "MIQ(FsProbe-getFsMod) FS probe detected [#{mod}] for [#{fname}] [partition: #{partNum}]"
+        require_relative "modules/#{mod}"
+        return Object.const_get(mod)
+      end
+    end
+    nil
+  end
+end