azuki 0.0.1

data/lib/azuki/client/azuki_postgresql.rb

@@ -0,0 +1,141 @@
+require "azuki/client"
+
+class Azuki::Client::AzukiPostgresql
+  Version = 11
+
+  include Azuki::Helpers
+
+  @headers = { :x_azuki_gem_version  => Azuki::Client.version }
+
+  def self.add_headers(headers)
+    @headers.merge! headers
+  end
+
+  def self.headers
+    @headers
+  end
+
+  attr_reader :attachment
+  def initialize(attachment)
+    @attachment = attachment
+    if attachment.resource_name == 'SHARED_DATABASE'
+      error('This command is not available for shared database')
+    end
+    require 'rest_client'
+  end
+
+  def azuki_postgresql_host
+    if attachment.starter_plan?
+      ENV["AZUKI_POSTGRESQL_HOST"] || "postgres-starter-api"
+    else
+      if ENV['SHOGUN']
+        "shogun-#{ENV['SHOGUN']}"
+      else
+        ENV["AZUKI_POSTGRESQL_HOST"] || "postgres-api"
+      end
+    end
+  end
+
+  def resource_name
+    attachment.resource_name
+  end
+
+  def azuki_postgresql_resource
+    RestClient::Resource.new(
+      "https://#{azuki_postgresql_host}.azukiapp.com/client/v11/databases",
+      :user => Azuki::Auth.user,
+      :password => Azuki::Auth.password,
+      :headers => self.class.headers
+      )
+  end
+
+  def ingress
+    http_put "#{resource_name}/ingress"
+  end
+
+  def reset
+    http_put "#{resource_name}/reset"
+  end
+
+  def rotate_credentials
+    http_post "#{resource_name}/credentials_rotation"
+  end
+
+  def get_database(extended=false)
+    query = extended ? '?extended=true' : ''
+    http_get resource_name + query
+  end
+
+  def get_wait_status
+    http_get "#{resource_name}/wait_status"
+  end
+
+  def unfollow
+    http_put "#{resource_name}/unfollow"
+  end
+
+  protected
+
+  def sym_keys(c)
+    if c.is_a?(Array)
+      c.map { |e| sym_keys(e) }
+    else
+      c.inject({}) do |h, (k, v)|
+        h[k.to_sym] = v; h
+      end
+    end
+  end
+
+  def checking_client_version
+    begin
+      yield
+    rescue RestClient::BadRequest => e
+      if message = json_decode(e.response.to_s)["upgrade_message"]
+        abort(message)
+      else
+        raise e
+      end
+    end
+  end
+
+  def display_azuki_warning(response)
+    warning = response.headers[:x_azuki_warning]
+    display warning if warning
+    response
+  end
+
+  def http_get(path)
+    checking_client_version do
+      retry_on_exception(RestClient::Exception) do
+        response = azuki_postgresql_resource[path].get
+        display_azuki_warning response
+        sym_keys(json_decode(response.to_s))
+      end
+    end
+  end
+
+  def http_post(path, payload = {})
+    checking_client_version do
+      response = azuki_postgresql_resource[path].post(json_encode(payload))
+      display_azuki_warning response
+      sym_keys(json_decode(response.to_s))
+    end
+  end
+
+  def http_put(path, payload = {})
+    checking_client_version do
+      response = azuki_postgresql_resource[path].put(json_encode(payload))
+      display_azuki_warning response
+      sym_keys(json_decode(response.to_s))
+    end
+  end
+end
+
+module AzukiPostgresql
+  class Client < Azuki::Client::AzukiPostgresql
+    def initialize(*args)
+      Azuki::Helpers.deprecate "AzukiPostgresql::Client has been deprecated. Please use Azuki::Client::AzukiPostgresql instead."
+      super
+    end
+  end
+end

data/lib/azuki/client/cisaurus.rb

@@ -0,0 +1,26 @@
+require "azuki/client"
+
+class Azuki::Client::Cisaurus
+
+  include Azuki::Helpers
+
+  def initialize(uri)
+    require 'rest_client'
+    @uri = URI.parse(uri)
+  end
+
+  def authenticated_resource(path)
+    host = "#{@uri.scheme}://#{@uri.host}"
+    host += ":#{@uri.port}" if @uri.port
+    RestClient::Resource.new("#{host}#{path}", "", Azuki::Auth.api_key)
+  end
+
+  def copy_slug(from, to)
+    authenticated_resource("/v1/apps/#{from}/copy/#{to}").post(json_encode("description" => "Forked from #{from}"), :content_type => :json).headers[:location]
+  end
+
+  def job_done?(job_location)
+    done = authenticated_resource(job_location).get.code
+    done == 202
+  end
+end

data/lib/azuki/client/pgbackups.rb

@@ -0,0 +1,113 @@
+require "azuki/client"
+
+class Azuki::Client::Pgbackups
+
+  include Azuki::Helpers
+
+  def initialize(uri)
+    require 'rest_client'
+    @uri = URI.parse(uri)
+  end
+
+  def authenticated_resource(path)
+    host = "#{@uri.scheme}://#{@uri.host}"
+    host += ":#{@uri.port}" if @uri.port
+    RestClient::Resource.new("#{host}#{path}",
+      :user     => @uri.user,
+      :password => @uri.password,
+      :headers  => {:x_azuki_gem_version => Azuki::Client.version}
+    )
+  end
+
+  def create_transfer(from_url, from_name, to_url, to_name, opts={})
+    # opts[:expire] => true will delete the oldest backup if at the plan limit
+    resource = authenticated_resource("/client/transfers")
+    params = {:from_url => from_url, :from_name => from_name, :to_url => to_url, :to_name => to_name}.merge opts
+    json_decode post(resource, params).body
+  end
+
+  def get_transfers
+    resource = authenticated_resource("/client/transfers")
+    json_decode get(resource).body
+  end
+
+  def get_transfer(id)
+    resource = authenticated_resource("/client/transfers/#{id}")
+    json_decode get(resource).body
+  end
+
+  def get_backups(opts={})
+    resource = authenticated_resource("/client/backups")
+    json_decode get(resource).body
+  end
+
+  def get_backup(name, opts={})
+    name = URI.escape(name)
+    resource = authenticated_resource("/client/backups/#{name}")
+    json_decode get(resource).body
+  end
+
+  def get_latest_backup
+    resource = authenticated_resource("/client/latest_backup")
+    json_decode get(resource).body
+  end
+
+  def delete_backup(name)
+    name = URI.escape(name)
+    begin
+      resource = authenticated_resource("/client/backups/#{name}")
+      delete(resource).body
+      true
+    rescue RestClient::ResourceNotFound => e
+      false
+    end
+  end
+
+  private
+
+  def get(resource)
+    check_errors do
+      response = resource.get
+      display_azuki_warning response
+      response
+    end
+  end
+
+  def post(resource, params)
+    check_errors do
+      response = resource.post(params)
+      display_azuki_warning response
+      response
+    end
+  end
+
+  def delete(resource)
+    check_errors do
+      response = resource.delete
+      display_azuki_warning response
+      response
+    end
+  end
+
+  def check_errors
+    yield
+  rescue RestClient::Unauthorized
+    error "Invalid PGBACKUPS_URL"
+  end
+
+  def display_azuki_warning(response)
+    warning = response.headers[:x_azuki_warning]
+    display warning if warning
+    response
+  end
+
+end
+
+module Pgbackups
+  class Client < Azuki::Client::Pgbackups
+    def initialize(*args)
+      Azuki::Helpers.deprecate "Pgbackups::Client has been deprecated. Please use Azuki::Client::Pgbackups instead."
+      super
+    end
+  end
+end

data/lib/azuki/client/rendezvous.rb

@@ -0,0 +1,108 @@
+require "timeout"
+require "socket"
+require "uri"
+require "azuki/auth"
+require "azuki/client"
+require "azuki/helpers"
+
+class Azuki::Client::Rendezvous
+
+  include Azuki::Helpers
+
+  attr_reader :rendezvous_url, :connect_timeout, :activity_timeout, :input, :output, :on_connect
+
+  def initialize(opts)
+    @rendezvous_url = opts[:rendezvous_url]
+    @connect_timeout = opts[:connect_timeout]
+    @activity_timeout = opts[:activity_timeout]
+    @input = opts[:input]
+    @output = opts[:output]
+  end
+
+  def on_connect(&blk)
+    @on_connect = blk if block_given?
+    @on_connect
+  end
+
+  def start
+    uri = URI.parse(rendezvous_url)
+    host, port, secret = uri.host, uri.port, uri.path[1..-1]
+
+    ssl_socket = Timeout.timeout(connect_timeout) do
+      ssl_context = OpenSSL::SSL::SSLContext.new
+
+      if Azuki::Auth.verify_host?(host)
+        ssl_context.ca_file     = File.expand_path("../../../../data/cacert.pem", __FILE__)
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      tcp_socket = TCPSocket.open(host, port)
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+      ssl_socket.connect
+      ssl_socket.puts(secret)
+      ssl_socket.readline
+      ssl_socket
+    end
+
+    on_connect.call if on_connect
+
+    readables = [input, ssl_socket].compact
+
+    begin
+      loop do
+        if o = IO.select(readables, nil, nil, activity_timeout)
+          if (input && (o.first.first == input))
+            begin
+              data = input.readpartial(10000)
+            rescue EOFError
+              readables.delete(input)
+              next
+            end
+            if running_on_windows?
+              data.gsub!("\r\n", "\n") # prevent double CRs
+            end
+            ssl_socket.write(data)
+            ssl_socket.flush
+          elsif (o.first.first == ssl_socket)
+            begin
+              data = ssl_socket.readpartial(10000)
+            rescue EOFError
+              break
+            end
+            output.write(fixup(data))
+          end
+        else
+          raise(Timeout::Error.new)
+        end
+      end
+    rescue Interrupt
+      ssl_socket.write(3.chr)
+      ssl_socket.flush
+      retry
+    rescue SignalException => e
+      if Signal.list["QUIT"] == e.signo
+        ssl_socket.write(28.chr)
+        ssl_socket.flush
+        retry
+      end
+      raise
+    rescue Errno::EIO
+    end
+  end
+
+  private
+
+  def fixup(data)
+    return nil if ! data
+    if data.respond_to?(:force_encoding)
+      data.force_encoding('utf-8') if data.respond_to?(:force_encoding)
+    end
+    if running_on_windows?
+      begin
+        data.gsub!(/\e\[[\d;]+m/, '')
+      rescue # ignore failed gsub, for instance when non-utf8
+      end
+    end
+    output.isatty ? data : data.gsub(/\cM/,"")
+  end
+end

data/lib/azuki/client/ssl_endpoint.rb

@@ -0,0 +1,25 @@
+class Azuki::Client
+  def ssl_endpoint_add(app, pem, key)
+    json_decode(post("apps/#{app}/ssl-endpoints", :accept => :json, :pem => pem, :key => key).to_s)
+  end
+
+  def ssl_endpoint_info(app, cname)
+    json_decode(get("apps/#{app}/ssl-endpoints/#{escape(cname)}", :accept => :json).to_s)
+  end
+
+  def ssl_endpoint_list(app)
+    json_decode(get("apps/#{app}/ssl-endpoints", :accept => :json).to_s)
+  end
+
+  def ssl_endpoint_remove(app, cname)
+    json_decode(delete("apps/#{app}/ssl-endpoints/#{escape(cname)}", :accept => :json).to_s)
+  end
+
+  def ssl_endpoint_rollback(app, cname)
+    json_decode(post("apps/#{app}/ssl-endpoints/#{escape(cname)}/rollback", :accept => :json).to_s)
+  end
+
+  def ssl_endpoint_update(app, cname, pem, key)
+    json_decode(put("apps/#{app}/ssl-endpoints/#{escape(cname)}", :accept => :json, :pem => pem, :key => key).to_s)
+  end
+end

data/lib/azuki/command.rb

@@ -0,0 +1,294 @@
+require 'azuki/helpers'
+require 'azuki/plugin'
+require 'azuki/version'
+require "optparse"
+
+module Azuki
+  module Command
+    class CommandFailed  < RuntimeError; end
+
+    extend Azuki::Helpers
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+      end
+      Azuki::Plugin.load!
+    end
+
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.command_aliases
+      @@command_aliases ||= {}
+    end
+
+    def self.files
+      @@files ||= Hash.new {|hash,key| hash[key] = File.readlines(key).map {|line| line.strip}}
+    end
+
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    def self.register_command(command)
+      commands[command[:command]] = command
+    end
+
+    def self.register_namespace(namespace)
+      namespaces[namespace[:name]] = namespace
+    end
+
+    def self.current_command
+      @current_command
+    end
+
+    def self.current_command=(new_current_command)
+      @current_command = new_current_command
+    end
+
+    def self.current_args
+      @current_args
+    end
+
+    def self.current_options
+      @current_options ||= {}
+    end
+
+    def self.global_options
+      @global_options ||= []
+    end
+
+    def self.invalid_arguments
+      @invalid_arguments
+    end
+
+    def self.shift_argument
+      # dup argument to get a non-frozen string
+      @invalid_arguments.shift.dup rescue nil
+    end
+
+    def self.validate_arguments!
+      unless invalid_arguments.empty?
+        arguments = invalid_arguments.map {|arg| "\"#{arg}\""}
+        if arguments.length == 1
+          message = "Invalid argument: #{arguments.first}"
+        elsif arguments.length > 1
+          message = "Invalid arguments: "
+          message << arguments[0...-1].join(", ")
+          message << " and "
+          message << arguments[-1]
+        end
+        $stderr.puts(format_with_bang(message))
+        run(current_command, ["--help"])
+        exit(1)
+      end
+    end
+
+    def self.warnings
+      @warnings ||= []
+    end
+
+    def self.display_warnings
+      unless warnings.empty?
+        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
+      end
+    end
+
+    def self.global_option(name, *args, &blk)
+      # args.sort.reverse gives -l, --long order
+      global_options << { :name => name.to_s, :args => args.sort.reverse, :proc => blk }
+    end
+
+    global_option :app, "-a", "--app APP" do |app|
+      raise OptionParser::InvalidOption.new(app) if app == "pp"
+    end
+
+    global_option :confirm, "--confirm APP"
+    global_option :help,    "-h", "--help"
+    global_option :remote,  "-r", "--remote REMOTE"
+
+    def self.prepare_run(cmd, args=[])
+      command = parse(cmd)
+
+      if args.include?('-h') || args.include?('--help')
+        args.unshift(cmd) unless cmd =~ /^-.*/
+        cmd = 'help'
+        command = parse(cmd)
+      end
+
+      if cmd == '--version'
+        cmd = 'version'
+        command = parse(cmd)
+      end
+
+      @current_command = cmd
+      @anonymized_args, @normalized_args = [], []
+
+      opts = {}
+      invalid_options = []
+
+      parser = OptionParser.new do |parser|
+        # remove OptionParsers Officious['version'] to avoid conflicts
+        # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
+        parser.base.long.delete('version')
+        (global_options + (command && command[:options] || [])).each do |option|
+          parser.on(*option[:args]) do |value|
+            if option[:proc]
+              option[:proc].call(value)
+            end
+            opts[option[:name].gsub('-', '_').to_sym] = value
+            ARGV.join(' ') =~ /(#{option[:args].map {|arg| arg.split(' ', 2).first}.join('|')})/
+            @anonymized_args << "#{$1} _"
+            @normalized_args << "#{option[:args].last.split(' ', 2).first} _"
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+          @anonymized_args << '!'
+          @normalized_args << '!'
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        @anonymized_args << '!'
+        @normalized_args << '!'
+        retry
+      end
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+      @invalid_arguments = invalid_options
+
+      @anonymous_command = [ARGV.first, *@anonymized_args].join(' ')
+      begin
+        usage_directory = "#{home_directory}/.azuki/usage"
+        FileUtils.mkdir_p(usage_directory)
+        usage_file = usage_directory << "/#{Azuki::VERSION}"
+        usage = if File.exists?(usage_file)
+          json_decode(File.read(usage_file))
+        else
+          {}
+        end
+        usage[@anonymous_command] ||= 0
+        usage[@anonymous_command] += 1
+        File.write(usage_file, json_encode(usage) + "\n")
+      rescue
+        # usage writing is not important, allow failures
+      end
+
+      if command
+        command_instance = command[:klass].new(args.dup, opts.dup)
+
+        if !@normalized_args.include?('--app _') && (implied_app = command_instance.app rescue nil)
+          @normalized_args << '--app _'
+        end
+        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
+
+        [ command_instance, command[:method] ]
+      else
+        error([
+          "`#{cmd}` is not a azuki command.",
+          suggestion(cmd, commands.keys + command_aliases.keys),
+          "See `azuki help` for a list of available commands."
+        ].compact.join("\n"))
+      end
+    end
+
+    def self.run(cmd, arguments=[])
+      begin
+        object, method = prepare_run(cmd, arguments.dup)
+        object.send(method)
+      rescue Interrupt, StandardError, SystemExit => error
+        # load likely error classes, as they may not be loaded yet due to defered loads
+        require 'azuki-api'
+        require 'rest_client'
+        raise(error)
+      end
+    rescue Azuki::API::Errors::Unauthorized, RestClient::Unauthorized
+      puts "Authentication failure"
+      unless ENV['AZUKI_API_KEY']
+        run "login"
+        retry
+      end
+    rescue Azuki::API::Errors::VerificationRequired, RestClient::PaymentRequired => e
+      retry if Azuki::Helpers.confirm_billing
+    rescue Azuki::API::Errors::NotFound => e
+      error extract_error(e.response.body) {
+        e.response.body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue RestClient::ResourceNotFound => e
+      error extract_error(e.http_body) {
+        e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue Azuki::API::Errors::Locked => e
+      app = e.response.headers[:x_confirmation_required]
+      if confirm_command(app, extract_error(e.response.body))
+        arguments << '--confirm' << app
+        retry
+      end
+    rescue RestClient::Locked => e
+      app = e.response.headers[:x_confirmation_required]
+      if confirm_command(app, extract_error(e.http_body))
+        arguments << '--confirm' << app
+        retry
+      end
+    rescue Azuki::API::Errors::Timeout, RestClient::RequestTimeout
+      error "API request timed out. Please try again, or contact support@azukiapp.com if this issue persists."
+    rescue Azuki::API::Errors::ErrorWithResponse => e
+      error extract_error(e.response.body)
+    rescue RestClient::RequestFailed => e
+      error extract_error(e.http_body)
+    rescue CommandFailed => e
+      error e.message
+    rescue OptionParser::ParseError
+      commands[cmd] ? run("help", [cmd]) : run("help")
+    rescue Excon::Errors::SocketError => e
+      if e.message == 'getaddrinfo: nodename nor servname provided, or not known (SocketError)'
+        error("Unable to connect to Azuki API, please check internet connectivity and try again.")
+      else
+        raise(e)
+      end
+    ensure
+      display_warnings
+    end
+
+    def self.parse(cmd)
+      commands[cmd] || commands[command_aliases[cmd]]
+    end
+
+    def self.extract_error(body, options={})
+      default_error = block_given? ? yield : "Internal server error.\nRun `azuki status` to check for known platform issues."
+      parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || default_error
+    end
+
+    def self.parse_error_xml(body)
+      xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+      msg = xml_errors.map { |a| a.text }.join(" / ")
+      return msg unless msg.empty?
+    rescue Exception
+    end
+
+    def self.parse_error_json(body)
+      json = json_decode(body.to_s) rescue false
+      case json
+      when Array
+        json.first.join(' ') # message like [['base', 'message']]
+      when Hash
+        json['error']   # message like {'error' => 'message'}
+      else
+        nil
+      end
+    end
+
+    def self.parse_error_plain(body)
+      return unless body.respond_to?(:headers) && body.headers[:content_type].to_s.include?("text/plain")
+      body.to_s
+    end
+  end
+end