kvm 0.0.1.pre

data/lib/kvm/archive.rb

@@ -0,0 +1,56 @@
+require 'kvm/resource'
+require 'kvm/artifact'
+require 'open-uri'
+
+module KVM
+  class Archive < FileResource
+    BASE_DIR=File.expand_path('archives', KVM_DIR)
+    
+    attr_reader :filename
+    
+    def initialize(name, dist = "bin")
+      @info = Artifact.parse_name(name, dist)
+      @ext = Archive.project_extension(@info[:project])
+      @filename = Artifact.filename(@info, @ext)
+      super(File.expand_path(Artifact.filename(@info, @ext), BASE_DIR))
+    end
+    
+    def generate!
+      download
+    end
+    
+    def download_url
+      "http://downloads.#{@info[:project]}.kuali.org/#{@info[:version]}/#{@filename}"
+    end
+    
+    def download
+      FileUtils.mkdir_p BASE_DIR
+      # this performs a redundant copy
+      # TODO: make moar bettar
+      # Thor get helper?
+      open(download_url) do |src|
+        File.open(File.join(BASE_DIR, @filename), "wb") do |dst|
+          FileUtils.copy_stream(src, dst)
+        end
+      end
+      #system("wget -P #{BASE_DIR} #{url}") || raise("Error downloading #{url}")
+    end
+
+    protected
+    
+    def self.project_extension(project)
+      case project
+        when 'kfs'
+          'zip'
+        when 'rice'
+          'tar.gz'
+        else
+          'tar.gz'
+      end
+    end
+    
+    def self.from_file(f)
+      Archive.new(File.basename(f))
+    end
+  end
+end

data/lib/kvm/artifact.rb

@@ -0,0 +1,28 @@
+module KVM
+  module Artifact
+    def self.parse_name(name, dist = "bin")
+      results = name.scan(/([[:alpha:]]+)-([[:alnum:]\.]+)(?:-([[:alpha:]]+))?.*/)
+      raise "Invalid artifact identifier #{name}" if results.length == 0
+      parsed = {
+        :name => name,
+        :project => results[0][0],
+        :version => results[0][1],
+        :dist => results[0][2]
+      }
+      parsed[:dist] = dist unless parsed[:project] == "kfs" # kfs only has a single distribution
+      parsed
+    end
+    
+    def self.to_name(info)
+      [ info[:project], info[:version], info[:dist] ].join('-')
+    end
+
+    def self.filename(info, ext)
+      [ dirname(info), ext ].join(".")
+    end
+
+    def self.dirname(info)
+      to_name(info)
+    end
+  end
+end

data/lib/kvm/db/jdbc_adapter.rb

@@ -0,0 +1,71 @@
+module KVM
+  module Db
+    class JdbcAdapter
+      DB_DRIVERS = {
+        'oracle' => 'oracle.jdbc.driver.OracleDriver',
+        'mysql' => 'com.mysql.jdbc.Driver'
+      }
+      
+      def initialize(db_config)
+        ensure_jruby
+        @db_config = db_config
+        @driver_jar = db_config.jar
+        load_driver
+      end
+      
+      def execute_update(sqls)
+        for sql in sqls
+          with_statement do |stmt|
+            next unless sql and sql.length > 0
+            KVM::LOG.info("Executing statement: " + sql)
+            stmt.executeUpdate(sql)
+          end
+        end
+      end
+      
+      protected
+      
+      def with_statement
+        with_connection do |con|
+          stmt = con.createStatement
+          begin
+            yield stmt
+          ensure
+            stmt.close
+          end
+        end
+      end
+      
+      def with_connection
+        con = jdbc_connect
+        begin
+          yield con
+        ensure
+          con.close
+        end
+      end
+      
+      def jdbc_connect
+        # load the jdbc driver
+        Java::JavaClass.for_name(DB_DRIVERS[@db_config.db_type])
+        props = java.util.Properties.new
+        props.setProperty("user", @db_config.username)
+        props.setProperty("password", @db_config.password)
+        # special case to automatically log in as sysdba when using 'sys' username
+        props.setProperty("internal_logon", "sysdba") if @db_config.db_type == 'oracle' and @db_config.username == 'sys'
+        java.sql.DriverManager.getConnection(@db_config.url, props)
+      end
+
+      def ensure_jruby
+        raise "This command must be run under JRuby" unless defined? JRUBY_VERSION
+      end
+      
+      def load_driver
+        raise "Please specify the driver jar in the 'jar' property" unless @driver_jar
+        # jrubiness follows...
+        require 'java'
+        require @driver_jar
+      end
+    end
+  end
+end

data/lib/kvm/db/oracle.rb

@@ -0,0 +1,23 @@
+require 'kvm/log'
+
+module KVM
+  module Db
+    module Oracle
+      def self.create_user(username, password)
+        [ %Q(create user #{username} identified by "#{password}" default tablespace users), 
+          "grant connect, resource to #{username}",
+          "grant create view to #{username}" ]
+      end
+      
+      def self.drop_user(user)
+        [ "drop user #{user} cascade" ]
+      end
+      
+      def self.parse_sql(db, file)
+        sql = File.read(file)
+        # naively strip comments and split statements
+        statements = sql.gsub(/^--.*$/, '').split(/^\/$/).map { |s| s.strip }
+      end
+    end
+  end
+end

data/lib/kvm/db/types.rb

@@ -0,0 +1,11 @@
+require 'kvm/db/oracle'
+
+module KVM
+  module Db
+    DB_TYPES = [ 'oracle', 'mysql' ]
+    DB_PLATFORMS = {
+      'oracle' => KVM::Db::Oracle,
+      'mysql' => nil
+    }
+  end
+end

data/lib/kvm/impex.rb

@@ -0,0 +1,109 @@
+require 'kvm/subversion'
+require 'kvm/source'
+require 'kvm/db/jdbc_adapter'
+require 'kvm/log'
+#require 'rake'
+#require 'ant'
+
+module KVM
+  class Impex
+    IMPEX_SOURCE=KVM::Source.new(KVM::Subversion::IMPEX_TOOL_REPO_PATH)
+    DRIVERS_DIRECTORY_OPT = 'drivers.directory'
+    DEFAULT_DRIVERS_DIRECTORY  = '/opt/java/drivers'
+    BUNDLED_ANT = File.expand_path(File.join('..', '..', 'support', 'ant'), File.dirname(__FILE__))
+
+    def initialize(dir)
+      @dir = dir
+    end
+    
+    def create_ddl(schema_dir, db_type, output_dir, opts = {})
+      run_gensql('create-ddl', schema_dir, db_type, { 'torque.sql.dir' => "#{output_dir}/sql" }.merge(opts))
+    end
+    
+    def dataxml_to_sql(schema_dir, db_type, output_dir, opts = {})
+      # generates datasql subdir in release
+      run_gensql('dataxml-to-sql', schema_dir, db_type, opts)
+      mv_dir "#{schema_dir}/datasql/", "#{output_dir}"
+    end
+    
+    def prepare_sqlloader(schema_dir, db_type, output_dir, opts = {})
+      # generates sqlloader subdir in release
+      run_gensql('prepare-sqlloader', schema_dir, db_type, opts)
+      mv_dir "#{schema_dir}/sqlloader/", "#{output_dir}"
+    end
+    
+    def apply_ddl(dataset_dir, db_type, url, user, password, opts = {})
+      run_db('apply-ddl', dataset_dir, db_type, url, user, password, opts)
+    end
+    
+    def apply_data_sql(dataset_dir, db_type, url, user, password, opts = {})
+      run_db('apply-data-sql', dataset_dir, db_type, url, user, password, opts)
+    end
+    
+    def apply_constraint_ddl(dataset_dir, db_type, url, user, password, opts = {})
+      run_db('apply-constraint-ddl', dataset_dir, db_type, url, user, password, opts)
+    end
+    
+    # compound commands
+    
+    def generate_sql(schema_dir, db_type, output_dir, opts = {})
+      LOG.info "Generating sql #{schema_dir} #{db_type} #{output_dir}"
+      create_ddl(schema_dir, db_type, output_dir, opts)
+      dataxml_to_sql(schema_dir, db_type, output_dir)
+      #prepare_sqlloader(schema_dir, db_type, output_dir)
+    end
+    
+    # like 'import' except can be used against pregenerated sql datasets
+    def apply_sql(dataset_dir, db_type, url, user, password, opts = {})
+      LOG.info "Applying sql #{dataset_dir} #{db_type}"
+      # first run without constraints  
+      apply_ddl(dataset_dir, db_type, url, user, password, opts) &&
+        # insert data
+        apply_data_sql(dataset_dir, db_type, url, user, password, opts) &&
+          # apply constraints
+          apply_constraint_ddl(dataset_dir, db_type, url, user, password, opts)
+    end
+        
+    protected
+    
+    def mv_dir(src, tgt_parent)
+      FileUtils.mkdir_p tgt_parent
+      FileUtils.mv src, tgt_parent
+    end
+    
+    def run_db(command, dataset_dir, db_type, url, user, password, opts = {})
+      run(command, {
+        'torque.schema.dir' => dataset_dir,
+        'import.torque.database' => db_type,
+        'import.torque.database.driver' => KVM::Db::JdbcAdapter::DB_DRIVERS[db_type],
+        'import.torque.database.url' => url,
+        'import.torque.database.user' => user,
+        'import.torque.database.password' => password
+      }.merge(opts))
+    end
+    
+    def run_gensql(command, schema_dir, db_type, opts = {})
+      run(command, {
+        'torque.schema.dir' => schema_dir,
+        'import.torque.database' => db_type
+      }.merge(opts))
+    end
+    
+    def run(command, opts)
+      LOG.debug command
+      LOG.debug opts
+      # HACK: because i don't have time to futz with this
+      drivers_dir = ENV['JDBC_DRIVERS_DIR'] || DEFAULT_DRIVERS_DIRECTORY
+      opts[DRIVERS_DIRECTORY_OPT] = drivers_dir unless opts[DRIVERS_DIRECTORY_OPT]
+
+      prop_array = opts.map { |k, v| "-D#{k}=#{v}" }
+      LOG.debug prop_array
+      ant_args = prop_array + [ "-f", "#{@dir}/impex/build.xml", command ]
+      command_line = ([ File.join(BUNDLED_ANT, 'bin', 'ant') ] + ant_args).join(" ")
+      LOG.debug command_line
+      system (command_line) || raise("Error running impex")
+    end
+  
+    IMPEX = KVM::Impex.new(IMPEX_SOURCE.path)
+  end
+end

data/lib/kvm/log.rb

@@ -0,0 +1,7 @@
+require 'logger'
+
+module KVM
+  # use Thor say for colors?
+  LOG = Logger.new(STDOUT)
+  LOG.level = Logger::INFO
+end

data/lib/kvm/resource.rb

@@ -0,0 +1,72 @@
+module KVM
+  class Resource
+    def exists?
+      false
+    end
+  
+    def generate!
+    end
+  
+    def get
+      exists = exists?
+      generate! unless exists
+      !exists
+    end
+    
+    def name
+      nil
+    end
+    
+    def self.list
+      []
+    end
+  end
+  
+  class FileSystemResource < KVM::Resource
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+  
+    def name
+      File.basename(@path)
+    end
+  
+    def exists?
+      !@path.nil? and self.class.is_resource?(@path)
+    end
+    
+    def nested_path(paths)
+      File.expand_path(File.join(paths), path)
+    end
+    
+    def self.list(glob=File.join(self::BASE_DIR, "*"))
+      Dir[glob].select { |f| is_resource?(f) }.map { |f| from_file(f) }
+    end
+    
+    protected
+    
+    def self.is_resource?(file)
+      file.exists?(file)
+    end
+    
+    def self.from_file(file)
+      file
+    end
+  end
+
+  class FileResource < KVM::FileSystemResource
+    protected
+    def self.is_resource?(f)
+      File.file?(f)
+    end
+  end
+  
+  class DirResource < KVM::FileSystemResource
+    protected
+    def self.is_resource?(f)
+      File.directory?(f)
+    end
+  end
+end

data/lib/kvm/rice_release.rb

@@ -0,0 +1,79 @@
+require 'kvm/resource'
+require 'kvm/artifact'
+require 'kvm/log'
+
+module KVM
+  class RiceRelease < DirResource
+    BASE_DIR=File.expand_path('releases', KVM_DIR)
+  
+    EXTRACTOR = {
+      '.tar.gz' => 'tar -zxf %s'
+    }
+    
+    def initialize(name, dist = "bin")
+      @info = Artifact.parse_name(name, dist)
+      super(File.expand_path(Artifact.dirname(@info), BASE_DIR))
+      LOG.debug "RELEASE DIR: " + path
+      LOG.debug "PATH EXISTS?"
+      LOG.debug File.directory?(path)
+    end
+    
+    #def name
+    #  super.gsub(/-bin$/, '')
+    #end
+    
+    def generate!
+      LOG.info "Extracting Rice release #{@info[:version]}"
+      RiceRelease.extract_release(Archive.new(Artifact.to_name(@info)), path)
+    end
+    
+    def dataset_dirs
+      Dir.glob(dataset_base_dir("*"))
+    end
+    
+    def dataset_base_dir(ds_name)
+      File.join(path, "database", ds_name + '-dataset')
+    end
+    
+    def dataset_dir(ds_name, db_type)
+      LOG.debug "dataset_dir " + ds_name
+      LOG.debug File.join(dataset_base_dir(ds_name), db_type)
+      File.join(dataset_base_dir(ds_name), db_type)
+    end
+    
+    def datasets
+      dataset_dirs.map { |d| File.basename(d).gsub(/-dataset$/, '') }
+    end
+    
+    def test_sql_file(type)
+      File.expand_path("scripts/ddl/rice-test-tables-#{type}.sql", path)
+    end
+    
+    protected
+    
+    def self.extract_release(archive, target_dir)
+      archive.get
+      EXTRACTOR.each do |key, cmd_format|
+        if archive.name =~ /.#{key}$/
+          command = cmd_format % archive.path
+          LOG.debug "Extracting #{archive.path} to #{BASE_DIR}"
+          LOG.debug command
+          FileUtils.mkdir_p target_dir
+          LOG.debug Dir[BASE_DIR + "/*"]
+          LOG.debug Dir[BASE_DIR + "/" + target_dir]
+          LOG.debug "target dir #{target_dir} exists?"
+          LOG.debug File.directory?(target_dir)
+          Dir.chdir target_dir do
+            system(command) || raise("Error extracting #{archive.path}")
+            return
+          end
+        end
+      end
+      raise "Unable to extract #{archive}"
+    end
+    
+    def self.from_file(f)
+      RiceRelease.new(File.basename(f))
+    end
+  end
+end