prick 0.29.1 → 0.30.0

data/lib/prick/subcommand/prick-drop.rb

@@ -1,30 +1,73 @@
 #!/usr/bin/env ruby
 
-require 'builder/builder.rb'
+require_relative '../builder/builder.rb'
 
 module Prick::SubCommand
-  def self.drop_user(username) # No database so does not cascade
-    PgConn.new("postgres") { |conn|
-      conn.role.drop([username])
-    }
+  # Drop database owner
+  def self.drop_owner(username) 
+    # No database at this point so no session is running and no cascade. A nop
+    # if the user is the current user or owns objects in other databases
+    if username != ENV['USER']
+      super_conn.role.drop(username, fail: false, silent: true)
+    end
   end
 
-  # Drop all users associated with the given database except the owner
+  # Drop all users associated with the given database except the owner. We
+  # assume that users can only be connected to the project database and that
+  # they don't own objects in other databases
   def self.drop_users(database)
-    PgConn.new(database) { |conn|
-      users = conn.role.list(database: database)
-      conn.role.drop(users, cascade: true)
-    }
+    constrain database, String
+    conn = super_conn
+    if conn.rdbms.exist? database
+      users = conn.role.list(database: database).reject { _1 == conn.rdbms.owner(database) }
+      conn.session.terminate(database, users)
+      if conn.rdbms.exist?(database) 
+        # Connect to database to make cascade work. Run in a block to close connection afterwards
+        PgConn.new(database) { |conn| conn.role.drop(users, cascade: true) }
+      else
+        conn.rdbms.role.drop(users)
+      end
+    else
+      # We don't terminate sessions because we assume one-database-users
+      conn.role.drop(users, cascade: true) # Fails if the users owns objects in other databases
+    end
   end
 
+  # Drop a database
   def self.drop_database(database)
-    PgConn.new("postgres") { |conn| conn.rdbms.drop database }
+    State.connection.session.terminate(database, nil)
+    State.connection { |conn| conn.rdbms.drop database }
   end
 
-  def self.drop_all(database)
-    drop_users(database)
-    drop_database(database)
-    drop_user(username)
+  # Empty the database
+  def self.drop_schema(database, schemas = [])
+    constrain database, String
+    constrain schemas, [String]
+    if schemas.empty?
+      State.connection { |conn| conn.rdbms.empty!(database) }
+    else
+      Prick.state.connection { |conn|
+        schemas.each { |schema| conn.schema.drop(schema, cascade: true) }
+      }
+    end
+  end
+
+  # Drop database and its users including the owner if possible and not the
+  # current user
+  def self.drop_all(database, username = nil)
+    constrain database, String
+    State.connection { |conn|
+      if username.nil? && conn.rdbms.exist?(database)
+        owner = State.connection.rdbms.owner(database)
+      else
+        owner = username || database
+      end
+      if conn.rdbms.exist? database
+        drop_users(database) 
+        drop_database(database)
+      end
+      drop_owner(owner) if owner != ENV['USER']
+    }
   end
 end
 

data/lib/prick/subcommand/prick-fox.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'builder/builder.rb'
+require_relative '../builder/builder.rb'
 
 module Prick::SubCommand
   def self.fox(database, username, files)
@@ -37,7 +37,7 @@ __END__
           when :batches; builder.dump
           when nil;
         else
-          raise Prick::Error, "Illegal dump type: #{dump.inspect}"
+          Prick.error "Illegal dump type: #{dump.inspect}"
         end && exit
 
         time "Execute build object" do

data/lib/prick/subcommand/prick-init.rb

@@ -1,46 +1,53 @@
 require 'fileutils'
 
 module Prick::SubCommand
-  def self.init(dir, name, title, database, username)
+  def self.init(project_file, dir, name, title) # dir, name, and title can be nil
+    cwd = Dir.getwd
     if dir
-      !File.exist?(dir) or raise Prick::Error, "Directory #{dir} exists"
+      !File.exist?(dir) or Prick.error "Directory #{dir} exists"
       FileUtils.mkdir_p(dir)
       Dir.chdir(dir)
     else
       dir = "."
     end
-    name ||= File.basename(Dir.getwd)
-    title ||= name
-    database ||= name
-    username ||= name
+    dirname = File.basename(Dir.getwd)
+    name ||= dirname
+    title ||= name.gsub(/[_-]/, " ").capitalize
 
+    # Note that the initial project file is invalid and is removed again after
+    # the initial commit
     Command.command %(
       git init .
-      cp -a #{SHARE_PATH}/init/. .
+      dir=#{SHARE_PATH}/init
+      for path in $dir/*; do
+        source_file=$(basename $path)
+        dest_file=$(sed 's/^dot\././' <<<$source_file)
+        cp -a $dir/$source_file $dest_file
+      done
       git add .
       git commit -am "Initial import"
+      rm -f #{project_file} 
     ), fail: false
+    Command.status == 0 or Prick.failure "Failed creating initial import"
 
-    Command.status == 0 or raise Prick::Fail, "Init script failed"
-
-    state = State.new
+    # Write (valid) configuration file
+    state = State.new(project_file, nil, nil)
     state.name = name
     state.title = title
     state.prick_version = PrickVersion.new VERSION
     state.version = PrickVersion.new("0.0.0")
-    state.environment = :development
-    state.database = database
-    state.username = username
-    state.save
+    state.save_project
 
+    # Commit configuration file and create initial release
     Command.command %(
       set -e
+      git add #{project_file}
       git commit -am "Release 0.0.0"
-      git tag v0.0.0
+      git tag --message "Initial Release" v0.0.0
     ), fail: false
+    Command.status == 0 or Prick.failure "Failed creating initial release"
 
-    Command.status == 0 or raise Prick::Fail, "Init script failed"
-
-    [dir, state]
+    Dir.chdir(cwd)
+    [dir, name]
   end
 end

data/lib/prick/subcommand/prick-list.rb

@@ -0,0 +1,99 @@
+module Prick::SubCommand
+  def self.list_environments(format: :long)
+    environments = Environment.environments.select { |env| env.comment }
+    if format == :short
+      puts environments.map(&:name)
+    else
+      headers = %w(Environment Description)
+      rows = environments.map { |env| [env.name, env.comment] }
+      Fmt.puts_table(headers, rows)
+    end
+  end
+
+  def self.list_variables(format: :long, all: false)
+    if format == :short
+      puts Prick.state.bash_environment.keys
+    else
+      headers = %w(variable value)
+      vars = Prick.state.bash_environment(all: all).reject { |k,v| k == "PATH" }
+      rows = vars.map { |k,v| [k, Array(v).flatten.join(" ")] }
+      Fmt.puts_table(headers, rows)
+    end
+  end
+
+  def self.list_databases(format: :long)
+    constrain format, :long, :short
+    conn = State.connection
+#   databases = conn.values "select datname from pg_database where datistemplate = false order by datname;"
+
+    if format == :short
+      puts Prick.databases
+    else
+      fs_time = `find . -type f -not -path '*/\.*' -printf '%TF %TT\n' | sort -r | head -n 1`
+      git_branch = Git.branch.current
+      git_rev = Git.id[0...8]
+
+      rows = []
+      Prick.databases { |database, conn|
+        row = conn.record(%(
+          select 
+              '#{database}' as "database", name, version, branch, rev, clean, environment, 
+              to_char(
+                  built_at at time zone 'UTC' at time zone current_setting('TimeZone'), 
+                  'YYYY-MM-DD HH24:MI') as "built_at",
+              success
+          from prick.versions
+        ))
+
+        if row[:success]
+          clean = row[:clean]
+          same_revision = row[:branch] == git_branch && row[:rev] == git_rev
+          up2date = fs_time <= row[:built_at]
+          row[:state] = 
+              case [clean, same_revision, up2date]
+                in [true, true, true]; "clean"    # Clean repo
+                in [true, true, false]; "dirty"   # Clean repo but doesn't include latest changes
+                in [true, false, _]; "detached"   # Clean repo but different revision
+                
+                in [false, true, true]; "ok"      # Dirty repo
+                in [false, true, false]; "dirty"  # Dirty repo, but doesn't include latest changes
+                in [false, false, _]; "stale"     # Dirty repo, no way back
+              end
+        else
+          row[:state] = "-"
+        end
+
+        last_column = (Prick.state.database == database ? "*" : "")
+        rows << row.values + [last_column]
+      }
+
+      headers = %w(database project version branch rev clean environment built success state) + [" "]
+      Fmt.puts_table(headers, rows)
+    end
+  end
+
+  def self.list_users
+    puts State.connection.role.list(database: Prick.state.database)
+  end
+
+  def self.list_owners(format: :long)
+    owners = {}
+    Prick.databases.each { |database|
+#     owner = super_conn.rdbms.exist?(d) ? super_conn.rdbms.owner(d) : d 
+      owner = super_conn.rdbms.owner(database)
+      (owners[owner] ||= []) << database
+    }
+    if format == :short
+      puts owners.keys
+    else
+      headers = %w(username databases) + [" "]
+      rows = owners.map { |owner, databases| 
+        current_user_mark = (Prick.state.username == owner ? '*' : "")
+        [owner, databases.join(","), current_user_mark] 
+      }
+      Fmt.puts_table(headers, rows)
+    end
+  end
+end
+
+

data/lib/prick/subcommand/prick-make.rb

@@ -1,28 +1,28 @@
 #!/usr/bin/env ruby
 
-require 'builder/builder.rb'
+require_relative '../builder/builder.rb'
 
 module Prick::SubCommand
   def self.make(database, username, schema, timer: nil, dump: nil)
     Timer.on! if timer
     time "Prick::Command#make" do
       begin
-        super_conn = PgConn.new
+        super_conn = State.connection
         conn = nil
         builder = nil
-        built_at = EPOCH
+        last_built_at = EPOCH
         clean = false
         create_schemas = []
 
         time "Load build object" do
           if super_conn.rdbms.exist? database
-            conn = PgConn.new(database, username)
-            if conn.schema.exist_table?("prick", "versions") && !conn.empty?("prick.versions")
-              built_at = conn.value("select built_at from prick.versions")
+            conn = Prick.state.connection
+            if conn.schema.exist_relation?("prick", "versions") && !conn.empty?("prick.versions")
+              last_built_at = conn.value("select built_at from prick.versions")
             end
           else
             super_conn.rdbms.create database, owner: username
-            conn = PgConn.new(database, username)
+            conn = Prick.state.connection
             clean = true
           end
 
@@ -43,7 +43,7 @@ module Prick::SubCommand
             after_schemas.each { |delete_schema| builder.pool.delete_schema(delete_schema) }
           end
 
-          touched_nodes = builder.nodes.select { |node| File.mtime(node.path) > built_at }
+          touched_nodes = builder.nodes.select { |node| File.mtime(node.path) > last_built_at }
           touched_phases = touched_nodes.map(&:phase).uniq.compact
           touched_kinds = touched_nodes.map(&:kind).uniq.compact
           touched_schema = touched_nodes.first&.schema
@@ -74,7 +74,7 @@ module Prick::SubCommand
           when :batches; builder.dump
           when nil;
         else
-          raise Prick::Error, "Illegal dump type: #{dump.inspect}"
+          Prick.error "Illegal dump type: #{dump.inspect}"
         end
         exit if dump
 

data/lib/prick/subcommand/prick-migrate.rb

@@ -3,12 +3,13 @@ module Prick
   module SubCommand
 #   def self.migrate(database, username, file) TODO
     def self.migrate(database, username, file: nil)
-      PgConn.new(database, username) { |conn|
+      conn = Prick.state.connection
+#     PgConn.new(database, username) { |conn|
         conn.schema.exist_relation? "prick", "versions" or 
-            raise Prick::Fail, "Can't read version from database"
+            Prick.failure "Can't read version from database"
 
         from_version = PrickVersion.new(conn.value "select version from prick.versions") or
-            raise Prick::Fail, "Illegal version in table prick.versions"
+            Prick.failure "Illegal version in table prick.versions"
 
         if file
           conn.transaction {
@@ -16,12 +17,12 @@ module Prick
           }
         else
           to_version = Prick.state.version
-          from_version != to_version or raise Prick::Fail, "Already up to date"
-          from_version < to_version or raise Prick::Fail, "Can't migrate backwards"
+          from_version != to_version or Prick.failure "Already up to date"
+          from_version < to_version or Prick.failure "Can't migrate backwards"
 
           migration_dir = "#{MIGRATION_DIR}/#{from_version}" 
           File.directory? migration_dir or 
-              raise Prick::Fail, "Can't migrate from #{from_version} to #{to_version}"
+              Prick.failure "Can't migrate from #{from_version} to #{to_version}"
 
           puts "Migrating from #{from_version} to #{to_version}"
 
@@ -31,7 +32,7 @@ module Prick
             conn.exec File.read(SCHEMA_VERSION_PATH)
           }
         end
-      }
+#     }
     end
   end
 end

data/lib/prick/subcommand/prick-release.rb

@@ -8,15 +8,17 @@ module Prick
       Git.synchronized? or raise "Won't release: Repository is not synchronized with origin"
 
       version = Prick.state.version.increment!(kind).to_s
-      Prick.state.save
+      Prick.state.save_project
 
-      Git.add(Prick.state.file)
+      Git.add(Prick.state.project_file)
       Git.add(Prick.state.schema_file)
       Git.commit "Release #{version}"
       Git.tag.create "v#{version}"
       Git.branch.create version
       Git.push
 
+      # TODO TODO TODO
+
       puts version
     end
   end

data/lib/prick/subcommand/prick-set.rb

@@ -0,0 +1,52 @@
+require 'time' # For Time#parse
+
+module Prick::SubCommand
+  def self.set(variable, value = nil, arg = nil)
+    case variable
+      when "database"; set_database(value, arg)
+      when "environment"; set_environment(value)
+      when "duration"; set_duration(value)
+    else
+      return false
+    end
+    true
+  end
+
+  def self.set_environment(environment)
+    if environment
+      Prick.state.environment = environment
+      Prick.state.save_state
+    else
+      puts Prick.state.environment
+    end
+  end
+
+  # If the environment is nil, it is initialized from the database on next build
+  def self.set_database(database, environment = nil)
+    if database
+      conn = State.connection
+      conn.rdbms.exist? database or Prick.error "Database '#{database}' does not exist"
+      username = conn.rdbms.owner database
+
+      Prick.state.database = database
+      Prick.state.username = username
+
+      if environment.nil?
+        Prick.state.connection # Implicitly initialize database enviroment if present
+        environment = Prick.state.database_environment # or Prick.error "Can't find environment"
+      end
+      Prick.state.environment = environment
+      Prick.state.save_state
+    else
+      puts Prick.state.database
+    end
+  end
+
+  def self.set_duration(make_start)
+    conn = Prick.state.connection
+    built_at = conn.value "select built_at from prick.versions"
+    duration = Time.now - Time.iso8601(make_start)
+    conn.exec "update prick.versions set make_duration = #{duration}"
+  end
+end
+

data/lib/prick/subcommand/prick-setup.rb

@@ -1,20 +1,10 @@
 #!/usr/bin/env ruby
 
-require 'builder/builder.rb'
+require_relative '../builder/builder.rb'
 
 module Prick::SubCommand
-  def self.setup(database, username)
-    conn = PgConn.new("template1") # Connect to template1 because database might not exist
-    if !conn.role.exist? username
-      # FIXME Should not be created as superuser but we can't do that before we
-      # have a super: option in build
-      conn.role.create username, superuser: true, can_login: true, create_role: true
-    end
-    if !conn.rdbms.exist? database
-      conn.rdbms.create database, owner: username
-    end
-    builder = Prick::Build::Builder.new(conn, "schema")
-    # TODO Run builder setup scrips
+  def self.setup(database, username, environment)
+    create_database(database, username, environment)
+    set_database(database, environment)
   end
 end
-

data/lib/prick/subcommand/prick-teardown.rb

@@ -1,19 +1,23 @@
 #!/usr/bin/env ruby
 
-require 'builder/builder.rb'
+require_relative '../builder/builder.rb'
 
 module Prick::SubCommand
-  def self.teardown(database, username)
-    conn = PgConn.new "postgres" # Superuser connection
-    if conn.rdbms.exist? database
-      conn.rdbms.drop database, force: true
-    end
-    if conn.role.exist? username
-      conn.role.drop username, cascade: true
-    end
+  def self.teardown(*databases, remove_state_file: false)
+    databases = Array(databases).flatten
+    owners = databases.map { |d| 
+      super_conn.rdbms.exist?(d) ? super_conn.rdbms.owner(d) : d
+    }.uniq
+    users = databases.map { |d| super_conn.role.list(database: d) }.flatten.uniq
+
+    databases.each { |d| drop_database(d) }
+    super_conn.role.drop(users)
+    super_conn.role.drop(owners, fail: false)
+    owners.each { |o| drop_owner(o) }
+
+    FileUtils.rm_f Prick.state.state_file if remove_state_file
 
     # TODO Run builder teardown scrips
-#   builder = Prick::Build::Builder.new(conn, "schema")
   end
 end
 

data/lib/prick/subcommand/subcommand.rb

@@ -0,0 +1,12 @@
+module Prick::Subcommand 
+# def self.parse_username_database
+#   case username_database
+#     when nil
+#       [nil, nil]
+#     when username_database =~ /^(.*)@(.*)$/
+#       [$1, $2]
+#   else
+#     [username_database, username_database]
+#   end
+# end
+end

data/lib/prick/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prick
-  VERSION = "0.29.1"
+  VERSION = "0.30.0"
 end

data/lib/prick.rb

@@ -1,4 +1,4 @@
-require_relative 'prick/version.rb'
+require 'prick/version.rb'
 
 require 'pg_conn'
 
@@ -8,7 +8,7 @@ require 'constrain'
 
 module Prick
   class Error < RuntimeError; end
-  class Fail < RuntimeError; end
+  class Failure < RuntimeError; end
 end
 
 require_relative 'prick/constants.rb'
@@ -18,6 +18,7 @@ require_relative 'prick/local/command.rb'
 require_relative 'prick/local/git.rb'
 require_relative 'prick/local/timer.rb'
 require_relative 'prick/local/ansi.rb'
+require_relative 'prick/local/fmt.rb'
 
 require_relative 'prick/environment.rb'
 require_relative 'prick/state.rb'
@@ -25,27 +26,65 @@ require_relative 'prick/prick_version.rb'
 require_relative 'prick/diff.rb'
 
 module Prick
-  module SubCommand
-    extend Timer
-    def self.mesg(*msgs) puts msgs.join(" ") if !$quiet end
-    def self.verb(*msgs) puts msgs.join(" ") if $verbose && !$quiet end
-  end
+  def mesg(*msgs) = Prick.mesg(*msgs)
+  def verb(*msgs) = Prick.verb(*msgs)
+  def self.mesg(*msgs) puts msgs.join(" ") if !$quiet end
+  def self.verb(*msgs) puts msgs.join(" ") if $verbose && !$quiet end
 end
 
-require_relative 'prick/subcommand/prick-init.rb'
-require_relative 'prick/subcommand/prick-setup.rb'
-require_relative 'prick/subcommand/prick-teardown.rb'
+require_relative 'prick/subcommand/subcommand.rb'
+require_relative 'prick/subcommand/prick-build.rb'
 require_relative 'prick/subcommand/prick-clean.rb'
 require_relative 'prick/subcommand/prick-create.rb'
-require_relative 'prick/subcommand/prick-build.rb'
-require_relative 'prick/subcommand/prick-make.rb'
-require_relative 'prick/subcommand/prick-fox.rb'
 require_relative 'prick/subcommand/prick-drop.rb'
-require_relative 'prick/subcommand/prick-release.rb'
+require_relative 'prick/subcommand/prick-set.rb'
+require_relative 'prick/subcommand/prick-list.rb'
+require_relative 'prick/subcommand/prick-fox.rb'
+require_relative 'prick/subcommand/prick-init.rb'
+require_relative 'prick/subcommand/prick-make.rb'
 require_relative 'prick/subcommand/prick-migrate.rb'
+require_relative 'prick/subcommand/prick-release.rb'
+require_relative 'prick/subcommand/prick-setup.rb'
+require_relative 'prick/subcommand/prick-teardown.rb'
 
 module Prick
   @state = nil
-  def self.state() @state end
+  def self.state?() !@state.nil? end
+  def self.state() @state or raise ArgumentError end
   def self.state=(state) @state = state end
+
+  def self.error(*args) raise Prick::Error.new *args end
+  def self.failure(*args) raise Prick::Failure.new *args end
+
+  def self.owner_conn = state.connection
+  def self.super_conn = State.connection
+# def self.conn = owner_conn
+
+  # Return list of prick databases. If a block is given it is called with a
+  # connection to each of the databases
+  def self.databases(&block)
+    databases = super_conn.values %(
+      select datname from pg_database where datistemplate = false order by datname
+    )
+    databases.select! { |database| 
+      PgConn.new(database) { |conn|
+        is_prick_database = conn.exist?(%(
+            select 1 
+            from information_schema.tables 
+            where table_schema = 'prick'
+            and table_name = 'builds' 
+            limit 1
+        ))
+        yield(database, conn) if is_prick_database && block_given?
+        is_prick_database
+      }
+    }
+    databases
+  end
+
+  module SubCommand
+    def self.owner_conn = Prick.owner_conn
+    def self.super_conn = Prick.super_conn
+#   def self.conn = Prick.conn
+  end
 end