pgbundle 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b9cc70db81cebbd38a1e0e58ed488170c31b63a
+  data.tar.gz: d53ffc2ec4eeb0ee68f4b2152bd454930d925171
+SHA512:
+  metadata.gz: fd4ad7ddb2a3e04d5ac26e51fb56892a52682f5b88647799a652bca003089f7a6f3f3d15ef41f3c422d09983e84e7fce562caedec603a98fd7136988194fbb88
+  data.tar.gz: 1876743b60fae52ecc8a59c928703b4f9d42a7b00da3ae746eec089a7ef47e4cf3deb5774db3045d05338822c9e57187c243a4c1b94d0568968769891c8421d1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - rbx-2
+  - 2.0.0
+  - 2.1.1
+matrix:
+  allow_failures:
+    - rvm: rbx-2
+addons:
+  postgresql: "9.3"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pgbundle.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Manuel Kniep
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# pgbundle
+
+bundling postgres extension
+
+## install
+
+  gem install pgbundle
+
+## usage
+
+define your dependent postgres extensions in a Pgfile like this:
+
+```
+#Pgfile
+
+database 'my_database', host: 'my.db.server', use_sudo: true, system_user: 'postgres'
+
+pgx 'hstore'
+pgx 'my_extension', '1.0.2', github: me/my_extension
+pgx 'my_other_extionsion', :git => 'https://github.com/me/my_other_extionsion.git'
+pgx 'my_ltree_dependend_extension', github: me/my_ltree_dependend_extension, require: 'ltree'
+```
+
+### install your extension
+
+  pgbundle install
+
+installs the extensions and dependencies on your database server
+
+### check your dependencies
+
+  pgbundle check
+
+checks whether all dependencies are available for creation on the database server
+
+## getting started
+
+if your already have some database on your current project you can get a starting point with
+
+  pgbundle init
+
+lets say your database named 'my_project' runs on localhost with user postges
+
+  pgbundle init my_project -u postgres -h localhost
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/bin/pgbundle

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'thor/group'
+require 'pgbundle'
+require 'pry'
+
+module PgBundle
+  class Cli < Thor
+    desc 'install', 'installs extensions'
+    def install(pgfile = 'Pgfile')
+      definition(pgfile).available_extensions.each do |dep|
+        say_status('exists', dep.name)
+      end
+
+      installed = definition(pgfile).install
+
+      installed.each do |d|
+        say_status('install', d.name, :yellow)
+      end
+    rescue InstallError, ExtensionCreateError, CircularDependencyError => e
+      say_status('error', e.message, :red)
+      exit 1
+    end
+
+    desc 'check', 'checks availability of required extensions'
+    def check(pgfile = 'Pgfile')
+      missing = false
+      definition(pgfile).check.each do |d|
+        if d[:created]
+          say_status('created', d[:name])
+        else
+          unless d[:installed]
+            say_status('missing', d[:name], :red)
+            missing = true
+          end
+          say_status('installed', d[:name], :yellow) if d[:installed]
+        end
+      end
+      exit 1 if missing
+    end
+
+    desc 'init', 'write an initial pgfile to stdout'
+    method_options %w( user -u ) => :string
+    method_options %w( host -h ) => :string
+    def init(db_name)
+      definition = PgBundle::Definition.new
+      definition.database = PgBundle::Database.new(db_name, options)
+      say("found the following definition for your current database:\n\n")
+      say definition.init.join("\n")
+    end
+
+    no_commands do
+      def definition(pgfile)
+        definition = Dsl.new.eval_pgfile(pgfile)
+        definition.link_dependencies
+      end
+    end
+  end
+end
+
+PgBundle::Cli.start(ARGV)

data/lib/pgbundle.rb

@@ -0,0 +1,59 @@
+require 'pgbundle/version'
+
+module PgBundle
+  autoload :Dsl, 'pgbundle/dsl'
+  autoload :Definition, 'pgbundle/definition'
+  autoload :Database, 'pgbundle/database'
+  autoload :Extension, 'pgbundle/extension'
+  autoload :BaseSource, 'pgbundle/base_source'
+  autoload :PathSource, 'pgbundle/path_source'
+  autoload :GithubSource, 'pgbundle/github_source'
+
+  class PgfileError < StandardError
+  end
+
+  class InstallError < StandardError; end
+  class ExtensionCreateError < StandardError; end
+  class CircularDependencyError < StandardError
+    def initialize(base, dep)
+      super "Circular Dependency between #{base} and #{dep} detected"
+    end
+  end
+
+  class TransactionRollback < StandardError; end
+
+  class ExtensionNotFound < ExtensionCreateError
+    def initialize(name, version = nil)
+      if version
+        super "specified Version #{version} for Extension #{name} not available"
+      else
+        super "Extension #{name} not available"
+      end
+    end
+  end
+
+  class SourceNotFound < InstallError
+    def initialize(name)
+      super "Source for Extension #{name} not found"
+    end
+  end
+
+  class DependencyNotFound < ExtensionCreateError
+    def initialize(base_name, dependen_msg)
+      super "Can't install Dependency for Extension #{base_name}: #{dependen_msg}"
+    end
+  end
+
+  class MissingDependency < ExtensionCreateError
+    def initialize(base_name, dependen_msg)
+      required = dependen_msg[/required extension \"(.*?)\" is not installed/, 1]
+      super "Dependency #{required} for Extension #{base_name} is not defined"
+    end
+  end
+
+  class GitCommandError < InstallError
+    def initialize
+      super 'Failed to load git repository'
+    end
+  end
+end

data/lib/pgbundle/base_source.rb

@@ -0,0 +1,26 @@
+module PgBundle
+  # The BaseSource class defines an Extension source like PathSource or GithubSource
+  # it defines how to get the code and run make install on a given host (e.g. database server)
+  class BaseSource
+    attr_accessor :path
+    def initialize(path)
+      @path = path
+    end
+
+    def load(host, user, dest)
+      fail NotImplementedError
+    end
+
+    private
+
+    def copy_local(source, dest)
+      FileUtils.cp_r source, dest
+    end
+
+    def copy_to_remote(host, user, source, dest)
+      Net::SCP.start(host, user) do |scp|
+        scp.upload(source, dest, recursive: true)
+      end
+    end
+  end
+end

data/lib/pgbundle/database.rb

@@ -0,0 +1,133 @@
+require 'pg'
+require 'pry'
+module PgBundle
+  # The Database class defines on which database the extensions should be installed
+  # Note to install an extension the code must be compiled on the database server
+  # on a typical environment ssh access is needed if the database host differs from
+  # the Pgfile host
+  class Database
+    attr_accessor :name, :user, :host, :system_user, :use_sudo
+    def initialize(name, opts = {})
+      @name        = name
+      @user        = opts[:user]        || 'postgres'
+      @host        = opts[:host]        || 'localhost'
+      @use_sudo    = opts[:use_sudo]    || false
+      @system_user = opts[:system_user] || 'postgres'
+    end
+
+    def connection
+      @connection ||= begin
+        PG.connect(dbname: name, user: user, host: host)
+      end
+    end
+
+    # executes the given sql on the database connections
+    # redirects all noise to /dev/null
+    def execute(sql)
+      silence do
+        connection.exec sql
+      end
+    end
+
+    def transaction(&block)
+      silence do
+        connection.transaction(&block)
+      end
+    end
+
+    def transaction_rollback(&block)
+      silence do
+        connection.transaction do |con|
+          yield con
+          fail TransactionRollback
+        end
+      end
+
+      rescue TransactionRollback
+    end
+
+    # loads the source, runs make install and removes the source afterwards
+    def make_install(source, ext_name)
+      remove_source(ext_name)
+      source.load(host, system_user, load_destination(ext_name))
+      run(make_install_cmd(ext_name))
+      remove_source(ext_name)
+    end
+
+    # loads the source and runs make uninstall
+    def make_uninstall(source, ext_name)
+      remove_source(ext_name)
+      source.load(host, system_user, load_destination(ext_name))
+      run(make_uninstall_cmd(ext_name))
+      remove_source(ext_name)
+    end
+
+    def drop_extension(name)
+      execute "DROP EXTENSION IF EXISTS #{name}"
+    end
+
+    def load_destination(ext_name)
+      "/tmp/#{ext_name}"
+    end
+
+    # returns currently installed extensions
+    def current_definition
+      result = execute('SELECT name, version, requires FROM pg_available_extension_versions WHERE installed').to_a
+    end
+
+    private
+
+    def sudo
+      use_sudo ? 'sudo' : ''
+    end
+
+    def remove_source(name)
+      run("rm -rf #{load_destination(name)}")
+    end
+
+    def make_install_cmd(name)
+      "cd #{load_destination(name)} && #{sudo} make clean && make install"
+    end
+
+    def make_uninstall_cmd(name)
+      "cd #{load_destination(name)} && #{sudo} make uninstall"
+    end
+
+    def run(cmd)
+      if host == 'localhost'
+        local cmd
+      else
+        remote cmd
+      end
+    end
+
+    def local(cmd)
+      %x(#{cmd})
+    end
+
+    def remote(cmd)
+      Net::SSH.start(host, system_user) do |ssh|
+        ssh.exec cmd
+      end
+    end
+
+
+    def silence
+      begin
+        orig_stderr = $stderr.clone
+        orig_stdout = $stdout.clone
+        $stderr.reopen File.new('/dev/null', 'w')
+        $stdout.reopen File.new('/dev/null', 'w')
+        retval = yield
+      rescue Exception => e
+        $stdout.reopen orig_stdout
+        $stderr.reopen orig_stderr
+        raise e
+      ensure
+        $stdout.reopen orig_stdout
+        $stderr.reopen orig_stderr
+      end
+      retval
+    end
+  end
+end

data/lib/pgbundle/definition.rb

@@ -0,0 +1,70 @@
+require 'pg'
+module PgBundle
+  # The Definition class collects all objects defined in a PgFile
+  class Definition
+    attr_accessor :database, :extensions, :errors
+    def initialize
+      @extensions = {}
+      @errors = []
+    end
+
+    # returns an Array of missing Extensions
+    def missing_extensions
+      link_dependencies
+      extensions.select { |_, dep| !dep.available?(database) }.values
+    end
+
+    # returns an Array of already available Extensions
+    def available_extensions
+      link_dependencies
+      extensions.select { |_, dep| dep.available?(database) }.values
+    end
+
+    # installs missing extensions returns all successfully installed Extensions
+    def install
+      installed = missing_extensions.map do |dep|
+        dep.install(database)
+        dep
+      end
+
+      installed.select { |dep| dep.available?(database) }
+    end
+
+    def init
+      ["database '#{database.name}', host: '#{database.host}', user: #{database.user}, system_user: #{database.system_user}, use_sudo: #{database.use_sudo}"] +
+      database.current_definition.map do |r|
+        name, version = r['name'], r['version']
+        requires = r['requires'] ? ", requires: " + r['requires'].gsub(/[{},]/,{'{' => '%w(', '}' =>')', ','=> ' '}) : ''
+        "pgx '#{name}', '#{version}'#{requires}"
+      end
+    end
+
+    # returns an array hashes with dependency information
+    # [{name: 'foo', installed: true, created: false }]
+    def check
+      link_dependencies
+      extensions.map do |_,ext|
+        {
+          name: ext.name,
+          installed: ext.installed?(database),
+          created: ext.created?(database)
+        }
+      end
+    end
+
+    # links extension dependencies to each other
+    def link_dependencies
+      extensions.each do |_, ex|
+        undefined_dependencies = ex.dependencies.select { |k, v| v.source.nil? }.keys
+        undefined_dependencies.each do |name|
+          if extensions[name]
+            ex.dependencies[name] = extensions[name]
+          else
+            ex.dependencies[name] = PgBundle::Extension.new(name)
+          end
+        end
+      end
+      self
+    end
+  end
+end