transcriptic 0.1.0

data/bin/transcriptic

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+# start up the CLI
+require "transcriptic/cli"
+Transcriptic::CLI.start(*ARGV)

data/lib/transcriptic.rb

@@ -0,0 +1,3 @@
+module Transcriptic; end
+
+require "transcriptic/client"

data/lib/transcriptic/api.rb

@@ -0,0 +1,73 @@
+require "transcriptic/api/errors"
+require "transcriptic/api/version"
+
+require "transcriptic/api/sequences"
+
+srand
+
+module Transcriptic
+  class API
+
+    def initialize(options={})
+      @api_key = options.delete(:api_key) || ENV['TRANSCRIPTIC_API_KEY']
+      user_pass = ":#{@api_key}"
+      options = {
+        :headers  => {},
+        :host     => 'www.transcriptic.com',
+        :scheme   => 'https'
+      }.merge(options)
+      options[:headers] = {
+        'Accept'                => 'application/json',
+        'Accept-Encoding'       => 'gzip',
+        #'Accept-Language'       => 'en-US, en;q=0.8',
+        'Authorization'         => "Basic #{Base64.encode64(user_pass).gsub("\n", '')}",
+        'User-Agent'            => "transcriptic-rb/#{Transcriptic::API::VERSION}",
+        'X-Transcriptic-API-Version'  => '3',
+        'X-Ruby-Version'        => RUBY_VERSION,
+        'X-Ruby-Platform'       => RUBY_PLATFORM
+      }.merge(options[:headers])
+      @connection = Excon.new("#{options[:scheme]}://#{options[:host]}", options)
+    end
+
+    def request(params, &block)
+      begin
+        response = @connection.request(params, &block)
+      rescue Excon::Errors::SocketError => error
+        raise error
+      rescue Excon::Errors::Error => error
+        klass = case error.response.status
+          when 401 then Transcriptic::API::Errors::Unauthorized
+          when 402 then Transcriptic::API::Errors::VerificationRequired
+          when 403 then Transcriptic::API::Errors::Forbidden
+          when 404 then Transcriptic::API::Errors::NotFound
+          when 408 then Transcriptic::API::Errors::Timeout
+          when 422 then Transcriptic::API::Errors::RequestFailed
+          when 423 then Transcriptic::API::Errors::Locked
+          when /50./ then Transcriptic::API::Errors::RequestFailed
+          else Transcriptic::API::Errors::ErrorWithResponse
+        end
+
+        reerror = klass.new(error.message, error.response)
+        reerror.set_backtrace(error.backtrace)
+        raise(reerror)
+      end
+
+      if response.body && !response.body.empty?
+        if response.headers['Content-Encoding'] == 'gzip'
+          response.body = Zlib::GzipReader.new(StringIO.new(response.body)).read
+        end
+        begin
+          response.body = Transcriptic::API::OkJson.decode(response.body)
+        rescue
+          # leave non-JSON body as is
+        end
+      end
+
+      # reset (non-persistent) connection
+      @connection.reset
+
+      response
+    end
+
+  end
+end

data/lib/transcriptic/api/errors.rb

@@ -0,0 +1,24 @@
+module Transcriptic
+  class API
+    module Errors
+      class Error < StandardError; end
+
+      class ErrorWithResponse < Error
+        attr_reader :response
+
+        def initialize(message, response)
+          super message
+          @response = response
+        end
+      end
+
+      class Unauthorized < ErrorWithResponse; end
+      class VerificationRequired < ErrorWithResponse; end
+      class Forbidden < ErrorWithResponse; end
+      class NotFound < ErrorWithResponse; end
+      class Timeout < ErrorWithResponse; end
+      class Locked < ErrorWithResponse; end
+      class RequestFailed < ErrorWithResponse; end
+    end
+  end
+end

data/lib/transcriptic/api/sequences.rb

@@ -0,0 +1,33 @@
+module Transcriptic
+  class API
+
+    # DELETE /:organization/sequences/:sequence
+    def delete_sequence(organization, sequence)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/#{organization}/sequences/#{sequence}"
+      )
+    end
+
+    # GET /:organization/sequences
+    def get_sequences(organization)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/#{organization}/sequences"
+      )
+    end
+
+    # POST /:organization/sequences
+    def post_domain(organization, sequence)
+      request(
+        :expects  => 201,
+        :method   => :post,
+        :path     => "/#{organization}/sequences",
+        :query    => {'sequence' => sequence}
+      )
+    end
+
+  end
+end

data/lib/transcriptic/api/version.rb

@@ -0,0 +1,5 @@
+module Transcriptic
+  class API
+    VERSION = "0.1.0"
+  end
+end

data/lib/transcriptic/auth.rb

@@ -0,0 +1,223 @@
+require "transcriptic"
+require "transcriptic/client"
+require "transcriptic/helpers"
+
+class Transcriptic::Auth
+  class << self
+    attr_accessor :credentials
+
+    def client
+      @client ||= begin
+        client = Transcriptic::Client.new(user, password, host)
+        client.on_warning { |msg| self.display("\n#{msg}\n\n") }
+        client
+      end
+    end
+
+    def login
+      delete_credentials
+      get_credentials
+    end
+
+    def logout
+      delete_credentials
+    end
+
+    def clear
+      @credentials = nil
+      @client = nil
+    end
+
+    include Transcriptic::Helpers
+
+    # just a stub; will raise if not authenticated
+    def check
+      client.list
+    end
+
+    def default_host
+      "transcriptic.com"
+    end
+
+    def host
+      ENV['TRANSCRIPTIC_HOST'] || default_host
+    end
+
+    def reauthorize
+      @credentials = ask_for_and_save_credentials
+    end
+
+    def user    # :nodoc:
+      get_credentials
+      @credentials[0]
+    end
+
+    def password    # :nodoc:
+      get_credentials
+      @credentials[1]
+    end
+
+    def credentials_file
+      if host == default_host
+        "#{home_directory}/.transcriptic/credentials"
+      else
+        "#{home_directory}/.transcriptic/credentials.#{host}"
+      end
+    end
+
+    def get_credentials    # :nodoc:
+      return if @credentials
+      unless @credentials = read_credentials
+        ask_for_and_save_credentials
+      end
+      @credentials
+    end
+
+    def read_credentials
+      File.exists?(credentials_file) and File.read(credentials_file).split("\n")
+    end
+
+    def echo_off
+      system "stty -echo"
+    end
+
+    def echo_on
+      system "stty echo"
+    end
+
+    def ask_for_credentials
+      puts "Enter your Transcriptic credentials."
+
+      print "Email: "
+      user = ask
+
+      print "Password: "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+      api_key = Transcriptic::Client.auth(user, password, host)['api_key']
+
+      [user, api_key]
+    end
+
+    def ask_for_password_on_windows
+      require "Win32API"
+      char = nil
+      password = ''
+
+      while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          # windows might throw a -1 at us so make sure to handle RangeError
+          (password << char.chr) rescue RangeError
+        end
+      end
+      puts
+      return password
+    end
+
+    def ask_for_password
+      echo_off
+      password = ask
+      puts
+      echo_on
+      return password
+    end
+
+    def ask_for_and_save_credentials
+      begin
+        @credentials = ask_for_credentials
+        write_credentials
+        check
+      rescue ::RestClient::Unauthorized, ::RestClient::ResourceNotFound => e
+        delete_credentials
+        clear
+        display "Authentication failed."
+        retry if retry_login?
+        exit 1
+      rescue Exception => e
+        delete_credentials
+        raise e
+      end
+      check_for_associated_ssh_key unless Transcriptic::Command.current_command == "keys:add"
+    end
+
+    def check_for_associated_ssh_key
+      return unless client.keys.length.zero?
+      associate_or_generate_ssh_key
+    end
+
+    def associate_or_generate_ssh_key
+      public_keys = available_ssh_public_keys.sort
+
+      case public_keys.length
+      when 0 then
+        display "Could not find an existing public key."
+        display "Would you like to generate one? [Yn] ", false
+        unless ask.strip.downcase == "n"
+          display "Generating new SSH public key."
+          generate_ssh_key("id_rsa")
+          associate_key("#{home_directory}/.ssh/id_rsa.pub")
+        end
+      when 1 then
+        display "Found existing public key: #{public_keys.first}"
+        associate_key(public_keys.first)
+      else
+        display "Found the following SSH public keys:"
+        public_keys.each_with_index do |key, index|
+          display "#{index+1}) #{File.basename(key)}"
+        end
+        display "Which would you like to use with your Transcriptic account? ", false
+        chosen = public_keys[ask.to_i-1] rescue error("Invalid choice")
+        associate_key(chosen)
+      end
+    end
+
+    def generate_ssh_key(keyfile)
+      ssh_dir = File.join(home_directory, ".ssh")
+      unless File.exists?(ssh_dir)
+        FileUtils.mkdir_p ssh_dir
+        File.chmod(0700, ssh_dir)
+      end
+      `ssh-keygen -t rsa -N "" -f \"#{home_directory}/.ssh/#{keyfile}\" 2>&1`
+    end
+
+    def associate_key(key)
+      display "Uploading ssh public key #{key}"
+      client.add_key(File.read(key))
+    end
+
+    def available_ssh_public_keys
+      keys = [
+        "#{home_directory}/.ssh/id_rsa.pub",
+        "#{home_directory}/.ssh/id_dsa.pub"
+      ]
+      keys.concat(Dir["#{home_directory}/.ssh/*.pub"])
+      keys.select { |d| File.exists?(d) }.uniq
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(credentials_file))
+      f = File.open(credentials_file, 'w')
+      f.puts self.credentials
+      f.close
+      set_credentials_permissions
+    end
+
+    def set_credentials_permissions
+      FileUtils.chmod 0700, File.dirname(credentials_file)
+      FileUtils.chmod 0600, credentials_file
+    end
+
+    def delete_credentials
+      FileUtils.rm_f(credentials_file)
+      clear
+    end
+  end
+end

data/lib/transcriptic/cli.rb

@@ -0,0 +1,12 @@
+require "transcriptic"
+require "transcriptic/command"
+
+class Transcriptic::CLI
+
+  def self.start(*args)
+    command = args.shift.strip rescue "help"
+    Transcriptic::Command.load
+    Transcriptic::Command.run(command, args)
+  end
+
+end

data/lib/transcriptic/client.rb

@@ -0,0 +1,332 @@
+require 'rexml/document'
+require 'rest-client'
+require 'uri'
+require 'time'
+require 'transcriptic/auth'
+require 'transcriptic/helpers'
+require 'transcriptic/version'
+
+# A Ruby class to call the Transcriptic REST API.  You might use this if you want to
+# manage your Transcriptic apps from within a Ruby program, such as Capistrano.
+#
+# Example:
+#
+#   require 'transcriptic'
+#   transcriptic = Transcriptic::Client.new('me@example.com', 'mypass')
+#   transcriptic.create('myapp')
+#
+class Transcriptic::Client
+
+  include Transcriptic::Helpers
+  extend Transcriptic::Helpers
+
+  def self.version
+    Transcriptic::VERSION
+  end
+
+  def self.gem_version_string
+    "transcriptic-gem/#{version}"
+  end
+
+  attr_accessor :host, :user, :password
+
+  def self.auth(user, password, host = Transcriptic::Auth.default_host)
+    client = new(user, password, host)
+    json_decode client.post('/users/sign_in', { 'user[email]' => user, 'user[password]' => password }, :accept => 'json').to_s
+  end
+
+  def initialize(user, password, host=Transcriptic::Auth.default_host)
+    @user = user
+    @password = password
+    @host = host
+  end
+
+  # Show info such as mode, custom domain, and collaborators on an app.
+  def status(run_id)
+    doc = xml(get("/apps/#{name_or_domain}").to_s)
+    attrs = hash_from_xml_doc(doc)[:app]
+    attrs.merge!(:collaborators => list_collaborators(attrs[:name]))
+    attrs.merge!(:addons        => installed_addons(attrs[:name]))
+  end
+
+  # Add an ssh public key to the current user.
+  def add_key(key)
+    post("/user/keys", key, { 'Content-Type' => 'text/ssh-authkey' }).to_s
+  end
+
+  # Remove an existing ssh public key from the current user.
+  def remove_key(key)
+    delete("/user/keys/#{escape(key)}").to_s
+  end
+
+  # Clear all keys on the current user.
+  def remove_all_keys
+    delete("/user/keys").to_s
+  end
+
+  # Get a list of stacks available to the app, with the current one marked.
+  def list_stacks(app_name, options={})
+    include_deprecated = options.delete(:include_deprecated) || false
+
+    json_decode resource("/apps/#{app_name}/stack").get(
+      :params => { :include_deprecated => include_deprecated },
+      :accept => 'application/json'
+    ).to_s
+  end
+
+  class AppCrashed < RuntimeError; end
+
+  # Show a list of projects which you are a collaborator on.
+  def list
+    doc = xml(get('/apps').to_s)
+    doc.elements.to_a("//apps/app").map do |a|
+      name = a.elements.to_a("name").first
+      owner = a.elements.to_a("owner").first
+      [name.text, owner.text]
+    end
+  end
+  
+  # Show info such as mode, custom domain, and collaborators on an app.
+  def info(name_or_domain)
+    name_or_domain = name_or_domain.gsub(/^(http:\/\/)?(www\.)?/, '')
+  end
+
+  def organizations
+    json_decode resource("/organizations").get(:accept => 'application/json').to_s
+  end
+
+  # Add an ssh public key to the current user.
+  def add_sequence(organization, sequence)
+    post("/#{organization}/sequences", sequence, { 'Content-Type' => 'text/ssh-authkey' }).to_s
+  end
+
+  # Remove an existing ssh public key from the current user.
+  def remove_sequence(organization, sequence)
+    delete("/#{organization}/sequences/#{escape(key)}").to_s
+  end
+
+  class Protocol
+    attr_accessor :attached, :upid
+
+    def initialize(client, protocol, upid=nil)
+      @client = client
+      @protocol = protocol
+      @upid = upid
+    end
+
+    # launch the protocol
+    def launch(command, attached=false)
+      @attached = attached
+      @response = @client.post(
+        "/runs/#{@app}/services",
+        command,
+        :content_type => 'text/plain'
+      )
+      @next_chunk = @response.to_s
+      @interval = 0
+      self
+    rescue RestClient::RequestFailed => e
+      raise AppCrashed, e.http_body  if e.http_code == 502
+      raise
+    end
+
+    # Does the service have any remaining output?
+    def end_of_stream?
+      @next_chunk.nil?
+    end
+
+    # Read the next chunk of output.
+    def read
+      chunk = @client.get(@next_chunk)
+      if chunk.headers[:location].nil? && chunk.code != 204
+        # no more chunks
+        @next_chunk = nil
+        chunk.to_s
+      elsif chunk.to_s == ''
+        # assume no content and back off
+        @interval = 2
+        ''
+      elsif location = chunk.headers[:location]
+        # some data read and next chunk available
+        @next_chunk = location
+        @interval = 0
+        chunk.to_s
+      end
+    end
+
+    # Iterate over all output chunks until EOF is reached.
+    def each
+      until end_of_stream?
+        sleep(@interval)
+        output = read
+        yield output unless output.empty?
+      end
+    end
+
+    # All output as a string
+    def to_s
+      buf = []
+      each { |part| buf << part }
+      buf.join
+    end
+  end
+
+  def status(run_id)
+    json_decode resource("/runs/#{run_id}/status").get(:accept => 'application/json').to_s
+  end
+
+  # Get a Protocol instance to execute commands against.
+  def protocol(run_id, upid)
+    Protocol.new(self, run_id, upid)
+  end
+
+  def read_logs(run_id, options=[])
+    query = "&" + options.join("&") unless options.empty?
+    url = get("/runs/#{run_id}/logs?#{query}").to_s
+    uri  = URI.parse(url);
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    if uri.scheme == 'https'
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    http.read_timeout = 60 * 60 * 24
+
+    begin
+      http.start do
+        http.request_get(uri.path + (uri.query ? "?" + uri.query : "")) do |request|
+          request.read_body do |chunk|
+            yield chunk
+          end
+        end
+      end
+    rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+      abort(" !    Could not connect to logging service")
+    rescue Timeout::Error, EOFError
+      abort("\n !    Request timed out")
+    end
+  end
+
+  def on_warning(&blk)
+    @warning_callback = blk
+  end
+
+  ##################
+
+  def resource(uri, options={})
+    RestClient.proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    resource = RestClient::Resource.new(realize_full_uri(uri), options.merge(:user => user, :password => password))
+    resource
+  end
+
+  def get(uri, extra_headers={})    # :nodoc:
+    process(:get, uri, extra_headers)
+  end
+
+  def post(uri, payload="", extra_headers={})    # :nodoc:
+    process(:post, uri, extra_headers, payload)
+  end
+
+  def put(uri, payload, extra_headers={})    # :nodoc:
+    process(:put, uri, extra_headers, payload)
+  end
+
+  def delete(uri, extra_headers={})    # :nodoc:
+    process(:delete, uri, extra_headers)
+  end
+
+  def process(method, uri, extra_headers={}, payload=nil)
+    headers  = transcriptic_headers.merge(extra_headers)
+    args     = [method, payload, headers].compact
+
+    resource_options = default_resource_options_for_uri(uri)
+
+    begin
+      response = resource(uri, resource_options).send(*args)
+    rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+      host = URI.parse(realize_full_uri(uri)).host
+      error " !   Unable to connect to #{host}"
+    rescue RestClient::SSLCertificateNotVerified => ex
+      host = URI.parse(realize_full_uri(uri)).host
+      #error "WARNING: Unable to verify SSL certificate for #{host}\nTo disable SSL verification, run with TRANSCRIPTIC_SSL_VERIFY=disable"
+    end
+
+    extract_warning(response)
+    response
+  end
+
+  def extract_warning(response)
+    return unless response
+    if response.headers[:x_transcriptic_warning] && @warning_callback
+      warning = response.headers[:x_transcriptic_warning]
+      @displayed_warnings ||= {}
+      unless @displayed_warnings[warning]
+        @warning_callback.call(warning)
+        @displayed_warnings[warning] = true
+      end
+    end
+  end
+
+  def transcriptic_headers   # :nodoc:
+    {
+      'X-Transcriptic-API-Version' => '1',
+      'User-Agent'                 => self.class.gem_version_string,
+      'X-Ruby-Version'             => RUBY_VERSION,
+      'X-Ruby-Platform'            => RUBY_PLATFORM
+    }
+  end
+
+  def xml(raw)   # :nodoc:
+    REXML::Document.new(raw)
+  end
+
+  def escape(value)  # :nodoc:
+    escaped = URI.escape(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    escaped.gsub('.', '%2E') # not covered by the previous URI.escape
+  end
+
+  module JSON
+    def self.parse(json)
+      json_decode(json)
+    end
+  end
+
+  private
+
+  def realize_full_uri(given)
+    full_host = (host =~ /^http/) ? host : "https://www.#{host}"
+    host = URI.parse(full_host)
+    uri = URI.parse(given)
+    uri.host ||= host.host
+    uri.scheme ||= host.scheme || "https"
+    uri.path = (uri.path[0..0] == "/") ? uri.path : "/#{uri.path}"
+    uri.port = host.port if full_host =~ /\:\d+/
+    uri.to_s
+  end
+
+  def default_resource_options_for_uri(uri)
+    if ENV["TRANSCRIPTIC_SSL_VERIFY"] == "disable"
+      {}
+    elsif realize_full_uri(uri) =~ %r|^https://www.transcriptic.com|
+      { :verify_ssl => OpenSSL::SSL::VERIFY_PEER, :ssl_ca_file => local_ca_file }
+    else
+      {}
+    end
+  end
+
+  def local_ca_file
+    File.expand_path("../../data/cacert.pem", __FILE__)
+  end
+
+  def hash_from_xml_doc(elements)
+    elements.inject({}) do |hash, e|
+      next(hash) unless e.respond_to?(:children)
+      hash.update(e.name.gsub("-","_").to_sym => case e.children.length
+        when 0 then nil
+        when 1 then e.text
+        else hash_from_xml_doc(e.children)
+      end)
+    end
+  end
+end