dbgeni 0.10.0

data/lib/dbgeni/commands/new.rb

@@ -0,0 +1,178 @@
+# Expects only one parameter, the directory of the new dbgeni directory structure
+
+ARGV << '--help' if ARGV.empty?
+
+if ARGV.length > 1 or %w(-h --help).include? ARGV[0]
+  puts "Error: only one parameter is allowed for the new command" if ARGV.length > 1
+  puts <<-EOF
+Usage: dbgeni new <path/to/directory/for/new/installer/structure>
+EOF
+  exit
+end
+
+require 'fileutils'
+
+directory = ARGV.shift
+
+# There can be two commands here - first is to create the directory
+# structure, the second is new-conf to just create the file, but only if
+# the directory exists.
+if %w(n new).include? $initial_command
+  if File.directory?(directory)
+    puts "Error: The directory already exists"
+    exit(1)
+  end
+
+  # create the base directory
+  begin
+    puts "creating directory: #{directory}"
+    FileUtils.mkdir_p(directory)
+  rescue Exception => e
+    puts "error: failed to create #{directory} - #{e.to_s}"
+    exit(1)
+  end
+
+  # create the directory to hold migrations
+  begin
+    puts "creating directory: #{directory}/migrations"
+    FileUtils.mkdir_p(directory+'/migrations')
+  rescue Exception => e
+    puts "error: failed to create #{directory}/migrations - #{e.to_s}"
+    exit(1)
+  end
+  # create the directory to hold code
+  begin
+    puts "creating directory: #{directory}/code"
+    FileUtils.mkdir_p(directory+'/code')
+  rescue Exception => e
+    puts "error: failed to create #{directory}/code - #{e.to_s}"
+    exit(1)
+  end
+
+  # create the directory to hold dml
+  begin
+    puts "creating directory: #{directory}/dml"
+    FileUtils.mkdir_p(directory+'/dml')
+  rescue Exception => e
+    puts "error: failed to create #{directory}/dml - #{e.to_s}"
+    exit(1)
+  end
+
+else
+  unless File.directory?(directory)
+    puts "Error: The directory #{directory} does not exist"
+    exit(1)
+  end
+end
+
+
+# Create the initial version of the configuration file
+begin
+  puts "creating file: #{directory}/.dbgeni"
+  conf = File.open("#{directory}/.dbgeni", "w")
+  conf.puts <<-EOF
+
+# This directory specifies the location of the migrations directory
+migrations_directory "./migrations"
+
+# This directory specifies the location of the DML files directory
+dml_directory "./dml"
+
+# This directory specifies the location of any code modules
+code_directory "./code"
+
+# This specifes the location of the plugin directory. Specifying this parameter
+# enables plugins and the directory must exist
+# plugin_directory "./dbgeni_plugins"
+
+# This specifies the type of database this installer is applied against
+# Valid values are oracle, mysql, sqlite, sybase however this is not validated
+# to enable different database plugins to easily be added.
+database_type "sqlite"
+
+# This is the table the installer logs applied migrations in the database
+# The default is dbgeni_migrations
+database_table "dbgeni_migrations"
+
+# Use the include_file option to load another config file, perhaps
+# containing environment details for many different environments in one place
+#
+# include_file '/path/to/include/file'
+
+
+# Environment Section
+#
+# There must be at least one environment, and at a minimum each environment
+# should define a username, database and password (except sqlite which only
+# requires a database to be specified)
+#
+# Typically there will be more than one enviroment block detailling development,
+# test and production but any number of environments are valid provided there is at least one.
+#
+# The environments can be defined here or in an included file.
+
+# Defaults - this section is optional and can be used to define parameters that must
+# appear in every environment, for example install_schema. If a parameter is defined
+# here, and also defined in the environment, then the value in the environment block
+# will override the default. If many default blocks are specified, in included files
+# for example, the parameters are merged. If any parameters are duplicated, the last to
+# be loaded will used.
+#
+# defaults {
+#  username 'scott'
+# }
+
+environment('development') {
+
+### SQLITE
+  database 'testdb.sqlite' # This is the only required connection parameter for sqlite
+
+### ORACLE
+#
+#  database 'DEV1'    # This is the name of an entry in the tns_names.ora file
+#  username 'scott'   # This is the username to connect as, and also the default schema
+#  password 'tiger'   # This is the password for the username
+#
+#  install_schema 'other' # Optional: If dbgeni connects as a database user, but the application is owned
+                          # by another user, set the application schema here
+
+### MYSQL
+#
+#  database 'DEV1'      # This is the database to use after connection
+#  username 'scott'     # This is the username to connect as
+#  password 'tiger'     # This is the password for the username
+#  hostname '127.0.0.1' # This is the hostname or IP mysql is running on
+                        # For localhost use the IP 127.0.0.1 or it will not work.
+#  port     '3306'      # This the port of the mysql service
+
+### SYBASE
+#
+#  database 'DEV1'       # This is the database to use after connection
+#  username 'scott'      # This is the username to connect as
+#  password 'tiger'      # This is the password for the username
+#  hostname '127.0.0.1'  # This is the hostname or IP sybase is running on
+#  port     '3306'       # This the port of the sybase service
+#  sybase_service 'dev1' # THis is the sybase service name defined in the sql.ini file
+
+
+#   Other parameters can be defined here to be used as replacement parameters in scripts
+#   or in plugins in future versions of dbgeni.
+#   param_name 'value'
+}
+
+#
+# environment('test') {
+#   username 'user'
+#   database 'TEST.WORLD'
+#   password ''
+# }
+#
+
+
+EOF
+rescue Exception => e
+  puts "error: failed to create #{directory}/.dbgeni - #{e.to_s}"
+  exit(1)
+end
+
+exit(0)

data/lib/dbgeni/config.rb

@@ -0,0 +1,325 @@
+module DBGeni
+
+  # Config understands the following:
+
+  # migrations_directory 'value' # This will be checked to ensure its a valid dir
+  #                              # and defaults to 'migrations'
+  # environment('development') {
+  #   username 'user' # this must be here, or it will error
+  #   database 'MYDB.WORLD'     # this must be here, or it will error. For Oracle, this is the TNS Name
+  #   password ''     # If this value is missing, it will be promoted for if the env is used.
+  # }
+  #
+  # environment('other environment') {
+  #   username '' # the environment block can be repeated for many environments
+  # }
+  #
+  # global_parameters { # These are common parameters to all environments, but they can be
+  #                     # overriden. Basically take global, merge in environment
+  #   param_name 'value'
+  # }
+
+  class Config
+    attr_reader   :environments
+    attr_reader   :current_environment
+    attr_reader   :migration_directory
+    attr_reader   :dml_directory
+    # ideally wnat code_dir to be code_directory, but then it clashes with the
+    # setter used in the config file, so need to change it. Probably more sensible
+    # like this than the migrations_directory vs migration_directory
+    #                            _-_
+    #
+    attr_reader   :code_dir
+    attr_reader   :db_type  # oracle, mysql, sqlite etc, default sqlite
+    attr_reader   :db_table # defaults to dbgeni_migrations
+    attr_reader   :config_file
+    attr_reader   :base_directory
+
+    DEFAULTS_ENV = '__defaults__'
+
+
+    def initialize
+      @migration_directory  = 'migrations'
+      @dml_directory        = 'dml'
+      @code_dir             = 'code'
+      @plugin_dir           =  nil
+      @db_type              = 'sqlite'
+      @db_table             = 'dbgeni_migrations'
+      @base_dir             = '.'
+      @environments         = Hash.new
+    end
+
+
+    def self.load_from_file(filename)
+      cfg = self.new
+      cfg.load_from_file(filename)
+    end
+
+
+    def load_from_file(filename)
+      if filename == nil
+        raise DBGeni::ConfigFileNotSpecified
+      end
+      raw_config = ''
+      self.base_directory = File.expand_path(File.dirname(filename))
+      @config_file        = File.expand_path(filename)
+      begin
+        File.open(@config_file) do |f|
+          raw_config = f.read
+        end
+      rescue Errno::ENOENT
+        raise DBGeni::ConfigFileNotExist, "#{@config_location} (expanded from #{filename}) does not exist"
+      end
+      load(raw_config)
+    end
+
+
+    # Normally this is assumed to be the location the config file is in.
+    # All relative file operations come from this directory
+    def base_directory=(dir)
+      @base_directory = dir
+      # If change the base directory, then unless migration dir is
+      # an absolute path, it will need to change too.
+      @migration_directory = File.join(@base_directory, @migration_directory) unless is_absolute_path?(@migration_directory)
+      @dml_directory       = File.join(@base_directory, @dml_directory) unless is_absolute_path?(@dml_directory)
+      @code_dir            = File.join(@base_directory, @code_dir)   unless is_absolute_path?(@code_dir)
+      if @plugin_dir
+        @plugin_dir          = File.join(@base_directory, @plugin_dir) unless is_absolute_path?(@plugin_dir)
+      end
+    end
+
+
+#    def get_environment(name)
+#      if name == nil
+#        # if there is only a single environment defined, then return it
+#        if @environments.keys.length == 1
+#          @environments[@environments.keys.first]
+#        else
+#          raise DBGeni::ConfigAmbiguousEnvironment, "More than one environment is defined"
+#        end
+#      else
+#        unless @environments.has_key?(name)
+#          raise DBGeni::EnvironmentNotExist
+#        end
+#        @environments[name]
+#      end
+#    end
+
+
+    def env
+      current_env
+    end
+
+
+    def current_env
+      if @current_environment
+        @environments[@current_environment]
+      elsif @environments.keys.reject{|i| i == DEFAULTS_ENV}.length == 1
+        @environments[@environments.keys.reject{|i| i == DEFAULTS_ENV}.first]
+      else
+        raise DBGeni::ConfigAmbiguousEnvironment, "More than one environment is defined"
+      end
+    end
+
+
+    def set_env(name=nil)
+      if name == nil
+        valid_envs = @environments.keys.reject{|i| i == DEFAULTS_ENV}
+        if valid_envs.length == 1
+          @current_environment = valid_envs.first
+        else
+          raise DBGeni::ConfigAmbiguousEnvironment, "More than one environment is defined"
+        end
+      elsif @environments.has_key?(name)
+        @current_environment = name
+      else
+        raise DBGeni::EnvironmentNotExist
+      end
+    end
+
+
+    def load(raw_config, recursed=false)
+      begin
+        self.instance_eval(raw_config)
+      rescue Exception => e
+        raise DBGeni::ConfigSyntaxError, e.to_s
+      end
+      merge_defaults unless recursed
+      self
+    end
+
+    def merge_defaults
+      if @environments.has_key? DEFAULTS_ENV
+        @environments.keys.each do |k|
+          next if k == DEFAULTS_ENV
+          @environments[k].__merge_defaults(@environments[DEFAULTS_ENV].__params)
+        end
+      end
+    end
+
+    def to_s
+      str = ''
+      str << "migrations_directory => #{@migration_directory}\n"
+      @environments.keys.sort.each do |k|
+        str << "\n\nEnvironment: #{k}\n"
+        str <<     "=============#{(1..k.length).map do "=" end.join}\n\n"
+        str << @environments[k].__to_s
+      end
+      str
+    end
+
+    ######################################
+    # Methods below here are for the DSL #
+    ######################################
+
+    # mig_dir could be defined as a file in current directory 'migrations'
+    # or it could be a relative directory './somedir/migrations'
+    # or it could be a full path '/somedir/migrations' or in windows 'C:\somedir\migrations'
+    # To use the migrations it needs to be expanded to a full path *somehow*.
+    # If it begins / or <LETTER>:\ then assume its full path, otherwise concatenate
+    # to the full path of the config file.
+    def migrations_directory(*p)
+      if p.length == 0
+        @migration_directory
+      else
+        if is_absolute_path?(p[0])
+          # it looks like an absolute path
+          @migration_directory = p[0]
+        else
+          # it looks like a relative path
+          if @base_directory
+            @migration_directory = File.join(@base_directory, p[0])
+          else
+            @migration_directory = p[0]
+          end
+        end
+      end
+    end
+
+    def dml_directory(*p)
+      if p.length == 0
+        @dml_directory
+      else
+        if is_absolute_path?(p[0])
+          # it looks like an absolute path
+          @dml_directory = p[0]
+        else
+          # it looks like a relative path
+          if @base_directory
+            @dml_directory = File.join(@base_directory, p[0])
+          else
+            @dml_directory = p[0]
+          end
+        end
+      end
+    end
+
+    def code_directory(*p)
+      if p.length == 0
+        @code_dir
+      else
+        if is_absolute_path?(p[0])
+          # it looks like an absolute path
+          @code_dir = p[0]
+        else
+          # it looks like a relative path
+          if @base_directory
+            @code_dir = File.join(@base_directory, p[0])
+          else
+            @code_dir = p[0]
+          end
+        end
+      end
+    end
+
+    def plugin_directory(*p)
+      if p.length == 0
+        @plugin_dir
+      else
+        if is_absolute_path?(p[0])
+          # it looks like an absolute path
+          @plugin_dir = p[0]
+        else
+          # it looks like a relative path
+          if @base_directory
+            @plugin_dir = File.join(@base_directory, p[0])
+          else
+            @plugin_dir = p[0]
+          end
+        end
+      end
+    end
+
+
+    def database_type(*p)
+      # TODO - consider putting validation here
+      @db_type = p[0]
+    end
+
+    def database_table(*p)
+      # TODO - consider putting validation here
+      @db_table = p[0]
+    end
+
+    # For some reason I cannot work out, this method is never getting
+    # call in the evaluated block. Ideally wanted to have migrations_directory
+    # and migrations_directory= so that it doesn't matter which is called.
+    # def migrations_directory=(value)
+    #   puts "called the equals one"
+    #   @migration_directory = value
+    # end
+
+
+    # Given a block of environment details, generate a new environment
+    # object. eg
+    # environment('some_name') do
+    #   database  ''
+    #   user      ''
+    #   password  prompt
+    #
+    #   some_dir_path '/path_to_directory'
+    def environment(name, &block)
+      env = Environment.new(name)
+      block.arity < 1 ? env.instance_eval(&block) : block.call(env)
+      env.__completed_loading
+      if @environments.has_key?(name)
+        @environments[name].__merge_environment(env)
+      else
+        @environments[name] = env
+      end
+    end
+
+    def defaults(&block)
+      environment(DEFAULTS_ENV, &block)
+    end
+
+
+    def include_file(*p)
+      file = p[0]
+      if !is_absolute_path?(file)
+        file = File.join(@base_directory, file)
+      end
+      begin
+        raw_config = ''
+        File.open(file) do |f|
+          raw_config = f.read
+        end
+        self.load(raw_config)
+      rescue Errno::ENOENT
+        raise DBGeni::ConfigFileNotExist, "Included config #{file} does not exist"
+      rescue DBGeni::ConfigSyntaxError
+        raise DBGeni::ConfigSyntaxError,  "Included config #{file} contains errors: #{e.to_s}"
+      end
+    end
+
+    private
+
+    def is_absolute_path?(path)
+      if path =~ /^\/|[a-zA-Z]:\\/
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/dbgeni/connectors/connector.rb

@@ -0,0 +1,59 @@
+module DBGeni
+
+  module Connector
+
+    def self.initialize(config)
+      required_class = setup(config.db_type)
+      conn = nil
+      begin
+        required_method = required_class.method("connect")
+      rescue NameError
+        raise DBGeni::InvalidConnectorForDBType, config.db_type
+      end
+      if config.db_type == 'sqlite' or (config.db_type == 'oracle' and RUBY_PLATFORM != 'java')
+        # don't need a host or port here, so make this a seperate call block
+        conn = required_method.call(config.env.username,
+                               # SQLITE doesn't need a password, so prevent asking for it
+                               # or it may be promoted for
+                               config.db_type == 'sqlite' ? '' : config.env.password,
+                               config.env.database)
+      else
+        conn = required_method.call(config.env.username,
+                                    config.env.password,
+                                    config.env.database,
+                                    config.env.hostname,
+                                    config.env.port)
+      end
+      if config.db_type == 'oracle'
+        if config.env.install_schema
+          if config.env.username != config.env.install_schema
+            conn.execute("alter session set current_schema=#{config.env.install_schema}")
+          end
+        end
+      end
+      conn
+    end
+
+    private
+
+    def self.setup(db_type)
+      begin
+        require "dbgeni/connectors/#{db_type}"
+      rescue Exception => e
+        puts "Error requiring connector: #{e.to_s}"
+        raise DBGeni::NoConnectorForDBType, db_type
+      end
+
+      required_class = nil
+      if Connector.const_defined?(db_type.capitalize)
+        required_class = Connector.const_get(db_type.capitalize)
+      else
+        raise DBGeni::NoConnectorForDBType, db_type
+      end
+      required_class
+    end
+
+  end
+
+end
+

data/lib/dbgeni/connectors/mysql.rb

@@ -0,0 +1,146 @@
+module DBGeni
+
+  module Connector
+
+    class Mysql
+      if RUBY_PLATFORM == 'java'
+        require 'java'
+        java_import 'com.mysql.jdbc.Driver'
+        java_import 'java.sql.DriverManager'
+      else
+        require 'mysql'
+      end
+
+      attr_reader :connection
+      attr_reader :database
+
+      def self.connect(user, password, database, host, port)
+        self.new(user, password, database, host, port=nil)
+      end
+
+      def disconnect
+        @connection.close
+      end
+
+      def execute(sql, *binds)
+        if RUBY_PLATFORM == 'java'
+          execute_jdbc(sql, *binds)
+        else
+          execute_native(sql, *binds)
+        end
+      end
+
+
+      def ping
+        results = self.execute('select 1 + 1 from dual')
+        if results.length == 1
+          true
+        else
+
+          false
+        end
+      end
+
+      def commit
+        @connection.commit
+      end
+
+      def rollback
+        @connection.rollback
+      end
+
+      def date_placeholder(bind_var)
+        "?" # ":#{bind_var}"
+      end
+
+      def date_as_string(dtm)
+        dtm.strftime '%Y-%m-%d %H:%M:%S'
+      end
+
+      private
+
+      def initialize(user, password, database, host, port=3306)
+        @database = database
+        begin
+          if RUBY_PLATFORM == 'java'
+            @connection = DriverManager.get_connection("jdbc:mysql://#{host}:#{port||3306}/#{database}", user, password)
+          else
+            @connection = ::Mysql.connect(host, user, password, database, port)
+          end
+        rescue Exception => e
+          raise DBGeni::DBConnectionError, e.to_s
+        end
+      end
+
+      def execute_native(sql, *binds)
+        # strange exception handling here. If you issue a select, the fetch works fine.
+        # However, something like create table blows up when fetch is called with noMethodError
+        # so it is being caught and thrown away ... hackish, but the mysql drive seems to be
+        # at fault, is badly documented and seems to be a bit rubbish. Ideall uses DBD::Mysql + DBI.
+
+        results = Array.new
+        if sql =~ /^drop\s+(procedure|function|trigger|table)/i
+          # cannot prepare these statements, need to just execute
+          @connection.query(sql)
+          return results
+        end
+
+        begin
+          query = @connection.prepare(sql)
+          query.execute(*binds)
+
+          results = Array.new
+          if query.num_rows > 0
+            while r = query.fetch()
+              results.push r
+            end
+          end
+          # everthing is auto commit right now ...
+          @connection.commit
+        rescue NoMethodError
+        ensure
+          begin
+            query.close()
+          rescue
+          end
+        end
+        results
+      end
+
+      def execute_jdbc(sql, *binds)
+        begin
+          query = @connection.prepare_statement(sql)
+          binds.each_with_index do |b, i|
+            if b.is_a?(String)
+              query.setString(i+1, b)
+            elsif b.is_a?(Fixnum)
+              query.setInt(i+1, b)
+            end
+          end
+          results = Array.new
+          unless sql =~ /^\s*(select|show)/i
+            query.execute()
+          else
+            rset = query.execute_query()
+            cols = rset.get_meta_data.get_column_count
+            while(r = rset.next) do
+              a = Array.new
+              1.upto(cols) do |i|
+                a.push rset.get_object(i)
+              end
+              results.push a
+            end
+          end
+          results
+        ensure
+          begin
+            query.close
+          rescue Exception => e
+          end
+        end
+      end
+
+    end
+  end
+end
+