pgbundle 0.0.1

data/lib/pgbundle/dsl.rb

@@ -0,0 +1,44 @@
+module PgBundle
+  # The Dsl class defines the Domain Specific Language for the PgFile
+  # it's mainly user to parse a PgFile and return a Definition Object
+  class Dsl
+    def initialize
+      @definition = Definition.new
+      @extensions = []
+    end
+
+    def eval_pgfile(pgfile, contents=nil)
+      contents ||= File.read(pgfile.to_s)
+      instance_eval(contents)
+      @definition
+    rescue SyntaxError => e
+      syntax_msg = e.message.gsub("#{pgfile}:", 'on line ')
+      raise PgfileError, "Pgfile syntax error #{syntax_msg}"
+    rescue ScriptError, RegexpError, NameError, ArgumentError => e
+      e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
+      puts e.backtrace.join("\n       ")
+      raise PgfileError, "There was an error in your Pgfile," \
+        " and pgbundle cannot continue. " \
+        + e.message
+    end
+
+    def database(*args)
+      opts = extract_options!(args)
+      @definition.database = Database.new(args.first, opts)
+    end
+
+    def pgx(*args)
+      opts = extract_options!(args)
+      ext = Extension.new(*args, opts)
+      @definition.extensions[ext.name] = ext
+    end
+
+    def extract_options!(arr)
+      if arr.last.is_a? Hash
+        arr.pop
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/pgbundle/extension.rb

@@ -0,0 +1,270 @@
+require 'net/ssh'
+module PgBundle
+  # The Extension class provides the api for defining an Extension
+  # it installation source, and dependencies
+  # example:
+  #   define an extension named 'foo' at version '0.1.1', with source on github depending on hstore
+  #   Extension.new('foo', '0.1.1', github: 'me/foo', requires: 'hstore')
+  #   you can then check if the Extension is available on a given database
+  #   extension.available?(database)
+  #   or install it along with it's dependencies
+  #   extension.install(database)
+  class Extension
+    attr_accessor :name, :version, :source, :resolving_dependencies
+    def initialize(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      @name, @version = args
+      self.dependencies = opts[:requires]
+      set_source(opts)
+    end
+
+    def dependencies
+      @dependencies
+    end
+
+    # set dependency hash with different options
+    # dependencies= {foo: Extension.new('foo'), bar: Extension.new('bar')}
+    # => {'foo' => Extension.new('foo'), 'bar' Extension.new('bar')}
+    # dependencies= 'foo'
+    # => {foo: Extension.new('foo')}
+    # dependencies= Extension.new('foo')
+    # => {foo: Extension.new('foo')}
+    # dependencies= ['foo', 'bar']
+    # => {'foo' => Extension.new('foo'), 'bar' Extension.new('bar')}
+    def dependencies=(obj = nil)
+      @dependencies = case obj
+      when nil
+        {}
+      when Hash
+        Hash[obj.map { |k, v| [k.to_s, v] }]
+      when String, Symbol
+        { obj.to_s => Extension.new(obj.to_s) }
+      when Extension
+        { obj.name => obj }
+      when Array
+        hashable = obj.map do |o|
+          case o
+          when String, Symbol
+            [o.to_s, Extension.new(obj.to_s)]
+          when Extension
+            [o.name, o]
+          end
+        end
+        Hash[hashable]
+      end
+    end
+
+    # returns true if extension is available for installation on a given database
+    def available?(database)
+      return false unless installed?(database)
+      return true if created?(database)
+
+      created_any_version?(database) ? updatable?(database) : creatable?(database)
+      rescue ExtensionCreateError
+        false
+    end
+
+    # returns true if extension is already created with the correct version in the given database
+    def created?(database)
+      if version
+        result = database.execute("SELECT * FROM pg_available_extension_versions WHERE name ='#{name}' AND version = '#{version}' AND installed").to_a
+      else
+        result = database.execute("SELECT * FROM pg_available_extension_versions WHERE name ='#{name}' AND installed").to_a
+      end
+
+      if result.empty?
+        false
+      else
+        true
+      end
+    end
+
+    # returns if the extension is already installed on the database system
+    # if it is also already created it returns the installed version
+    def installed?(database)
+      if version
+        result = database.execute("SELECT * FROM pg_available_extension_versions WHERE name ='#{name}' AND version = '#{version}'").to_a
+      else
+        result = database.execute("SELECT * FROM pg_available_extension_versions WHERE name ='#{name}'").to_a
+      end
+
+      if result.empty?
+        false
+      else
+        true
+      end
+    end
+
+    # checks that all dependencies are installed on a given database
+    def dependencies_installed?(database)
+      dependencies.all?{|_, d| d.installed?(database)}
+    end
+
+    # installs extension and all dependencies using make install
+    # returns true if Extension can successfully be created using CREATE EXTENSION
+    def install(database)
+      unless dependencies.empty?
+        install_dependencies(database)
+      end
+
+      make_install(database)
+      raise ExtensionNotFound.new(name, version) unless installed?(database)
+
+      add_missing_required_dependencies(database)
+
+      creatable?(database)
+    end
+
+    # completely removes extension be running make uninstall and DROP EXTENSION
+    def uninstall!(database)
+      drop_extension(database)
+      make_uninstall(database)
+    end
+
+    private
+
+    # create extension on a given database connection
+    def create!(con)
+      con.exec create_stmt
+    end
+
+    # create the dependency graph on the given connection
+    def create_dependencies(con)
+      @resolving_dependencies = true
+      dependencies.each do |_, d|
+        fail CircularDependencyError.new(name, d.name) if d.resolving_dependencies
+        d.create_dependencies(con)
+        d.create!(con)
+      end
+      @resolving_dependencies = false
+    end
+
+    # checks if Extension is already installed at any version thus need ALTER EXTENSION to install
+    def created_any_version?(database)
+      result = database.execute("SELECT * FROM pg_available_extension_versions WHERE name ='#{name}' AND installed").to_a
+      if result.empty?
+        false
+      else
+        true
+      end
+    end
+
+    # adds dependencies that are required but not defined yet
+    def add_missing_required_dependencies(database)
+      requires = requires(database)
+      requires.each do |name|
+        unless dependencies[name]
+          dependencies[name] = Extension.new(name)
+        end
+      end
+    end
+
+    # returns an array of required Extension specified in the extensions control file
+    def requires(database)
+      fail "Extension #{name} not (yet) installed" unless installed?(database)
+
+      stmt = if version
+        <<-SQL
+          SELECT unnest(requires) as name FROM
+          ( SELECT requires FROM  pg_available_extension_versions where name='#{name}' AND version ='#{version}') t
+        SQL
+      else
+        <<-SQL
+          SELECT unnest(requires) as name FROM
+          (SELECT requires FROM
+            pg_available_extensions a
+            JOIN pg_available_extension_versions v ON v.name = a.name AND a.default_version = v.version
+            WHERE v.name = '#{name}')t
+        SQL
+      end
+
+      result = database.execute(stmt).to_a
+
+      requires = result.map{|r| r['name']}
+    end
+
+    # loads the source and runs make uninstall
+    # returns: self
+    def make_uninstall(database)
+      database.make_uninstall(source, name)
+      self
+    end
+
+    def drop_extension(database)
+      database.drop_extension(name)
+    end
+
+    # loads the source and runs make install
+    # returns: self
+    def make_install(database)
+      return self if installed?(database)
+
+      fail SourceNotFound, name if source.nil?
+
+      database.make_install(source, name)
+      self
+    end
+
+    def create_stmt
+      stmt = "CREATE EXTENSION #{name}"
+      stmt += " VERSION '#{version}'" unless version.nil? || version.empty?
+
+      stmt
+    end
+
+    def install_dependencies(database)
+      begin
+        dependencies.each do |_, d|
+          d.install(database)
+        end
+      rescue InstallError, ExtensionCreateError => e
+        raise DependencyNotFound.new(name, e.message)
+      end
+
+      true
+    end
+
+    def creatable?(database)
+      dependencies_installed?(database) && installed?(database)
+    end
+
+    # hard checks that the dependency can be created running CREATE command in a transaction
+    def creatable!(database)
+      database.transaction_rollback do |con|
+        begin
+          create_dependencies(con)
+          create!(con)
+        rescue PG::UndefinedFile => err
+          raise ExtensionNotFound.new(name, version)
+        rescue PG::UndefinedObject => err
+          raise MissingDependency.new(name, err.message)
+        end
+      end
+
+      true
+    end
+
+    # checks that the extension can be updated running ALTER EXTENSION command in a transaction
+    def updatable?(database)
+      result = true
+      database.execute 'BEGIN'
+      begin
+        database.execute "ALTER EXTENSION #{name} UPDATE TO '#{version}'"
+      rescue PG::UndefinedFile, PG::UndefinedObject => err
+        @error = err.message
+        result = false
+      end
+      database.execute 'ROLLBACK'
+
+      result
+    end
+
+    def set_source(opts)
+      if opts[:path]
+        @source = PathSource.new(opts[:path])
+      elsif opts[:github]
+        @source = GithubSource.new(opts[:github])
+      end
+    end
+  end
+end

data/lib/pgbundle/github_source.rb

@@ -0,0 +1,32 @@
+require 'tmpdir'
+module PgBundle
+  # The GithubSource class defines a Github Source
+  class GithubSource < BaseSource
+    def load(host, user, dest)
+      clone(dest)
+      if host == 'localhost'
+        copy_local(clone_dir, dest)
+      else
+        copy_to_remote(host, user, clone_dir, dest)
+      end
+    end
+
+    def branch_name
+      @branch || 'master'
+    end
+
+    private
+
+    def clone(dest)
+      # git clone user@git-server:project_name.git -b branch_name /some/folder
+      %x((git clone git@github.com:#{path}.git -b #{branch_name} --quiet --depth=1 #{clone_dir} && rm -rf #{clone_dir}/.git}) 2>&1)
+      unless $?.success?
+        fail GitCommandError
+      end
+    end
+
+    def clone_dir
+      @clone_dir ||= Dir.mktmpdir
+    end
+  end
+end

data/lib/pgbundle/path_source.rb

@@ -0,0 +1,15 @@
+require 'tmpdir'
+require 'net/scp'
+module PgBundle
+  # The PathSource class defines a local Path Source
+  # eg. PathSource.new('/my/local/path')
+  class PathSource < BaseSource
+    def load(host, user, dest)
+      if host == 'localhost'
+        copy_local(path, dest)
+      else
+        copy_to_remote(host, user, path, dest)
+      end
+    end
+  end
+end

data/lib/pgbundle/version.rb

@@ -0,0 +1,3 @@
+module Pgbundle
+  VERSION = '0.0.1'
+end

data/pgbundle.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pgbundle/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pgbundle"
+  spec.version       = Pgbundle::VERSION
+  spec.authors       = ["Manuel Kniep"]
+  spec.email         = ["manuel@adjust.com"]
+  spec.summary       = %q{bundling postgres extension}
+  spec.description   = %q{bundler like postgres extension manager}
+  spec.homepage      = "http://github.com/adjust/pgbundle"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor'
+  spec.add_dependency 'net-ssh'
+  spec.add_dependency 'net-scp'
+  #https://bitbucket.org/ged/ruby-pg/wiki/Home
+  spec.add_dependency 'pg', '> 0.17'
+  spec.add_development_dependency 'rspec', '~> 2.14.0'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+end

data/spec/Pgfile

@@ -0,0 +1,6 @@
+database 'pgbundle_test', host: 'localhost'
+
+pgx 'hstore'
+pgx 'bar', path: './spec/sample_extensions/bar', requires: 'ltree'
+pgx 'baz', '0.0.2', path: './spec/sample_extensions/baz', requires: 'foo'
+pgx 'foo', '0.0.1', path: './spec/sample_extensions/foo'

data/spec/definition_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+describe PgBundle::Definition do
+  subject do
+    d = PgBundle::Definition.new
+    d.database = database
+    d.extensions['bar'] = PgBundle::Extension.new('bar', path: './spec/sample_extensions//bar', requires: 'ltree')
+    d.extensions['baz'] = PgBundle::Extension.new('baz', path: './spec/sample_extensions/baz', requires: 'foo')
+    d.extensions['foo'] = PgBundle::Extension.new('foo', '0.0.2', path: './spec/sample_extensions/foo')
+    d
+  end
+
+  it 'missing_extensions' do
+    subject.missing_extensions.map(&:name).should eq %w(bar baz foo)
+  end
+
+  it 'should install missing extension' do
+    subject.install.map(&:name).should eq %w(bar baz foo)
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe PgBundle::Dsl do
+
+  subject { PgBundle::Dsl.new.eval_pgfile(File.expand_path('../Pgfile', __FILE__)) }
+  its(:database) { should be_a PgBundle::Database }
+  its(:extensions) { should be_a Hash }
+end

data/spec/extension_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+describe PgBundle::Extension  do
+  describe 'Basiscs'  do
+    subject { PgBundle::Extension.new('foo', '1.2.3', github: 'bar/foo', requires: 'baz') }
+
+    its(:name) { should eq 'foo' }
+    its(:version) { should eq '1.2.3' }
+    its('dependencies.first.last') { should be_a PgBundle::Extension }
+    its(:source) { should be_a PgBundle::GithubSource }
+  end
+
+  describe 'Installation' do
+
+    context 'version available' do
+      subject { PgBundle::Extension.new('foo', '0.0.2', path: './spec/sample_extensions/foo') }
+
+      it 'should not be available before install' do
+        subject.available?(database).should be false
+      end
+
+      it 'should be available after install' do
+        subject.install(database)
+        subject.available?(database).should be true
+      end
+
+      context 'wrong version installed' do
+        subject { PgBundle::Extension.new('foo', '0.0.2', path: './spec/sample_extensions/foo') }
+        let(:wrong_version) { PgBundle::Extension.new('foo', '0.0.1', path: './spec/sample_extensions/foo') }
+        before do
+          wrong_version.install(database)
+          database.connection.exec "CREATE EXTENSION foo VERSION '0.0.2'"
+        end
+
+        it 'should be already installed' do
+          subject.should be_created_any_version(database)
+        end
+
+        it 'should be available' do
+          subject.should be_available(database)
+        end
+      end
+
+      context 'with require' do
+        let(:dependend) { PgBundle::Extension.new('bar', path: './spec/sample_extensions/bar', requires: 'ltree') }
+        subject { PgBundle::Extension.new('foo', '0.0.2', path: './spec/sample_extensions/foo', requires: dependend) }
+
+        it 'requires should be installable' do
+          dependend.should_not be_available(database)
+          subject.install(database).should be true
+          dependend.should be_available(database)
+        end
+
+      end
+    end
+
+    context 'version not available' do
+      subject { PgBundle::Extension.new('foo', '0.0.3', path: './spec/sample_extensions/foo') }
+
+      it 'should raise ExtensionNotFound' do
+        expect { subject.install(database) }.to raise_error PgBundle::ExtensionNotFound, 'specified Version 0.0.3 for Extension foo not available'
+      end
+
+      it 'should not be available although it is installed' do
+        subject.available?(database).should be false
+      end
+    end
+
+    context 'require not found'  do
+      subject { PgBundle::Extension.new('foo', '0.0.2', path: './spec/sample_extensions/foo', requires: PgBundle::Extension.new('noope')) }
+
+      it 'should raise DependencyNotFound' do
+        expect { subject.install(database) }.to raise_error PgBundle::DependencyNotFound, "Can't install Dependency for Extension foo: Source for Extension noope not found"
+      end
+    end
+  end
+end