azuki 0.0.1

data/lib/azuki/command/config.rb

@@ -0,0 +1,137 @@
+require "azuki/command/base"
+
+# manage app config vars
+#
+class Azuki::Command::Config < Azuki::Command::Base
+
+  # config
+  #
+  # display the config vars for an app
+  #
+  # -s, --shell  # output config vars in shell format
+  #
+  #Examples:
+  #
+  # $ azuki config
+  # A: one
+  # B: two
+  #
+  # $ azuki config --shell
+  # A=one
+  # B=two
+  #
+  def index
+    validate_arguments!
+
+    vars = api.get_config_vars(app).body
+    if vars.empty?
+      display("#{app} has no config vars.")
+    else
+      vars.each {|key, value| vars[key] = value.to_s}
+      if options[:shell]
+        vars.keys.sort.each do |key|
+          display(%{#{key}=#{vars[key]}})
+        end
+      else
+        styled_header("#{app} Config Vars")
+        styled_hash(vars)
+      end
+    end
+  end
+
+  # config:set KEY1=VALUE1 [KEY2=VALUE2 ...]
+  #
+  # set one or more config vars
+  #
+  #Example:
+  #
+  # $ azuki config:set A=one
+  # Setting config vars and restarting example... done, v123
+  # A: one
+  #
+  # $ azuki config:set A=one B=two
+  # Setting config vars and restarting example... done, v123
+  # A: one
+  # B: two
+  #
+  def set
+    unless args.size > 0 and args.all? { |a| a.include?('=') }
+      error("Usage: azuki config:set KEY1=VALUE1 [KEY2=VALUE2 ...]\nMust specify KEY and VALUE to set.")
+    end
+
+    vars = args.inject({}) do |vars, arg|
+      key, value = arg.split('=', 2)
+      vars[key] = value
+      vars
+    end
+
+    action("Setting config vars and restarting #{app}") do
+      api.put_config_vars(app, vars)
+
+      @status = begin
+        if release = api.get_release(app, 'current').body
+          release['name']
+        end
+      rescue Azuki::API::Errors::RequestFailed => e
+      end
+    end
+
+    vars.each {|key, value| vars[key] = value.to_s}
+    styled_hash(vars)
+  end
+
+  alias_command "config:add", "config:set"
+
+  # config:get KEY
+  #
+  # display a config value for an app
+  #
+  #Examples:
+  #
+  # $ azuki config:get A
+  # one
+  #
+  def get
+    unless key = shift_argument
+      error("Usage: azuki config:get KEY\nMust specify KEY.")
+    end
+    validate_arguments!
+
+    vars = api.get_config_vars(app).body
+    key, value = vars.detect {|k,v| k == key}
+    display(value.to_s)
+  end
+
+  # config:unset KEY1 [KEY2 ...]
+  #
+  # unset one or more config vars
+  #
+  # $ azuki config:unset A
+  # Unsetting A and restarting example... done, v123
+  #
+  # $ azuki config:unset A B
+  # Unsetting A and restarting example... done, v123
+  # Unsetting B and restarting example... done, v124
+  #
+  def unset
+    if args.empty?
+      error("Usage: azuki config:unset KEY1 [KEY2 ...]\nMust specify KEY to unset.")
+    end
+
+    args.each do |key|
+      action("Unsetting #{key} and restarting #{app}") do
+        api.delete_config_var(app, key)
+
+        @status = begin
+          if release = api.get_release(app, 'current').body
+            release['name']
+          end
+        rescue Azuki::API::Errors::RequestFailed => e
+        end
+      end
+    end
+  end
+
+  alias_command "config:remove", "config:unset"
+
+end

data/lib/azuki/command/db.rb

@@ -0,0 +1,218 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # manage the database for an app
+  #
+  class Db < Base
+
+    # db:push [DATABASE_URL]
+    #
+    # push local data up to your app
+    #
+    # DATABASE_URL should reference your local database. if not specified, it
+    # will be guessed from config/database.yml
+    #
+    # -c, --chunksize SIZE # specify the number of rows to send in each batch
+    # -d, --debug          # enable debugging output
+    # -e, --exclude TABLES # exclude the specified tables from the push
+    # -f, --filter REGEX   # only push certain tables
+    # -r, --resume FILE    # resume transfer described by a .dat file
+    # -t, --tables TABLES  # only push the specified tables
+    #
+    def push
+      load_taps
+      opts = parse_taps_opts
+
+      display("Warning: Data in the app '#{app}' will be overwritten and will not be recoverable.")
+
+      if confirm_command
+        taps_client(:push, opts)
+      end
+    end
+
+    # db:pull [DATABASE_URL]
+    #
+    # pull azuki data down into your local database
+    #
+    # DATABASE_URL should reference your local database. if not specified, it
+    # will be guessed from config/database.yml
+    #
+    # -c, --chunksize SIZE # specify the number of rows to send in each batch
+    # -d, --debug          # enable debugging output
+    # -e, --exclude TABLES # exclude the specified tables from the pull
+    # -f, --filter REGEX   # only pull certain tables
+    # -r, --resume FILE    # resume transfer described by a .dat file
+    # -t, --tables TABLES  # only pull the specified tables
+    #
+    def pull
+      load_taps
+      opts = parse_taps_opts
+
+      display("Warning: Data in the database '#{opts[:database_url]}' will be overwritten and will not be recoverable.")
+
+      if confirm_command
+        taps_client(:pull, opts)
+      end
+    end
+
+    protected
+
+    def parse_database_yml
+      return "" unless File.exists?(Dir.pwd + '/config/database.yml')
+      require 'erb'
+      require 'yaml'
+
+      environment = ENV['RAILS_ENV'] || ENV['MERB_ENV'] || ENV['RACK_ENV']
+      environment = 'development' if environment.nil? or environment.empty?
+
+      conf = YAML.load(ERB.new(File.read(Dir.pwd + '/config/database.yml')).result)[environment]
+      case conf['adapter']
+        when 'sqlite3'
+          return "sqlite://#{conf['database']}"
+        when 'postgresql'
+          uri_hash = conf_to_uri_hash(conf)
+          uri_hash['scheme'] = 'postgres'
+          return uri_hash_to_url(uri_hash)
+        else
+          return uri_hash_to_url(conf_to_uri_hash(conf))
+      end
+    rescue Exception => ex
+      puts "Error parsing database.yml: #{ex.message}"
+      puts ex.backtrace
+      ""
+    end
+
+    def conf_to_uri_hash(conf)
+      uri = {}
+      uri['scheme'] = conf['adapter']
+      uri['username'] = conf['user'] || conf['username']
+      uri['password'] = conf['password']
+      uri['host'] = conf['host'] || conf['hostname'] || '127.0.0.1'
+      uri['port'] = conf['port']
+      uri['path'] = conf['database']
+
+      conf['encoding'] = 'utf8' if conf['encoding'] == 'unicode' or conf['encoding'].nil?
+      uri['query'] = "encoding=#{conf['encoding']}"
+
+      uri
+    end
+
+    def userinfo_from_uri(uri)
+      username = uri['username'].to_s
+      password = uri['password'].to_s
+      return nil if username == ''
+
+      userinfo  = ""
+      userinfo << username
+      userinfo << ":" << password if password.length > 0
+      userinfo
+    end
+
+    def uri_hash_to_url(uri)
+      host = uri['host']
+      host ||= '127.0.0.1' unless uri['scheme'] == 'postgres'
+      uri_parts = {
+        :scheme   => uri['scheme'],
+        :userinfo => userinfo_from_uri(uri),
+        :password => uri['password'],
+        :host     => host,
+        :port     => uri['port'],
+        :path     => "/%s" % uri['path'],
+        :query    => uri['query'],
+      }
+
+      URI::Generic.build(uri_parts).to_s
+    end
+
+    def parse_taps_opts
+      opts = {}
+      opts[:default_chunksize] = options[:chunksize] || 1000
+      opts[:default_chunksize] = opts[:default_chunksize].to_i rescue 1000
+
+      if filter = options[:filter]
+        opts[:table_filter] = filter
+      elsif tables = options[:tables]
+        r_tables = tables.split(",").collect { |t| "^#{t.strip}$" }
+        opts[:table_filter] = "(#{r_tables.join("|")})"
+      end
+
+      if options[:'disable-compression']
+        opts[:disable_compression] = true
+      end
+
+      if excluded_tables = options[:exclude]
+        opts[:exclude_tables] = excluded_tables
+      end
+
+      if resume_file = options[:resume]
+        opts[:resume_filename] = resume_file
+      end
+
+      opts[:indexes_first] = !options[:'indexes-last']
+
+      opts[:database_url] = args.detect { |a| URI.parse(a).scheme } rescue nil
+
+      unless opts[:database_url]
+        opts[:database_url] = parse_database_yml
+        display "Auto-detected local database: #{opts[:database_url]}" if opts[:database_url] != ''
+      end
+      raise(CommandFailed, "Invalid database url") if opts[:database_url] == ''
+
+      if options[:debug]
+        require 'logger'
+        Taps.log.level = Logger::DEBUG
+      end
+
+      # setting local timezone equal to Azuki timezone allowing TAPS to
+      # correctly transfer datetime fields between databases
+      ENV['TZ'] = 'America/Los_Angeles'
+      opts
+    end
+
+    def taps_client(op, opts)
+      Taps::Config.verify_database_url(opts[:database_url])
+      if opts[:resume_filename]
+        Taps::Cli.new([]).clientresumexfer(op, opts)
+      else
+        info = azuki.database_session(app)
+
+        replacement_host = case
+          when ENV["TAPS_HOST"] then ENV["TAPS_HOST"]
+          when RUBY_VERSION >= '1.9' then "taps19.azukiapp.com"
+          else nil
+        end
+
+        if replacement_host
+          info["url"].gsub!("taps3.azukiapp.com", replacement_host)
+        end
+
+        opts[:remote_url] = info['url']
+        opts[:session_uri] = info['session']
+        Taps::Cli.new([]).clientxfer(op, opts)
+      end
+    end
+
+    def enforce_taps_version(version)
+      unless Taps.version >= version
+        error "Your taps gem is out of date (v#{version} or higher required)."
+      end
+    end
+
+    def load_taps
+      begin
+        require "rubygems"
+      rescue LoadError
+      end
+      require 'taps/operation'
+      require 'taps/cli'
+      enforce_taps_version "0.3.23"
+      display "Loaded Taps v#{Taps.version}"
+    rescue LoadError
+      message  = "Taps Load Error: #{$!.message}\n"
+      message << "You may need to install or update the taps gem to use db commands.\n"
+      message << "On most systems this will be:\n\nsudo gem install taps"
+      error message
+    end
+  end
+end

data/lib/azuki/command/domains.rb

@@ -0,0 +1,85 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # manage custom domains
+  #
+  class Domains < Base
+
+    # domains
+    #
+    # list custom domains for an app
+    #
+    #Examples:
+    #
+    # $ azuki domains
+    # === Domain names for example
+    # example.com
+    #
+    def index
+      validate_arguments!
+      domains = api.get_domains(app).body
+      if domains.length > 0
+        styled_header("#{app} Domain Names")
+        styled_array domains.map {|domain| domain["domain"]}
+      else
+        display("#{app} has no domain names.")
+      end
+    end
+
+    # domains:add DOMAIN
+    #
+    # add a custom domain to an app
+    #
+    #Examples:
+    #
+    # $ azuki domains:add example.com
+    # Adding example.com to example... done
+    #
+    def add
+      unless domain = shift_argument
+        error("Usage: azuki domains:add DOMAIN\nMust specify DOMAIN to add.")
+      end
+      validate_arguments!
+      action("Adding #{domain} to #{app}") do
+        api.post_domain(app, domain)
+      end
+    end
+
+    # domains:remove DOMAIN
+    #
+    # remove a custom domain from an app
+    #
+    #Examples:
+    #
+    # $ azuki domains:remove example.com
+    # Removing example.com from example... done
+    #
+    def remove
+      unless domain = shift_argument
+        error("Usage: azuki domains:remove DOMAIN\nMust specify DOMAIN to remove.")
+      end
+      validate_arguments!
+      action("Removing #{domain} from #{app}") do
+        api.delete_domain(app, domain)
+      end
+    end
+
+    # domains:clear
+    #
+    # remove all custom domains from an app
+    #
+    #Examples:
+    #
+    # $ azuki domains:clear
+    # Removing all domain names for example... done
+    #
+    def clear
+      validate_arguments!
+      action("Removing all domain names from #{app}") do
+        api.delete_domains(app)
+      end
+    end
+
+  end
+end

data/lib/azuki/command/drains.rb

@@ -0,0 +1,46 @@
+require "azuki/command/base"
+
+module Azuki::Command
+
+  # display syslog drains for an app
+  #
+  class Drains < Base
+
+    # drains
+    #
+    # list all syslog drains
+    #
+    def index
+      puts azuki.list_drains(app)
+      return
+    end
+
+    # drains:add URL
+    #
+    # add a syslog drain
+    #
+    def add
+      if url = args.shift
+        puts azuki.add_drain(app, url)
+        return
+      else
+        error("Usage: azuki drains:add URL")
+      end
+    end
+
+    # drains:remove URL
+    #
+    # remove a syslog drain
+    #
+    def remove
+      if url = args.shift
+        puts azuki.remove_drain(app, url)
+        return
+      else
+        error("Usage: azuki drains remove URL")
+      end
+    end
+
+  end
+end
+