jdc 0.1.1

data/lib/jdc/client.rb

@@ -0,0 +1,457 @@
+# JDC client
+#
+# Example:
+#
+#   require 'jdc'
+#   client = JDC::Client.new('api.vcap.me')
+#   client.create('myapplication', manifest)
+#   client.create_service('redis', 'my_redis_service', opts);
+#
+
+require 'rubygems'
+require 'json/pure'
+require 'open-uri'
+
+require File.expand_path('../const', __FILE__)
+require File.expand_path('../timer', __FILE__)
+require File.expand_path('../signature/version.rb', __FILE__)
+
+class JDC::Client
+
+  include JDC::Timer
+  include JDC::Signature::Version
+
+  def self.version
+    JDC::VERSION
+  end
+
+  attr_reader   :target, :host, :user, :proxy, :auth_token, :access_key_id, :secret_key
+  attr_accessor :trace
+
+  # Error codes
+  JDC_HTTP_ERROR_CODES = [ 400, 500 ]
+
+  # Errors
+  class BadTarget <  RuntimeError; end
+  class AuthError <  RuntimeError; end
+  class TargetError < RuntimeError; end
+  class NotFound < RuntimeError; end
+  class BadResponse < RuntimeError; end
+  class HTTPException <  RuntimeError; end
+
+  # Initialize new client to the target_uri with optional auth_token
+  def initialize(target_url=JDC::DEFAULT_TARGET, auth_token=nil)
+    target_url = "http://#{target_url}" unless /^https?/ =~ target_url
+    target_url = target_url.gsub(/\/+$/, '')
+    @target = target_url
+    @auth_token = auth_token
+    @access_key_id = ENV[JDC::ACCESS_KEY_ID] 
+    raise TargetError, "Please set the enviroment value:ACCESS_KEY_ID" unless @access_key_id 
+    @secret_key = ENV[JDC::SECRET_KEY]
+    raise TargetError, "Please set the enviroment value:SECRET_KEY" unless @secret_key 
+  end
+
+  ######################################################
+  # Target info
+  ######################################################
+
+  # Retrieves information on the target cloud, and optionally the logged in user
+  def info
+    # TODO: Should merge for new version IMO, general, services, user_account
+    json_get(JDC::INFO_PATH)
+  end
+
+  def raw_info
+    http_get(JDC::INFO_PATH)
+  end
+
+  # Global listing of services that are available on the target system
+  def services_info
+    json_get(path(JDC::GLOBAL_SERVICES_PATH))
+  end
+
+  def runtimes_info
+    json_get(path(JDC::GLOBAL_RUNTIMES_PATH))
+  end
+
+  ######################################################
+  # Apps
+  ######################################################
+
+  def apps
+    json_get(JDC::APPS_PATH)
+  end
+
+  def create_app(name, manifest={})
+    app = manifest.dup
+    app[:name] = name
+    app[:instances] ||= 1
+    json_post(JDC::APPS_PATH, app)
+  end
+
+  def update_app(name, manifest)
+    json_put(path(JDC::APPS_PATH, name), manifest)
+  end
+
+  def upload_app(name, zipfile, resource_manifest=nil)
+    #FIXME, manifest should be allowed to be null, here for compatability with old cc's
+    resource_manifest ||= []
+    upload_data = {:_method => 'put'}
+    if zipfile
+      if zipfile.is_a? File
+        file = zipfile
+      else
+        file = File.new(zipfile, 'rb')
+      end
+      upload_data[:application] = file
+    end
+    upload_data[:resources] = resource_manifest.to_json if resource_manifest
+    http_post(path(JDC::APPS_PATH, name, "application"), upload_data, 'multipart/form-data')
+  rescue RestClient::ServerBrokeConnection
+    retry
+  end
+
+  def delete_app(name)
+    http_delete(path(JDC::APPS_PATH, name))
+  end
+
+  def app_info(name)
+    json_get(path(JDC::APPS_PATH, name))
+  end
+
+  def app_update_info(name)
+    json_get(path(JDC::APPS_PATH, name, "update"))
+  end
+
+  def app_stats(name)
+    stats_raw = json_get(path(JDC::APPS_PATH, name, "stats"))
+    stats = []
+    stats_raw.each_pair do |k, entry|
+      # Skip entries with no stats
+      next unless entry[:stats]
+      entry[:instance] = k.to_s.to_i
+      entry[:state] = entry[:state].to_sym if entry[:state]
+      stats << entry
+    end
+    stats.sort { |a,b| a[:instance] - b[:instance] }
+  end
+
+  def app_instances(name)
+    json_get(path(JDC::APPS_PATH, name, "instances"))
+  end
+
+  def app_crashes(name)
+    json_get(path(JDC::APPS_PATH, name, "crashes"))
+  end
+
+  # List the directory or download the actual file indicated by
+  # the path.
+  def app_files(name, path, instance='0')
+    path = path.gsub('//', '/')
+    url = path(JDC::APPS_PATH, name, "instances", instance, "files", path)
+    _, body, headers = http_get(url)
+    body
+  end
+
+  ######################################################
+  # Services
+  ######################################################
+
+  # listing of services that are available in the system
+  def services
+    json_get(JDC::SERVICES_PATH)
+  end
+
+  def create_service(service, name)
+    services = services_info
+    services ||= []
+    service_hash = nil
+
+    service = service.to_s
+
+    # FIXME!
+    services.each do |service_type, value|
+      value.each do |vendor, version|
+        version.each do |version_str, service_descr|
+          if service == service_descr[:vendor]
+            service_hash = {
+              :type => service_descr[:type], :tier => 'free',
+              :vendor => service, :version => version_str
+            }
+            break
+          end
+        end
+      end
+    end
+
+    raise TargetError, "Service [#{service}] is not a valid service choice" unless service_hash
+    service_hash[:name] = name
+    json_post(path(JDC::SERVICES_PATH), service_hash)
+  end
+
+  def delete_service(name)
+    svcs = services || []
+    names = svcs.collect { |s| s[:name] }
+    raise TargetError, "Service [#{name}] not a valid service" unless names.include? name
+    http_delete(path(JDC::SERVICES_PATH, name))
+  end
+
+  def bind_service(service, appname)
+    app = app_info(appname)
+    services = app[:services] || []
+    app[:services] = services << service
+    update_app(appname, app)
+  end
+
+  def unbind_service(service, appname)
+    app = app_info(appname)
+    services = app[:services] || []
+    services.delete(service)
+    app[:services] = services
+    update_app(appname, app)
+  end
+
+  ######################################################
+  # Resources
+  ######################################################
+
+  # Send in a resources manifest array to the system to have
+  # it check what is needed to actually send. Returns array
+  # indicating what is needed. This returned manifest should be
+  # sent in with the upload if resources were removed.
+  # E.g. [{:sha1 => xxx, :size => xxx, :fn => filename}]
+  def check_resources(resources)
+    status, body, headers = json_post(JDC::RESOURCES_PATH, resources)
+    json_parse(body)
+  end
+
+  ######################################################
+  # Validation Helpers
+  ######################################################
+
+  # Checks that the target is valid
+  def target_valid?
+    return false unless descr = info
+    return false unless descr[:name]
+    return false unless descr[:build]
+    return false unless descr[:version]
+    return false unless descr[:support]
+    true
+  rescue
+    false
+  end
+
+  ######################################################
+  # User login/password
+  ######################################################
+
+  # login and return an auth_token
+  # Auth token can be retained and used in creating
+  # new clients, avoiding login.
+  def login(user, password)
+    status, body, headers = json_post(path(JDC::USERS_PATH, user, "tokens"), {:password => password})
+    response_info = json_parse(body)
+    if response_info
+      @user = user
+      @auth_token = response_info[:token]
+    end
+  end
+
+  # sets the password for the current logged user
+  def change_password(new_password)
+    user_info = json_get(path(JDC::USERS_PATH, @user))
+    if user_info
+      user_info[:password] = new_password
+      json_put(path(JDC::USERS_PATH, @user), user_info)
+    end
+  end
+
+  ######################################################
+  # System administration
+  ######################################################
+
+  def proxy=(proxy)
+    @proxy = proxy
+  end
+
+  def proxy_for(proxy)
+    @proxy = proxy
+  end
+
+  def users
+    json_get(JDC::USERS_PATH)
+  end
+
+  def add_user(user_email, password)
+    json_post(JDC::USERS_PATH, { :email => user_email, :password => password })
+  end
+
+  def delete_user(user_email)
+    http_delete(path(JDC::USERS_PATH, user_email))
+  end
+
+  ######################################################
+
+  def self.path(*path)
+    path.flatten.collect { |x|
+      URI.encode x.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+    }.join("/")
+  end
+
+  private
+
+  def path(*args, &blk)
+    self.class.path(*args, &blk)
+  end
+
+  def json_get(url)
+    status, body, headers = http_get(url, 'application/json')
+    json_parse(body)
+  rescue JSON::ParserError
+    raise BadResponse, "Can't parse response into JSON", body
+  end
+
+  def json_post(url, payload)
+    http_post(url, payload.to_json, 'application/json')
+  end
+
+  def json_put(url, payload)
+    http_put(url, payload.to_json, 'application/json')
+  end
+
+  def json_parse(str)
+    if str
+      JSON.parse(str, :symbolize_names => true)
+    end
+  end
+
+  require 'rest_client'
+
+  # HTTP helpers
+
+  def http_get(path, content_type=nil)
+    request(:get, path, content_type)
+  end
+
+  def http_post(path, body, content_type=nil)
+    request(:post, path, content_type, body)
+  end
+
+  def http_put(path, body, content_type=nil)
+    request(:put, path, content_type, body)
+  end
+
+  def http_delete(path)
+    request(:delete, path)
+  end
+
+  def request(method, path, content_type = nil, payload = nil, headers = {})
+    headers = headers.dup
+    headers['AUTHORIZATION'] = access_key_id if access_key_id 
+    headers['PROXY-USER'] = @proxy if @proxy
+    headers['Version'] = JDC::VERSION 
+    
+    #init date time -- tibelf
+    headers['Date'] = get_time 
+    headers['ACCESS-KEY-ID'] = access_key_id if access_key_id 
+    headers['Path'] = path 
+
+    if content_type
+      if content_type == 'application/json' 
+        headers['Content-Type'] = content_type
+        headers['Accept'] = content_type
+      else
+        headers['Content-Type'] = content_type
+      end
+    end
+
+    req = {
+      :method => method, :url => "#{@target}/#{path}",
+      :payload => payload, :headers => headers, :multipart => true
+    }
+
+    signature = generate_signature(secret_key, req)
+    headers['signature'] = signature
+
+    status, body, response_headers = perform_http_request(req)
+
+    if request_failed?(status)
+      # FIXME, old cc returned 400 on not found for file access
+      err = (status == 404 || status == 400) ? NotFound : TargetError
+      raise err, parse_error_message(status, body)
+    else
+      return status, body, response_headers
+    end
+  rescue URI::Error, SocketError, Errno::ECONNREFUSED => e
+    raise BadTarget, "Cannot access target (%s)" % [ e.message ]
+  end
+
+  def request_failed?(status)
+    JDC_HTTP_ERROR_CODES.detect{|error_code| status >= error_code}
+  end
+
+  def perform_http_request(req)
+    proxy_uri = URI.parse(req[:url]).find_proxy()
+    RestClient.proxy = proxy_uri.to_s if proxy_uri
+
+    # Setup tracing if needed
+    unless trace.nil?
+      req[:headers]['X-VCAP-Trace'] = (trace == true ? '22' : trace)
+    end
+
+    result = nil
+    RestClient::Request.execute(req) do |response, request|
+      result = [ response.code, response.body, response.headers ]
+      unless trace.nil?
+        puts '>>>'
+        puts "PROXY: #{RestClient.proxy}" if RestClient.proxy
+        puts "REQUEST: #{req[:method]} #{req[:url]}"
+        puts "RESPONSE_HEADERS:"
+        response.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+        end
+        puts "REQUEST_BODY: #{req[:payload]}" if req[:payload]
+        puts "RESPONSE: [#{response.code}]"
+        begin
+            puts JSON.pretty_generate(JSON.parse(response.body))
+        rescue
+            puts "#{response.body}"
+        end
+        puts '<<<'
+      end
+    end
+    result
+  rescue Net::HTTPBadResponse => e
+    raise BadTarget "Received bad HTTP response from target: #{e}"
+  rescue SystemCallError, RestClient::Exception => e
+    raise HTTPException, "HTTP exception: #{e.class}:#{e}"
+  end
+
+  def truncate(str, limit = 30)
+    etc = '...'
+    stripped = str.strip[0..limit]
+    if stripped.length > limit
+      stripped + etc
+    else
+      stripped
+    end
+  end
+
+  def parse_error_message(status, body)
+    parsed_body = json_parse(body.to_s)
+    if parsed_body && parsed_body[:code] && parsed_body[:description]
+      desc = parsed_body[:description].gsub("\"","'")
+      "Error #{parsed_body[:code]}: #{desc}"
+    else
+      "Error (HTTP #{status}): #{body}"
+    end
+  rescue JSON::ParserError
+    if body.nil? || body.empty?
+      "Error (#{status}): No Response Received"
+    else
+      body_out = trace ? body : truncate(body)
+      "Error (JSON #{status}): #{body_out}"
+    end
+  end
+
+end

data/lib/jdc/const.rb

@@ -0,0 +1,25 @@
+module JDC
+
+  # This is the internal JDC version number, and is not necessarily
+  # the same as the RubyGem version (JDC::Cli::VERSION).
+  VERSION = '0.1.1'
+
+  # Targets
+  DEFAULT_TARGET = 'https://api.jd-app.com'
+  DEFAULT_LOCAL_TARGET = 'http://api.vcap.me'
+
+  # General Paths
+  INFO_PATH            = 'info'
+  GLOBAL_SERVICES_PATH = ['info', 'services']
+  GLOBAL_RUNTIMES_PATH = ['info', 'runtimes']
+  RESOURCES_PATH       = 'resources'
+
+  # User specific paths
+  APPS_PATH            = 'apps'
+  SERVICES_PATH        = 'services'
+  USERS_PATH           = 'users'
+
+  #Enviroment Argument
+  ACCESS_KEY_ID = "ACCESS_KEY_ID"
+  SECRET_KEY    = "SECRET_KEY"
+end

data/lib/jdc/micro/switcher/base.rb

@@ -0,0 +1,97 @@
+require 'interact'
+
+module JDC::Micro::Switcher
+  class Base
+    include Interactive
+
+    def initialize(config)
+      @config = config
+
+      @vmrun = JDC::Micro::VMrun.new(config)
+      unless @vmrun.running?
+        if ask("JingDong Cloud VM is not running. Do you want to start it?", :choices => ['y', 'n']) == 'y'
+          display "Starting JingDong Cloud VM: ", false
+          @vmrun.start
+          say "done".green
+        else
+          err "JingDong Cloud VM needs to be running."
+        end
+      end
+
+      err "JingDong Cloud VM initial setup needs to be completed before using 'jdc micro'" unless @vmrun.ready?
+    end
+
+    def offline
+      unless @vmrun.offline?
+        # save online connection type so we can restore it later
+        @config['online_connection_type'] = @vmrun.connection_type
+
+        if (@config['online_connection_type'] != 'nat')
+          if ask("Reconfigure JingDong Cloud VM network to nat mode and reboot?", :choices => ['y', 'n']) == 'y'
+            display "Rebooting JingDong Cloud VM: ", false
+            @vmrun.connection_type = 'nat'
+            @vmrun.reset
+            say "done".green
+          else
+            err "Aborted"
+          end
+        end
+
+        display "Setting JingDong Cloud VM to offline mode: ", false
+        @vmrun.offline!
+        say "done".green
+        display "Setting host DNS server: ", false
+
+        @config['domain'] = @vmrun.domain
+        @config['ip'] = @vmrun.ip
+        set_nameserver(@config['domain'], @config['ip'])
+        say "done".green
+      else
+        say "JingDong Cloud VM already in offline mode".yellow
+      end
+    end
+
+    def online
+      if @vmrun.offline?
+        current_connection_type = @vmrun.connection_type
+        @config['online_connection_type'] ||= current_connection_type
+
+        if (@config['online_connection_type'] != current_connection_type)
+          # TODO handle missing connection type in saved config
+          question = "Reconfigure JingDong Cloud VM network to #{@config['online_connection_type']} mode and reboot?"
+          if ask(question, :choices => ['y', 'n']) == 'y'
+            display "Rebooting JingDong Cloud VM: ", false
+            @vmrun.connection_type = @config['online_connection_type']
+            @vmrun.reset
+            say "done".green
+          else
+            err "Aborted"
+          end
+        end
+
+        display "Unsetting host DNS server: ", false
+        # TODO handle missing domain and ip in saved config (look at the VM)
+        @config['domain'] ||= @vmrun.domain
+        @config['ip'] ||= @vmrun.ip
+        unset_nameserver(@config['domain'], @config['ip'])
+        say "done".green
+
+        display "Setting JingDong Cloud VM to online mode: ", false
+        @vmrun.online!
+        say "done".green
+      else
+        say "JingDong Cloud already in online mode".yellow
+      end
+    end
+
+    def status
+      mode = @vmrun.offline? ? 'offline' : 'online'
+      say "JingDong Cloud VM currently in #{mode.green} mode"
+      # should the VMX path be unescaped?
+      say "VMX Path: #{@vmrun.vmx}"
+      say "Domain: #{@vmrun.domain.green}"
+      say "IP Address: #{@vmrun.ip.green}"
+    end
+  end
+
+end

data/lib/jdc/micro/switcher/darwin.rb

@@ -0,0 +1,19 @@
+module JDC::Micro::Switcher
+
+  class Darwin < Base
+    def adminrun(command)
+      JDC::Micro.run_command("osascript", "-e 'do shell script \"#{command}\" with administrator privileges'")
+    end
+
+    def set_nameserver(domain, ip)
+      File.open("/tmp/#{domain}", 'w') { |file| file.write("nameserver #{ip}") }
+      adminrun("mkdir -p /etc/resolver;mv /tmp/#{domain} /etc/resolver/")
+    end
+
+    def unset_nameserver(domain, ip)
+      err "domain missing" unless domain
+      adminrun("rm -f /etc/resolver/#{domain}")
+    end
+  end
+
+end

data/lib/jdc/micro/switcher/dummy.rb

@@ -0,0 +1,15 @@
+# only used for testing
+module JDC::Micro::Switcher
+
+  class Dummy < Base
+    def adminrun(command)
+    end
+
+    def set_nameserver(domain, ip)
+    end
+
+    def unset_nameserver(domain, ip)
+    end
+  end
+
+end

data/lib/jdc/micro/switcher/linux.rb

@@ -0,0 +1,16 @@
+module JDC::Micro::Switcher
+
+  class Linux < Base
+    def set_nameserver(domain, ip)
+      JDC::Micro.run_command("sudo", "sed -i'.backup' '1 i nameserver #{ip}' /etc/resolv.conf")
+      # lock resolv.conf so Network Manager doesn't clear out the file when offline
+      JDC::Micro.run_command("sudo", "chattr +i /etc/resolv.conf")
+    end
+
+    def unset_nameserver(domain, ip)
+      JDC::Micro.run_command("sudo", "chattr -i /etc/resolv.conf")
+      JDC::Micro.run_command("sudo", "sed -i'.backup' '/#{ip}/d' /etc/resolv.conf")
+    end
+  end
+
+end

data/lib/jdc/micro/switcher/windows.rb

@@ -0,0 +1,31 @@
+module JDC::Micro::Switcher
+
+  class Windows < Base
+    def version?
+      JDC::Micro.run_command("cmd", "/c ver").to_s.scan(/\d+\.\d+/).first.to_f
+    end
+
+    def adminrun(command, args=nil)
+      if version? > 5.2
+        require 'win32ole'
+        shell = WIN32OLE.new("Shell.Application")
+        shell.ShellExecute(command, args, nil, "runas", 0)
+      else
+        # on older version this will try to run the command, and if you don't have
+        # admin privilges it will tell you so and exit
+        JDC::Micro.run_command(command, args)
+      end
+    end
+
+    # TODO better method to figure out the interface name is to get the NAT ip and find the
+    # interface with the correct subnet
+    def set_nameserver(domain, ip)
+      adminrun("netsh", "interface ip set dns \"VMware Network Adapter VMnet8\" static #{ip}")
+    end
+
+    def unset_nameserver(domain, ip)
+      adminrun("netsh", "interface ip set dns \"VMware Network Adapter VMnet8\" static none")
+    end
+  end
+
+end