nimbu 0.1

data/bin/nimbu

@@ -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 "nimbu/cli"
+Nimbu::CLI.start(*ARGV)

data/lib/nimbu.rb

@@ -0,0 +1,6 @@
+require "nimbu/version"
+require "nimbu/client"
+
+module Nimbu
+  # Your code goes here...
+end

data/lib/nimbu/auth.rb

@@ -0,0 +1,268 @@
+require "yaml"
+require "nimbu"
+require "nimbu/client"
+require "nimbu/helpers"
+
+class Nimbu::Auth
+  class << self
+
+    include Nimbu::Helpers
+    attr_accessor :credentials
+    attr_accessor :configuration
+
+    def client
+      @client ||= begin
+        client = Nimbu::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
+
+    # just a stub; will raise if not authenticated
+    def check
+      client.list
+    end
+
+    def default_host
+      "getnimbu.com"
+    end
+
+    def host
+      @host ||= ENV['NIMBU_HOST'] || get_nimbu_host
+    end
+
+    def theme
+      @theme ||= ENV['NIMBU_THEME'] || get_nimbu_theme
+    end
+
+    def get_nimbu_host
+      get_configuration[:hostname]
+    end
+
+    def get_nimbu_theme
+      get_configuration[:theme]
+    end
+
+    def get_configuration    # :nodoc:
+      @configuration ||= (read_configuration || ask_for_and_save_configuration)
+    end
+
+    def ask_for_and_save_configuration
+      @configuration = ask_for_configuration
+      write_configuration
+      @configuration
+    end
+
+    def configuration_file
+      "#{Dir.pwd}/nimbu.yml"
+    end
+
+    def delete_configuration
+      FileUtils.rm_f(configuration_file)
+      @host = nil
+    end
+
+   def ask_for_configuration
+      puts "What is the hostname for this Nimbu site?"
+      print "Hostname: "
+      hostname = ask
+
+      puts "What is the theme you are developing in this directory?"
+      print "Theme (i.e. default): "
+      theme = ask
+
+      {:hostname => hostname, :theme => theme}
+    end
+
+    def read_configuration
+      File.exists?(configuration_file) and YAML::load(File.open( configuration_file ))
+    end
+
+    def write_configuration
+      FileUtils.mkdir_p(File.dirname(configuration_file))
+      File.open(configuration_file, 'w') {|credentials| credentials.puts(YAML.dump(self.configuration))}
+      FileUtils.chmod(0700, File.dirname(configuration_file))
+      FileUtils.chmod(0600, configuration_file)
+    end
+
+    def reauthorize
+      @credentials = ask_for_and_save_credentials
+    end
+
+    def user    # :nodoc:
+      get_credentials[0]
+    end
+
+    def password    # :nodoc:
+      get_credentials[1]
+    end
+
+    def api_key
+      Nimbu::Client.auth(user, password)["api_key"]
+    end
+
+    def credentials_file
+      if host == default_host
+        "#{home_directory}/.nimbu/credentials"
+      else
+        "#{home_directory}/.nimbu/credentials.#{CGI.escape(host)}"
+      end
+    end
+
+    def get_credentials    # :nodoc:
+      @credentials ||= (read_credentials || ask_for_and_save_credentials)
+    end
+
+    def delete_credentials
+      FileUtils.rm_f(credentials_file)
+      @client, @credentials = nil, nil
+    end
+
+    def read_credentials
+      if ENV['NIMBU_API_KEY']
+        ['', ENV['NIMBU_API_KEY']]
+      else
+        File.exists?(credentials_file) and File.read(credentials_file).split("\n")
+      end
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(credentials_file))
+      File.open(credentials_file, 'w') {|credentials| credentials.puts(self.credentials)}
+      FileUtils.chmod(0700, File.dirname(credentials_file))
+      FileUtils.chmod(0600, credentials_file)
+    end
+
+    def echo_off
+      with_tty do
+        system "stty -echo"
+      end
+    end
+
+    def echo_on
+      with_tty do
+        system "stty echo"
+      end
+    end
+
+    def ask_for_credentials
+      puts "Enter your Nimbu credentials."
+
+      print "Email: "
+      user = ask
+
+      print "Password: "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+      api_key = Nimbu::Client.auth(user, password)['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
+      trap("INT") do
+        echo_on
+        exit
+      end
+      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
+        display "Authentication failed."
+        retry if retry_login?
+        exit 1
+      rescue Exception => e
+        delete_credentials
+        raise e
+      end
+      @credentials
+    end
+
+    def check_for_associated_ssh_key
+      return unless client.keys.empty?
+      associate_or_generate_ssh_key
+    end
+
+    def associate_or_generate_ssh_key
+      public_keys = Dir.glob("#{home_directory}/.ssh/*.pub").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 Nimbu 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 retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+  end
+end

data/lib/nimbu/cli.rb

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

data/lib/nimbu/client.rb

@@ -0,0 +1,269 @@
+require 'rexml/document'
+require 'rest_client'
+require 'uri'
+require 'time'
+require 'nimbu/auth'
+require 'nimbu/helpers'
+require 'nimbu/version'
+
+# A Ruby class to call the Nimbu REST API.  You might use this if you want to
+# manage your Nimbu apps from within a Ruby program, such as Capistrano.
+#
+# Example:
+#
+#   require 'nimbu'
+#   nimbu = Nimbu::Client.new('me@example.com', 'mypass')
+#   nimbu.create('myapp')
+#
+class Nimbu::Client
+
+  include Nimbu::Helpers
+  extend Nimbu::Helpers
+
+  def self.version
+    Nimbu::VERSION
+  end
+
+  def self.gem_version_string
+    "nimbu-gem/#{version}"
+  end
+
+  attr_accessor :host, :user, :password
+
+  def self.auth(user, password, host=Nimbu::Auth.host)
+    client = new(user, password, host)
+    json_decode client.post('/login', { :user => {:email => user, :password => password }}, :accept => 'json').to_s
+  end
+
+  def initialize(user, password, host=Nimbu::Auth.host)
+    @user = user
+    @password = password
+    @host = host
+  end
+
+  # Show a list of sites
+  def list
+    doc = xml(get('/sites').to_s)
+    doc.elements.to_a("//sites/site").map do |a|
+      name = a.elements.to_a("name").first
+      owner = a.elements.to_a("domain").first
+      [name.text, owner.text]
+    end
+  end
+
+  # Show info such as mode, custom domain, and collaborators on an app.
+  def info(name_or_domain)
+    raise ArgumentError.new("name_or_domain is required for info") unless name_or_domain
+    name_or_domain = name_or_domain.gsub(/^(http:\/\/)?(www\.)?/, '')
+    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
+
+  def on_warning(&blk)
+    @warning_callback = blk
+  end
+
+  def get_template(params)
+    post("/engine/template",params)
+  end
+
+  def get_page(params)
+    post("/engine/render",params)
+  end
+
+  def list_themes
+    get("/themes")
+  end
+
+  def show_theme_contents(theme)
+    get("/themes/#{theme}/list")
+  end
+
+  def fetch_theme_layout(theme,id)
+    get("/themes/#{theme}/layouts/#{id}")
+  end
+
+  def fetch_theme_template(theme,id)
+    get("/themes/#{theme}/templates/#{id}")
+  end
+
+  def fetch_theme_assets(theme,id)
+    get("/themes/#{theme}/assets/#{id}")
+  end
+
+
+  ##################
+
+  def resource(uri, options={})
+    if http_proxy
+      RestClient.proxy = http_proxy
+    end
+    resource = RestClient::Resource.new(realize_full_uri(uri), options.merge(:user => 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  = nimbu_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 HEROKU_SSL_VERIFY=disable"
+    end
+
+    extract_warning(response)
+    response
+  end
+
+  def extract_warning(response)
+    return unless response
+    if response.headers[:x_nimbu_warning] && @warning_callback
+      warning = response.headers[:x_nimbu_warning]
+      @displayed_warnings ||= {}
+      unless @displayed_warnings[warning]
+        @warning_callback.call(warning)
+        @displayed_warnings[warning] = true
+      end
+    end
+  end
+
+  def nimbu_headers   # :nodoc:
+    {
+      'X-Nimbu-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 configure_addon(action, app_name, addon, config = {})
+    response = update_addon action,
+                            addon_path(app_name, addon),
+                            config
+
+    json_decode(response.to_s) unless response.to_s.empty?
+  end
+
+  def addon_path(app_name, addon)
+    "/apps/#{app_name}/addons/#{escape(addon)}"
+  end
+
+  def update_addon(action, path, config)
+    params  = { :config => config }
+    app     = params[:config].delete(:confirm)
+    headers = { :accept => 'application/json' }
+    params.merge!(:confirm => app) if app
+
+    case action
+    when :install
+      post path, params, headers
+    when :upgrade
+      put path, params, headers
+    when :uninstall
+      confirm = app ? "confirm=#{app}" : ''
+      delete "#{path}?#{confirm}", headers
+    end
+  end
+
+  def realize_full_uri(given)
+    full_host = (host =~ /^http/) ? host : "http://#{host}"
+    host = URI.parse(full_host)
+    uri = URI.parse(given)
+    uri.host ||= host.host
+    uri.scheme ||= host.scheme || "http"
+    uri.path = "/api/v1" + ((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["HEROKU_SSL_VERIFY"] == "disable"
+      {}
+    elsif realize_full_uri(uri) =~ %r|^https://api.getnimbu.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
+
+  def http_proxy
+    proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    if proxy && !proxy.empty?
+      unless /^[^:]+:\/\// =~ proxy
+        proxy = "http://" + proxy
+      end
+      proxy
+    else
+      nil
+    end
+  end
+
+  def https_proxy
+    proxy = ENV['HTTPS_PROXY'] || ENV['https_proxy']
+    if proxy && !proxy.empty?
+      unless /^[^:]+:\/\// =~ proxy
+        proxy = "https://" + proxy
+      end
+      proxy
+    else
+      nil
+    end
+  end
+end