azuki 0.0.1

data/lib/azuki/helpers/azuki_postgresql.rb

@@ -0,0 +1,165 @@
+require "azuki/helpers"
+
+module Azuki::Helpers::AzukiPostgresql
+
+  extend self
+  extend Azuki::Helpers
+
+  class Attachment
+    attr_reader :config_var, :resource_name, :url, :addon, :plan
+    def initialize(raw)
+      @raw = raw
+      @config_var    = raw['config_var']
+      @resource_name = raw['resource']['name']
+      @url           = raw['resource']['value']
+      @addon, @plan  = raw['resource']['type'].split(':')
+    end
+
+    def starter_plan?
+      plan =~ /dev|basic/
+    end
+
+    def display_name
+      config_var + (primary_attachment? ? " (DATABASE_URL)"  : '')
+    end
+
+    def primary_attachment!
+      @primary_attachment = true
+    end
+
+    def primary_attachment?
+      @primary_attachment
+    end
+  end
+
+  def hpg_addon_name
+    if ENV['SHOGUN']
+      "shogun-#{ENV['SHOGUN']}"
+    else
+      ENV['AZUKI_POSTGRESQL_ADDON_NAME'] || 'azuki-postgresql'
+    end
+  end
+
+  def app_config_vars
+    @app_config_vars ||= api.get_config_vars(app).body
+  end
+
+  def app_attachments
+    @app_attachments ||= api.get_attachments(app).body.map { |raw| Attachment.new(raw) }
+  end
+
+  def hpg_databases
+    return @hpg_databases if @hpg_databases
+    pairs = app_attachments.select {|att|
+        att.addon == hpg_addon_name
+      }.map { |att|
+        [att.config_var, att]
+      }
+    @hpg_databases = Hash[ pairs ]
+
+    if find_database_url_real_attachment
+      @hpg_databases['DATABASE_URL'] = find_database_url_real_attachment
+    end
+
+    if app_config_vars['SHARED_DATABASE_URL']
+      @hpg_databases['SHARED_DATABASE'] = Attachment.new({
+        'config_var' => 'SHARED_DATABASE',
+        'resource' => {
+            'name'  => 'SHARED_DATABASE',
+            'value' => app_config_vars['SHARED_DATABASE_URL'],
+            'type'  => 'shared:database'
+          }
+        })
+    end
+
+    return @hpg_databases
+  end
+
+  def resource_url(resource)
+    api.get_resource(resource).body['value']
+  end
+
+  def forget_config!
+    @hpg_databases   = nil
+    @app_config_vars = nil
+    @app_attachments = nil
+  end
+
+  def find_database_url_real_attachment
+    raw_primary_db_url = app_config_vars['DATABASE_URL']
+    return unless raw_primary_db_url
+
+    primary_db_url = raw_primary_db_url.split("?").first
+    return unless primary_db_url && !primary_db_url.empty?
+
+    real_config = app_config_vars.detect {|k,v| k != 'DATABASE_URL' && v == primary_db_url }
+    if real_config
+      real = hpg_databases[real_config.first]
+      real.primary_attachment! if real
+      return real
+    else
+      return nil
+    end
+  end
+
+  def match_attachments_by_name(name)
+     return [] if name.empty?
+     return [name] if hpg_databases[name]
+     hpg_databases.keys.grep(%r{#{ name }}i)
+  end
+
+  def hpg_resolve(name, default=nil)
+    name = '' if name.nil?
+    name = 'DATABASE_URL' if name == 'DATABASE'
+
+    if hpg_databases.empty?
+      error("Your app has no databases.")
+    end
+
+    found_attachment = nil
+    candidates = match_attachments_by_name(name)
+    if default && name.empty? && app_config_vars[default]
+      found_attachment = hpg_databases[default]
+    elsif candidates.size == 1
+      found_attachment = hpg_databases[candidates.first]
+    end
+
+    if found_attachment.nil?
+      error("Unknown database#{': ' + name unless name.empty?}. Valid options are: #{hpg_databases.keys.sort.join(", ")}")
+    end
+
+    return found_attachment
+  end
+
+  def hpg_translate_fork_and_follow(addon, config)
+    if addon =~ /^#{hpg_addon_name}/
+      %w[fork follow].each do |opt|
+        if val = config[opt]
+          unless val.is_a?(String)
+            error("--#{opt} requires a database argument.")
+          end
+
+          uri = URI.parse(val) rescue nil
+          if uri && uri.scheme
+            argument_url = uri.to_s
+          else
+            attachment = hpg_resolve(val)
+            if attachment.starter_plan?
+              error("#{opt.tr 'f', 'F'} is only available on production databases.")
+            end
+            argument_url = attachment.url
+          end
+
+          config[opt] = argument_url
+        end
+      end
+    end
+  end
+
+  private
+
+  def hpg_promote(url)
+    api.put_config_vars(app, "DATABASE_URL" => url)
+  end
+
+end

data/lib/azuki/helpers/log_displayer.rb

@@ -0,0 +1,70 @@
+require "azuki/helpers"
+
+module Azuki::Helpers
+  class LogDisplayer
+
+    include Azuki::Helpers
+
+    attr_reader :azuki, :app, :opts
+
+    def initialize(azuki, app, opts)
+      @azuki, @app, @opts = azuki, app, opts
+    end
+
+    def display_logs
+      @assigned_colors = {}
+      @line_start = true
+      @token = nil
+
+      azuki.read_logs(app, opts) do |chunk|
+        unless chunk.empty?
+          if STDOUT.isatty && ENV.has_key?("TERM")
+            display(colorize(chunk))
+          else
+            display(chunk)
+          end
+        end
+      end
+    rescue Errno::EPIPE
+    rescue Interrupt => interrupt
+      if STDOUT.isatty && ENV.has_key?("TERM")
+        display("\e[0m")
+      end
+      raise(interrupt)
+    end
+
+    COLORS = %w( cyan yellow green magenta red )
+    COLOR_CODES = {
+      "red"     => 31,
+      "green"   => 32,
+      "yellow"  => 33,
+      "magenta" => 35,
+      "cyan"    => 36,
+    }
+
+    def colorize(chunk)
+      lines = []
+      chunk.split("\n").map do |line|
+        if parsed_line = parse_log(line)
+          header, identifier, body = parsed_line
+          @assigned_colors[identifier] ||= COLORS[@assigned_colors.size % COLORS.size]
+          lines << [
+            "\e[#{COLOR_CODES[@assigned_colors[identifier]]}m",
+            header,
+            "\e[0m",
+            body,
+          ].join("")
+        elsif not line.empty?
+          lines << line
+        end
+      end
+      lines.join("\n")
+    end
+
+    def parse_log(log)
+      return unless parsed = log.match(/^(.*?\[(\w+)([\d\.]+)?\]:)(.*)?$/)
+      [1, 2, 4].map { |i| parsed[i] }
+    end
+
+  end
+end

data/lib/azuki/plugin.rb

@@ -0,0 +1,163 @@
+# based on the Rails Plugin
+
+module Azuki
+  class Plugin
+    include Azuki::Helpers
+    extend Azuki::Helpers
+
+    class ErrorUpdatingSymlinkPlugin < StandardError; end
+
+    DEPRECATED_PLUGINS = %w(
+      azuki-cedar
+      azuki-certs
+      azuki-credentials
+      azuki-kill
+      azuki-labs
+      azuki-logging
+      azuki-netrc
+      azuki-pgdumps
+      azuki-postgresql
+      azuki-releases
+      azuki-shared-postgresql
+      azuki-sql-console
+      azuki-status
+      azuki-stop
+      azuki-suggest
+      pgbackups-automate
+      pgcmd
+      azuki-fork
+    )
+
+    attr_reader :name, :uri
+
+    def self.directory
+      File.expand_path("#{home_directory}/.azuki/plugins")
+    end
+
+    def self.list
+      Dir["#{directory}/*"].sort.map do |folder|
+        File.basename(folder)
+      end
+    end
+
+    def self.load!
+      list.each do |plugin|
+        check_for_deprecation(plugin)
+        next if skip_plugins.include?(plugin)
+        load_plugin(plugin)
+      end
+      # check to see if we are using ddollar/azuki-accounts
+      if list.include?('azuki-accounts') && Azuki::Auth.methods.include?(:fetch_from_account)
+        # setup netrc to match the default, if one exists
+        if default_account = %x{ git config azuki.account }.chomp
+          account = Azuki::Auth.extract_account rescue nil
+          if account && Azuki::Auth.read_credentials != [Azuki::Auth.user, Azuki::Auth.password]
+            Azuki::Auth.credentials = [Azuki::Auth.user, Azuki::Auth.password]
+            Azuki::Auth.write_credentials
+            load("#{File.dirname(__FILE__)}/command/accounts.rb")
+            # kill memoization in case '--account' was passed
+            Azuki::Auth.instance_variable_set(:@account, nil)
+          end
+        end
+      end
+    end
+
+    def self.load_plugin(plugin)
+      begin
+        folder = "#{self.directory}/#{plugin}"
+        $: << "#{folder}/lib"    if File.directory? "#{folder}/lib"
+        load "#{folder}/init.rb" if File.exists?  "#{folder}/init.rb"
+      rescue ScriptError, StandardError => error
+        styled_error(error, "Unable to load plugin #{plugin}.")
+        false
+      end
+    end
+
+    def self.remove_plugin(plugin)
+      FileUtils.rm_rf("#{self.directory}/#{plugin}")
+    end
+
+    def self.check_for_deprecation(plugin)
+      return unless STDIN.isatty
+
+      if DEPRECATED_PLUGINS.include?(plugin)
+        if confirm "The plugin #{plugin} has been deprecated. Would you like to remove it? (y/N)"
+          remove_plugin(plugin)
+        end
+      end
+    end
+
+    def self.skip_plugins
+      @skip_plugins ||= ENV["SKIP_PLUGINS"].to_s.split(/[ ,]/)
+    end
+
+    def initialize(uri)
+      @uri = uri
+      guess_name(uri)
+    end
+
+    def to_s
+      name
+    end
+
+    def path
+      "#{self.class.directory}/#{name}"
+    end
+
+    def install
+      if File.directory?(path)
+        uninstall
+      end
+      FileUtils.mkdir_p(self.class.directory)
+      Dir.chdir(self.class.directory) do
+        git("clone #{uri}")
+        unless $?.success?
+          FileUtils.rm_rf path
+          return false
+        end
+      end
+      true
+    end
+
+    def uninstall
+      ensure_plugin_exists
+      FileUtils.rm_r(path)
+    end
+
+    def update
+      ensure_plugin_exists
+      if File.symlink?(path)
+        raise Azuki::Plugin::ErrorUpdatingSymlinkPlugin
+      else
+        Dir.chdir(path) do
+          unless git('config --get branch.master.remote').empty?
+            message = git("pull")
+            unless $?.success?
+              error("Unable to update #{name}.\n" + message)
+            end
+          else
+            error(<<-ERROR)
+#{name} is a legacy plugin installation.
+Enable updating by reinstalling with `azuki plugins:install`.
+ERROR
+          end
+        end
+      end
+    end
+
+    private
+
+    def ensure_plugin_exists
+      unless File.directory?(path)
+        error("#{name} plugin not found.")
+      end
+    end
+
+    def guess_name(url)
+      @name = File.basename(url)
+      @name = File.basename(File.dirname(url)) if @name.empty?
+      @name.gsub!(/\.git$/, '') if @name =~ /\.git$/
+    end
+
+  end
+end

data/lib/azuki/updater.rb

@@ -0,0 +1,171 @@
+require "digest"
+require "fileutils"
+require "azuki/helpers"
+
+module Azuki
+  module Updater
+
+    def self.error(message)
+      raise Azuki::Command::CommandFailed.new(message)
+    end
+
+    def self.updating_lock_path
+      File.join(Azuki::Helpers.home_directory, ".azuki", "updating")
+    end
+
+    def self.installed_client_path
+      File.expand_path("../../..", __FILE__)
+    end
+
+    def self.updated_client_path
+      File.join(Azuki::Helpers.home_directory, ".azuki", "client")
+    end
+
+    def self.latest_local_version
+      installed_version = client_version_from_path(installed_client_path)
+      updated_version = client_version_from_path(updated_client_path)
+      if compare_versions(updated_version, installed_version) > 0
+        updated_version
+      else
+        installed_version
+      end
+    end
+
+    def self.client_version_from_path(path)
+      version_file = File.join(path, "lib/azuki/version.rb")
+      if File.exists?(version_file)
+        File.read(version_file).match(/VERSION = "([^"]+)"/)[1]
+      else
+        '0.0.0'
+      end
+    end
+
+    def self.disable(message=nil)
+      @disable = message if message
+      @disable
+    end
+
+    def self.check_disabled!
+      if disable
+        Azuki::Helpers.error(disable)
+      end
+    end
+
+    def self.wait_for_lock(path, wait_for=5, check_every=0.5)
+      start = Time.now.to_i
+      while File.exists?(path)
+        sleep check_every
+        if (Time.now.to_i - start) > wait_for
+          Azuki::Helpers.error "Unable to acquire update lock"
+        end
+      end
+      begin
+        FileUtils.touch path
+        ret = yield
+      ensure
+        FileUtils.rm_f path
+      end
+      ret
+    end
+
+    def self.autoupdate?
+      true
+    end
+
+    def self.update(url, autoupdate=false)
+      wait_for_lock(updating_lock_path, 5) do
+        require "excon"
+        require "azuki"
+        require "azuki/excon"
+        require "tmpdir"
+        require "zip/zip"
+
+        latest_version = Excon.get_with_redirect("http://assets.azukiapp.com/azuki-client/VERSION", :nonblock => false).body.chomp
+
+        if compare_versions(latest_version, latest_local_version) > 0
+          Dir.mktmpdir do |download_dir|
+            File.open("#{download_dir}/azuki.zip", "wb") do |file|
+              file.print Excon.get_with_redirect(url, :nonblock => false).body
+            end
+
+            hash = Digest::SHA256.file("#{download_dir}/azuki.zip").hexdigest
+            official_hash = Excon.get_with_redirect("https://toolbelt.azukiapp.com/update/hash", :nonblock => false).body.chomp
+
+            error "Update hash signature mismatch" unless hash == official_hash
+
+            Zip::ZipFile.open("#{download_dir}/azuki.zip") do |zip|
+              zip.each do |entry|
+                target = File.join(download_dir, entry.to_s)
+                FileUtils.mkdir_p File.dirname(target)
+                zip.extract(entry, target) { true }
+              end
+            end
+
+            FileUtils.rm "#{download_dir}/azuki.zip"
+
+            old_version = latest_local_version
+            new_version = client_version_from_path(download_dir)
+
+            if compare_versions(new_version, old_version) < 0 && !autoupdate
+              Azuki::Helpers.error("Installed version (#{old_version}) is newer than the latest available update (#{new_version})")
+            end
+
+            FileUtils.rm_rf updated_client_path
+            FileUtils.mkdir_p File.dirname(updated_client_path)
+            FileUtils.cp_r  download_dir, updated_client_path
+
+            new_version
+          end
+        else
+          false # already up to date
+        end
+      end
+    ensure
+      FileUtils.rm_f(updating_lock_path)
+    end
+
+    def self.compare_versions(first_version, second_version)
+      first_version.split('.').map {|part| Integer(part) rescue part} <=> second_version.split('.').map {|part| Integer(part) rescue part}
+    end
+
+    def self.inject_libpath
+      old_version = client_version_from_path(installed_client_path)
+      new_version = client_version_from_path(updated_client_path)
+
+      if compare_versions(new_version, old_version) > 0
+        $:.unshift File.join(updated_client_path, "lib")
+        vendored_gems = Dir[File.join(updated_client_path, "vendor", "gems", "*")]
+        vendored_gems.each do |vendored_gem|
+          $:.unshift File.join(vendored_gem, "lib")
+        end
+        load('azuki/updater.rb') # reload updated updater
+      end
+
+      background_update!
+    end
+
+    def self.last_autoupdate_path
+      File.join(Azuki::Helpers.home_directory, ".azuki", "autoupdate.last")
+    end
+
+    def self.background_update!
+      # if we've updated in the last 300 seconds, dont try again
+      if File.exists?(last_autoupdate_path)
+        return if (Time.now.to_i - File.mtime(last_autoupdate_path).to_i) < 300
+      end
+      log_path = File.join(Azuki::Helpers.home_directory, '.azuki', 'autoupdate.log')
+      FileUtils.mkdir_p File.dirname(log_path)
+      azuki_binary = File.expand_path($0)
+      pid = if defined?(RUBY_VERSION) and RUBY_VERSION =~ /^1\.8\.\d+/
+        fork do
+          exec("\"#{azuki_binary}\" update &> #{log_path} 2>&1")
+        end
+      else
+        spawn("\"#{azuki_binary}\" update", {:err => log_path, :out => log_path})
+      end
+      Process.detach(pid)
+      FileUtils.mkdir_p File.dirname(last_autoupdate_path)
+      FileUtils.touch last_autoupdate_path
+    end
+  end
+end