af 0.3.22 → 0.5.0.beta.1

data/lib/cli/commands/services.rb

@@ -1,217 +0,0 @@
-require "uuidtools"
-
-module VMC::Cli::Command
-
-  class Services < Base
-    include VMC::Cli::ServicesHelper
-    include VMC::Cli::TunnelHelper
-
-    def services
-      ss = client.services_info
-      ps = client.services
-      ps.sort! {|a, b| a[:name] <=> b[:name] }
-
-      if @options[:json]
-        services = { :system => ss, :provisioned => ps }
-        return display JSON.pretty_generate(services)
-      end
-      display_system_services(ss)
-      display_provisioned_services(ps)
-    end
-
-    def create_service(service=nil, name=nil, appname=nil)
-
-      unless no_prompt || service
-        services = client.services_info
-        err 'No services available to provision' if services.empty?
-        service = ask(
-          "Which service would you like to provision?",
-          { :indexed => true,
-            :choices =>
-              services.values.collect { |type|
-                type.keys.collect(&:to_s)
-              }.flatten
-          }
-        )
-      end
-      name = @options[:name] unless name
-      unless name
-        name = random_service_name(service)
-        picked_name = true
-      end
-
-      if client.infra_supported?
-        unless no_prompt || @options[:infra]
-          @options[:infra] = client.infra_name_for_description(
-              ask("Select Infrastructure",
-                :indexed => true, :choices => client.infra_descriptions))
-        end
-      end
-
-      create_service_banner(service, name, picked_name, @options[:infra])
-      appname = @options[:bind] unless appname
-      bind_service_banner(name, appname) if appname
-    end
-
-    def delete_service(service=nil)
-      unless no_prompt || service
-        user_services = client.services
-        err 'No services available to delete' if user_services.empty?
-        service = ask(
-          "Which service would you like to delete?",
-          { :indexed => true,
-            :choices => user_services.collect { |s| s[:name] }
-          }
-        )
-      end
-      err "Service name required." unless service
-      display "Deleting service [#{service}]: ", false
-      client.delete_service(service)
-      display 'OK'.green
-    end
-
-    def bind_service(service, appname)
-      bind_service_banner(service, appname)
-    end
-
-    def unbind_service(service, appname)
-      unbind_service_banner(service, appname)
-    end
-
-    def clone_services(src_app, dest_app)
-      begin
-        src  = client.app_info(src_app)
-        dest = client.app_info(dest_app)
-      rescue
-      end
-
-      err "Application '#{src_app}' does not exist" unless src
-      err "Application '#{dest_app}' does not exist" unless dest
-
-      services = src[:services]
-      err 'No services to clone' unless services && !services.empty?
-      services.each { |service| bind_service_banner(service, dest_app, false) }
-      check_app_for_restart(dest_app)
-    end
-
-    def export_service(service)
-      display "Exporting data from '#{service}': ", false
-      export_info = client.export_service(service)
-      if export_info
-        display 'OK'.green
-        puts export_info[:uri]
-      else
-        err "Export data from '#{service}': failed"
-      end
-    end
-
-    def import_service(service,url)
-      display "Importing data into '#{service}': ", false
-      import_info = client.import_service(service,url)
-      if import_info
-        display 'OK'.green
-      else
-        err "Import data into '#{service}' failed"
-      end
-    end
-
-    def tunnel(service=nil, client_name=nil)
-      unless defined? Caldecott
-        display "To use `af tunnel', you must first install Caldecott:"
-        display ""
-        display "\tgem install caldecott"
-        display ""
-        display "Note that you'll need a C compiler. If you're on OS X, Xcode"
-        display "will provide one. If you're on Windows, try DevKit."
-        display ""
-        display "This manual step will be removed in the future."
-        display ""
-        err "Caldecott is not installed."
-      end
-
-      ps = client.services
-      err "No services available to tunnel to" if ps.empty?
-
-      unless service
-        choices = ps.collect { |s| s[:name] }.sort
-        service = ask(
-          "Which service to tunnel to?",
-          :choices => choices,
-          :indexed => true
-        )
-      end
-
-      info = ps.select { |s| s[:name] == service }.first
-
-      err "Unknown service '#{service}'" unless info
-
-      port = pick_tunnel_port(@options[:port] || 10000)
-
-      raise VMC::Client::AuthError unless client.logged_in?
-
-      infra_name = nil
-      if client.infra_supported?
-        infra_name = info[:infra] ? info[:infra][:name] : default_infra
-        err "Infra '#{infra_name}' is not valid" unless client.infra_valid?(infra_name)
-      end
-
-      if not tunnel_pushed?(infra_name)
-        display "Deploying tunnel application '#{tunnel_appname(infra_name)}'."
-        auth = UUIDTools::UUID.random_create.to_s
-        push_caldecott(auth,infra_name)
-        bind_service_banner(service, tunnel_appname(infra_name), false)
-        start_caldecott(infra_name)
-      else
-        auth = tunnel_auth(infra_name)
-      end
-
-      if not tunnel_healthy?(auth,infra_name)
-        display "Redeploying tunnel application '#{tunnel_appname(infra_name)}'."
-
-        # We don't expect caldecott not to be running, so take the
-        # most aggressive restart method.. delete/re-push
-        client.delete_app(tunnel_appname(infra_name))
-        invalidate_tunnel_app_info(infra_name)
-
-        push_caldecott(auth,infra_name)
-        bind_service_banner(service, tunnel_appname(infra_name), false)
-        start_caldecott(infra_name)
-      end
-
-      if not tunnel_bound?(service,infra_name)
-        bind_service_banner(service, tunnel_appname(infra_name))
-      end
-
-      conn_info = tunnel_connection_info info[:vendor], service, auth, infra_name
-      display_tunnel_connection_info(conn_info)
-      display "Starting tunnel to #{service.bold} on port #{port.to_s.bold}."
-      start_tunnel(port, conn_info, auth, infra_name)
-
-      clients = get_clients_for(info[:vendor])
-
-      if clients.empty?
-        client_name ||= "none"
-      else
-        client_name ||= ask(
-          "Which client would you like to start?",
-          :choices => ["none"] + clients.keys,
-          :indexed => true
-        )
-      end
-
-      if client_name == "none"
-        wait_for_tunnel_end
-      else
-        wait_for_tunnel_start(port)
-        unless start_local_prog(clients, client_name, conn_info, port)
-          err "'#{client_name}' execution failed; is it in your $PATH?"
-        end
-      end
-    end
-
-    def get_clients_for(type)
-      conf = VMC::Cli::Config.clients
-      conf[type] || {}
-    end
-  end
-end

data/lib/cli/commands/user.rb

@@ -1,70 +0,0 @@
-module VMC::Cli::Command
-
-  class User < Base
-
-    # Errors
-    class InvalidLogin < VMC::Client::TargetError; end
-
-    def info
-      info = client_info
-      username = info[:user] || 'N/A'
-      return display JSON.pretty_generate([username]) if @options[:json]
-      display "\n[#{username}]"
-    end
-
-    def login(email=nil)
-      display "Attempting login to [#{target_url}]" if target_url
-      begin
-        email    = @options[:email] unless email
-        password = @options[:password]
-        tries ||= 0
-
-        unless no_prompt
-          email ||= ask("Email")
-          password ||= ask("Password", :echo => "*")
-        end
-
-        err "Need a valid email" unless email
-        err "Need a password" unless password
-        login_and_save_token(email, password)
-        say "Successfully logged into [#{target_url}]".green
-      rescue VMC::Client::TargetError
-        if (tries += 1) < 3 && prompt_ok && !@options[:password]
-          display "Problem with login, invalid account or password when attempting to login to '#{target_url}'".red
-          retry
-        end
-        raise InvalidLogin, "Problem with login, invalid account or password when attempting to login to '#{target_url}'"
-      end
-    end
-
-    def logout
-      VMC::Cli::Config.remove_token_file
-      say "Successfully logged out of [#{target_url}]".green
-    end
-
-    def change_password(password=nil)
-      info = client_info
-      email = info[:user]
-      err "Need to be logged in to change password." unless email
-      say "Changing password for '#{email}'\n"
-      unless no_prompt
-        password = ask "New Password", :echo => "*"
-        password2 = ask "Verify Password", :echo => "*"
-        err "Passwords did not match, try again" if password != password2
-      end
-      err "Password required" unless password
-      err "Passwords may not contain braces" if password =~ /[{}]/
-      client.change_password(password)
-      say "\nSuccessfully changed password".green
-    end
-
-    private
-
-    def login_and_save_token(email, password)
-      token = client.login(email, password)
-      VMC::Cli::Config.store_token(token, @options[:token_file])
-    end
-
-  end
-
-end

data/lib/cli/config.rb

@@ -1,176 +0,0 @@
-require "yaml"
-require 'fileutils'
-
-require 'rubygems'
-require 'json/pure'
-
-module VMC::Cli
-  class Config
-
-    DEFAULT_TARGET  = 'api.appfog.com'
-
-    TARGET_FILE    = '~/.af_target'
-    TOKEN_FILE     = '~/.af_token'
-    INSTANCES_FILE = '~/.af_instances'
-    ALIASES_FILE   = '~/.af_aliases'
-    CLIENTS_FILE   = '~/.af_clients'
-    MICRO_FILE     = '~/.af_micro'
-    CRASH_FILE     = '~/.af_crash'
-
-    STOCK_CLIENTS = File.expand_path("../../../config/clients.yml", __FILE__)
-
-    class << self
-      attr_accessor :colorize
-      attr_accessor :output
-      attr_accessor :trace
-      attr_accessor :nozip
-      attr_accessor :infra
-
-      def target_url
-        return @target_url if @target_url
-        target_file = File.expand_path(TARGET_FILE)
-        if File.exists? target_file
-          @target_url = lock_and_read(target_file).strip
-        else
-          @target_url  = DEFAULT_TARGET
-        end
-        @target_url = "https://#{@target_url}" unless /^https?/ =~ @target_url
-        @target_url = @target_url.gsub(/\/+$/, '')
-        @target_url
-      end
-
-      def base_of(url)
-        url.sub(/^[^\.]+\./, "")
-      end
-
-      def store_target(target_host)
-        target_file = File.expand_path(TARGET_FILE)
-        lock_and_write(target_file, target_host)
-      end
-
-      def store_crash(log)
-        crash_file = File.expand_path(CRASH_FILE)
-        lock_and_write(crash_file, log)
-      end
-
-      def all_tokens(token_file_path=nil)
-        token_file = File.expand_path(token_file_path || TOKEN_FILE)
-        return nil unless File.exists? token_file
-        contents = lock_and_read(token_file).strip
-        JSON.parse(contents)
-      end
-
-      alias :targets :all_tokens
-
-      def auth_token(token_file_path=nil)
-        return @token if @token
-        tokens = all_tokens(token_file_path)
-        @token = tokens[target_url] if tokens
-      end
-
-      def remove_token_file
-        FileUtils.rm_f(File.expand_path(TOKEN_FILE))
-      end
-
-      def store_token(token, token_file_path=nil)
-        tokens = all_tokens(token_file_path) || {}
-        tokens[target_url] = token
-        token_file = File.expand_path(token_file_path || TOKEN_FILE)
-        lock_and_write(token_file, tokens.to_json)
-      end
-
-      def instances
-        instances_file = File.expand_path(INSTANCES_FILE)
-        return nil unless File.exists? instances_file
-        contents = lock_and_read(instances_file).strip
-        JSON.parse(contents)
-      end
-
-      def store_instances(instances)
-        instances_file = File.expand_path(INSTANCES_FILE)
-        lock_and_write(instances_file, instances.to_json)
-      end
-
-      def aliases
-        aliases_file = File.expand_path(ALIASES_FILE)
-        # bacward compatible
-        unless File.exists? aliases_file
-          old_aliases_file = File.expand_path('~/.vmc-aliases')
-          FileUtils.mv(old_aliases_file, aliases_file) if File.exists? old_aliases_file
-        end
-        aliases = YAML.load_file(aliases_file) rescue {}
-      end
-
-      def store_aliases(aliases)
-        aliases_file = File.expand_path(ALIASES_FILE)
-        File.open(aliases_file, 'wb') {|f| f.write(aliases.to_yaml)}
-      end
-
-      def micro
-        micro_file = File.expand_path(MICRO_FILE)
-        return {} unless File.exists? micro_file
-        contents = lock_and_read(micro_file).strip
-        JSON.parse(contents)
-      end
-
-      def store_micro(micro)
-        micro_file = File.expand_path(MICRO_FILE)
-        lock_and_write(micro_file, micro.to_json)
-      end
-
-      def deep_merge(a, b)
-        merge = proc do |_, old, new|
-          if new.is_a?(Hash) and old.is_a?(Hash)
-            old.merge(new, &merge)
-          else
-            new
-          end
-        end
-
-        a.merge(b, &merge)
-      end
-
-      def clients
-        return @clients if @clients
-
-        stock = YAML.load_file(STOCK_CLIENTS)
-        clients = File.expand_path CLIENTS_FILE
-        if File.exists? clients
-          user = YAML.load_file(clients)
-          @clients = deep_merge(stock, user)
-        else
-          @clients = stock
-        end
-      end
-
-      def lock_and_read(file)
-        File.open(file, File::RDONLY) {|f|
-          if defined? JRUBY_VERSION
-            f.flock(File::LOCK_SH)
-          else
-            f.flock(File::LOCK_EX)
-          end
-          contents = f.read
-          f.flock(File::LOCK_UN)
-          contents
-        }
-      end
-
-      def lock_and_write(file, contents)
-        File.open(file, File::RDWR | File::CREAT, 0600) {|f|
-          f.flock(File::LOCK_EX)
-          f.rewind
-          f.puts contents
-          f.flush
-          f.truncate(f.pos)
-          f.flock(File::LOCK_UN)
-        }
-      end
-    end
-
-    def initialize(work_dir = Dir.pwd)
-      @work_dir = work_dir
-    end
-
-  end
-end