turbot 0.1.36 → 0.2.3

data/lib/turbot/client/cisaurus.rb

@@ -1,25 +0,0 @@
-require "turbot/client"
-
-class Turbot::Client::Cisaurus
-
-  include Turbot::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}", "", Turbot::Auth.api_key)
-  end
-
-  def copy_slug(from, to)
-    authenticated_resource("/v1/bots/#{from}/copy/#{to}").post(json_encode("description" => "Forked from #{from}"), :content_type => :json).headers[:location]
-  end
-
-  def job_done?(job_location)
-    202 != authenticated_resource(job_location).get.code
-  end
-end

data/lib/turbot/client/pgbackups.rb

@@ -1,113 +0,0 @@
-require "turbot/client"
-
-class Turbot::Client::Pgbackups
-
-  include Turbot::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_turbot_gem_version => Turbot::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_turbot_warning response
-      response
-    end
-  end
-
-  def post(resource, params)
-    check_errors do
-      response = resource.post(params)
-      display_turbot_warning response
-      response
-    end
-  end
-
-  def delete(resource)
-    check_errors do
-      response = resource.delete
-      display_turbot_warning response
-      response
-    end
-  end
-
-  def check_errors
-    yield
-  rescue RestClient::Unauthorized
-    error "Invalid PGBACKUPS_URL"
-  end
-
-  def display_turbot_warning(response)
-    warning = response.headers[:x_turbot_warning]
-    display warning if warning
-    response
-  end
-
-end
-
-module Pgbackups
-  class Client < Turbot::Client::Pgbackups
-    def initialize(*args)
-      Turbot::Helpers.deprecate "Pgbackups::Client has been deprecated. Please use Turbot::Client::Pgbackups instead."
-      super
-    end
-  end
-end

data/lib/turbot/client/rendezvous.rb

@@ -1,111 +0,0 @@
-require "timeout"
-require "socket"
-require "uri"
-require "turbot/auth"
-require "turbot/client"
-require "turbot/helpers"
-
-class Turbot::Client::Rendezvous
-
-  include Turbot::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
-      ssl_context.ssl_version = :TLSv1
-      
-      if Turbot::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
-              ssl_socket.write(4.chr)
-              ssl_socket.flush
-              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/turbot/client/ssl_endpoint.rb

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

data/lib/turbot/client/turbot_postgresql.rb

@@ -1,148 +0,0 @@
-require "turbot/client"
-
-class Turbot::Client::TurbotPostgresql
-  Version = 11
-
-  include Turbot::Helpers
-
-  @headers = { :x_turbot_gem_version  => Turbot::Client.version }
-
-  def self.add_headers(headers)
-    @headers.merge! headers
-  end
-
-  def self.headers
-    @headers
-  end
-
-  attr_reader :attachment
-  def initialize(attachment)
-    @attachment = attachment
-    require 'rest_client'
-  end
-
-  def turbot_postgresql_host
-    if attachment.starter_plan?
-      determine_host(ENV["TURBOT_POSTGRESQL_HOST"], "postgres-starter-api.turbot.com")
-    else
-      if ENV['SHOGUN']
-        "shogun-#{ENV['SHOGUN']}.turbotapp.com"
-      else
-        determine_host(ENV["TURBOT_POSTGRESQL_HOST"], "postgres-api.turbot.com")
-      end
-    end
-  end
-
-  def resource_name
-    attachment.resource_name
-  end
-
-  def turbot_postgresql_resource
-    RestClient::Resource.new(
-      "https://#{turbot_postgresql_host}/client/v11/databases",
-      :user => Turbot::Auth.user,
-      :password => Turbot::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_turbot_warning(response)
-    warning = response.headers[:x_turbot_warning]
-    display warning if warning
-    response
-  end
-
-  def http_get(path)
-    checking_client_version do
-      retry_on_exception(RestClient::Exception) do
-        response = turbot_postgresql_resource[path].get
-        display_turbot_warning response
-        sym_keys(json_decode(response.to_s))
-      end
-    end
-  end
-
-  def http_post(path, payload = {})
-    checking_client_version do
-      response = turbot_postgresql_resource[path].post(json_encode(payload))
-      display_turbot_warning response
-      sym_keys(json_decode(response.to_s))
-    end
-  end
-
-  def http_put(path, payload = {})
-    checking_client_version do
-      response = turbot_postgresql_resource[path].put(json_encode(payload))
-      display_turbot_warning response
-      sym_keys(json_decode(response.to_s))
-    end
-  end
-
-  private
-
-  def determine_host(value, default)
-    if value.nil?
-      default
-    else
-      "#{value}.turbotapp.com"
-    end
-  end
-end
-
-module TurbotPostgresql
-  class Client < Turbot::Client::TurbotPostgresql
-    def initialize(*args)
-      Turbot::Helpers.deprecate "TurbotPostgresql::Client has been deprecated. Please use Turbot::Client::TurbotPostgresql instead."
-      super
-    end
-  end
-end

data/lib/turbot/command/ssl.rb

@@ -1,43 +0,0 @@
-require "turbot/command/base"
-
-module Turbot::Command
-
-  # DEPRECATED: see `turbot certs` instead
-  #
-  # manage ssl certificates for an bot
-  #
-  class Ssl < Base
-
-    # ssl
-    #
-    # list legacy certificates for an bot
-    #
-    def index
-      api.get_domains(bot).body.each do |domain|
-        if cert = domain['cert']
-          display "#{domain['domain']} has a SSL certificate registered to #{cert['subject']} which expires on #{format_date(cert['expires_at'])}"
-        else
-          display "#{domain['domain']} has no certificate"
-        end
-      end
-    end
-
-    # ssl:add PEM KEY
-    #
-    # DEPRECATED: see `turbot certs:add` instead
-    #
-    def add
-      $stderr.puts " !    `turbot ssl:add` has been deprecated. Please use the SSL Endpoint add-on and the `turbot certs` commands instead."
-      $stderr.puts " !    SSL Endpoint documentation is available at: https://devcenter.turbot.com/articles/ssl-endpoint"
-    end
-
-    # ssl:clear
-    #
-    # remove legacy ssl certificates from an bot
-    #
-    def clear
-      turbot.clear_ssl(bot)
-      display "Cleared certificates for #{bot}"
-    end
-  end
-end