vmc 0.3.15 → 0.3.16.beta.1

data/lib/cli/commands/base.rb

@@ -12,6 +12,8 @@ module VMC::Cli
 
       attr_reader :no_prompt, :prompt_ok
 
+      MANIFEST = "manifest.yml"
+
       def initialize(options={})
         @options = options.dup
         @no_prompt = @options[:noprompts]
@@ -21,6 +23,165 @@ module VMC::Cli
         if WINDOWS
           VMC::Cli::Config.colorize = false
         end
+
+        @path = @options[:path] || '.'
+
+        load_manifest manifest_file if manifest_file
+      end
+
+      def manifest_file
+        return @options[:manifest] if @options[:manifest]
+        return @manifest_file if @manifest_file
+
+        where = File.expand_path(@path)
+        while true
+          if File.exists?(File.join(where, MANIFEST))
+            @manifest_file = File.join(where, MANIFEST)
+            break
+          elsif where == "/"
+            @manifest_file = nil
+            break
+          else
+            where = File.expand_path("../", where)
+          end
+        end
+
+        @manifest_file
+      end
+
+      def load_manifest_structure(file)
+        manifest = YAML.load_file file
+
+        Array(manifest["inherit"]).each do |p|
+          manifest = merge_parent(manifest, p)
+        end
+
+        if apps = manifest["applications"]
+          apps.each do |k, v|
+            abs = File.expand_path(k, file)
+            if Dir.pwd.start_with? abs
+              manifest = merge_manifest(manifest, v)
+            end
+          end
+        end
+
+        manifest
+      end
+
+      def resolve_manifest(manifest)
+        if apps = manifest["applications"]
+          apps.each_value do |v|
+            resolve_lexically(v, [manifest])
+          end
+        end
+
+        resolve_lexically(manifest, [manifest])
+      end
+
+      def load_manifest(file)
+        @manifest = load_manifest_structure(file)
+        resolve_manifest(@manifest)
+      end
+
+      def merge_parent(child, path)
+        file = File.expand_path("../" + path, manifest_file)
+        merge_manifest(child, load_manifest_structure(file))
+      end
+
+      def merge_manifest(child, parent)
+        merge = proc do |_, old, new|
+          if new.is_a?(Hash) and old.is_a?(Hash)
+            old.merge(new, &merge)
+          else
+            new
+          end
+        end
+
+        parent.merge(child, &merge)
+      end
+
+      def resolve_lexically(val, ctx = [@manifest])
+        case val
+        when Hash
+          val.each_value do |v|
+            resolve_lexically(v, [val] + ctx)
+          end
+        when Array
+          val.each do |v|
+            resolve_lexically(v, ctx)
+          end
+        when String
+          val.gsub!(/\$\{([[:alnum:]\-]+)\}/) do
+            resolve_symbol($1, ctx)
+          end
+        end
+
+        nil
+      end
+
+      def resolve_symbol(sym, ctx)
+        case sym
+        when "target-base"
+          target_base(ctx)
+
+        when "target-url"
+          target_url(ctx)
+
+        when "random-word"
+          "%04x" % [rand(0x0100000)]
+
+        else
+          found = find_symbol(sym, ctx)
+
+          if found
+            resolve_lexically(found, ctx)
+            found
+          else
+            err(sym, "Unknown symbol in manifest: ")
+          end
+        end
+      end
+
+      def find_symbol(sym, ctx)
+        ctx.each do |h|
+          if val = resolve_in(h, sym)
+            return val
+          end
+        end
+
+        nil
+      end
+
+      def resolve_in(hash, *where)
+        find_in_hash(hash, ["properties"] + where) ||
+          find_in_hash(hash, ["applications", @application] + where) ||
+          find_in_hash(hash, where)
+      end
+
+      def manifest(*where)
+        resolve_in(@manifest, *where)
+      end
+
+      def find_in_hash(hash, where)
+        what = hash
+        where.each do |x|
+          return nil unless what.is_a?(Hash)
+          what = what[x]
+        end
+
+        what
+      end
+
+      def target_url(ctx = [])
+        find_symbol("target", ctx) || VMC::Cli::Config.target_url
+      end
+
+      def target_base(ctx = [])
+        if tgt = find_symbol("target", ctx)
+          VMC::Cli::Config.base_of(tgt)
+        else
+          VMC::Cli::Config.suggest_url
+        end
       end
 
       # Inject a client to help in testing.
@@ -37,16 +198,8 @@ module VMC::Cli
         @client_info ||= client.info
       end
 
-      def target_url
-        @target_url ||= VMC::Cli::Config.target_url
-      end
-
-      def target_base
-        @target_base ||= VMC::Cli::Config.suggest_url
-      end
-
       def auth_token
-        @auth_token ||= VMC::Cli::Config.auth_token
+        @auth_token = VMC::Cli::Config.auth_token(@options[:token_file])
       end
 
       def runtimes_info

data/lib/cli/commands/manifest.rb

@@ -0,0 +1,56 @@
+module VMC::Cli::Command
+  class Manifest < Base
+    include VMC::Cli::ManifestHelper
+
+    def initialize(options)
+      super
+
+      # don't resolve any of the manifest template stuff
+      if manifest_file
+        @manifest = load_manifest_structure manifest_file
+      else
+        @manifest = {}
+      end
+    end
+
+    def edit
+      build_manifest
+      save_manifest
+    end
+
+    def extend(which)
+      parent = load_manifest_structure which
+      @manifest = load_manifest_structure which
+
+      build_manifest
+
+      simplify(@manifest, parent)
+
+      @manifest["inherit"] ||= []
+      @manifest["inherit"] << which
+
+      save_manifest(ask("Save where?"))
+    end
+
+    private
+
+    def simplify(child, parent)
+      return unless child.is_a?(Hash) and parent.is_a?(Hash)
+
+      child.reject! do |k, v|
+        if v == parent[k]
+          puts "rejecting #{k}"
+          true
+        else
+          simplify(v, parent[k])
+          false
+        end
+      end
+    end
+
+    def build_manifest
+      @application = ask("Configure for which application?", :default => ".")
+      interact true
+    end
+  end
+end

data/lib/cli/commands/services.rb

@@ -1,3 +1,5 @@
+require "uuidtools"
+
 module VMC::Cli::Command
 
   class Services < Base
@@ -112,21 +114,18 @@ module VMC::Cli::Command
 
       err "Unknown service '#{service}'" unless info
 
-      # TODO: rather than default to a particular port, we should get
-      # the defaults based on the service name.. i.e. known services should
-      # have known local default ports for this side of the tunnel.
       port = pick_tunnel_port(@options[:port] || 10000)
 
       raise VMC::Client::AuthError unless client.logged_in?
 
       if not tunnel_pushed?
         display "Deploying tunnel application '#{tunnel_appname}'."
-        auth = ask("Create a password", :echo => "*")
+        auth = UUIDTools::UUID.random_create.to_s
         push_caldecott(auth)
         bind_service_banner(service, tunnel_appname, false)
         start_caldecott
       else
-        auth = ask("Password", :echo => "*")
+        auth = tunnel_auth
       end
 
       if not tunnel_healthy?(auth)
@@ -166,7 +165,7 @@ module VMC::Cli::Command
         wait_for_tunnel_end
       else
         wait_for_tunnel_start(port)
-        unless start_local_prog(clients[client_name], conn_info, port)
+        unless start_local_prog(clients, client_name, conn_info, port)
           err "'#{client_name}' executation failed; is it in your $PATH?"
         end
       end

data/lib/cli/commands/user.rb

@@ -57,7 +57,7 @@ module VMC::Cli::Command
 
     def login_and_save_token(email, password)
       token = client.login(email, password)
-      VMC::Cli::Config.store_token(token)
+      VMC::Cli::Config.store_token(token, @options[:token_file])
     end
 
   end

data/lib/cli/config.rb

@@ -37,6 +37,10 @@ module VMC::Cli
         @target_url
       end
 
+      def base_of(url)
+        url.sub(/^[^\.]+\./, "")
+      end
+
       def suggest_url
         return @suggest_url if @suggest_url
         ha = target_url.split('.')
@@ -51,8 +55,8 @@ module VMC::Cli
         lock_and_write(target_file, target_host)
       end
 
-      def all_tokens
-        token_file = File.expand_path(TOKEN_FILE)
+      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)
@@ -60,9 +64,9 @@ module VMC::Cli
 
       alias :targets :all_tokens
 
-      def auth_token
+      def auth_token(token_file_path=nil)
         return @token if @token
-        tokens = all_tokens
+        tokens = all_tokens(token_file_path)
         @token = tokens[target_url] if tokens
       end
 
@@ -70,10 +74,10 @@ module VMC::Cli
         FileUtils.rm_f(File.expand_path(TOKEN_FILE))
       end
 
-      def store_token(token)
-        tokens = all_tokens || {}
+      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)
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
         lock_and_write(token_file, tokens.to_json)
       end
 
@@ -129,8 +133,12 @@ module VMC::Cli
       end
 
       def lock_and_read(file)
-        File.open(file, "r") {|f|
-          f.flock(File::LOCK_EX)
+        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

data/lib/cli/manifest_helper.rb

@@ -0,0 +1,238 @@
+require "set"
+
+module VMC::Cli::ManifestHelper
+  include VMC::Cli::ServicesHelper
+
+  DEFAULTS = {
+    "url" => "${name}.${target-base}",
+    "mem" => "128M",
+    "instances" => 1
+  }
+
+  MANIFEST = "manifest.yml"
+
+  YES_SET = Set.new(["y", "Y", "yes", "YES"])
+
+  # take a block and call it once for each app to push/update.
+  # with @application and @app_info set appropriately
+  def each_app(panic=true)
+    if @manifest and all_apps = @manifest["applications"]
+      where = File.expand_path(@path)
+      single = false
+
+      all_apps.each do |path, info|
+        app = File.expand_path("../" + path, manifest_file)
+        if where.start_with?(app)
+          @application = app
+          @app_info = info
+          yield info["name"]
+          single = true
+          break
+        end
+      end
+
+      unless single
+        if where == File.expand_path("../", manifest_file)
+          ordered_by_deps(all_apps).each do |path, info|
+            app = File.expand_path("../" + path, manifest_file)
+            @application = app
+            @app_info = info
+            yield info["name"]
+          end
+        else
+          err "Path '#{@path}' is not known to manifest '#{manifest_file}'."
+        end
+      end
+    else
+      @application = @path
+      @app_info = @manifest
+      if @app_info
+        yield @app_info["name"]
+      elsif panic
+        err "No applications."
+      end
+    end
+
+    nil
+  ensure
+    @application = nil
+    @app_info = nil
+  end
+
+  def interact(many=false)
+    @manifest ||= {}
+    configure_app(many)
+  end
+
+  def target_manifest
+    @options[:manifest] || MANIFEST
+  end
+
+  def save_manifest(save_to = nil)
+    save_to ||= target_manifest
+
+    File.open(save_to, "w") do |f|
+      f.write @manifest.to_yaml
+    end
+
+    say "Manifest written to #{save_to}."
+  end
+
+  def configure_app(many=false)
+    name = manifest("name") ||
+      set(ask("Application Name", :default => manifest("name")), "name")
+
+    url_template = manifest("url") || DEFAULTS["url"]
+    url_resolved = url_template.dup
+    resolve_lexically(url_resolved)
+
+    url = ask("Application Deployed URL", :default => url_resolved)
+
+    url = url_template if url == url_resolved
+
+    # common error case is for prompted users to answer y or Y or yes or
+    # YES to this ask() resulting in an unintended URL of y. Special
+    # case this common error
+    url = DEFAULTS["url"] if YES_SET.member? url
+
+    set url, "url"
+
+    unless manifest "framework"
+      framework = detect_framework
+      set framework.name, "framework", "name"
+      set(
+        { "mem" => framework.mem,
+          "description" => framework.description,
+          "exec" => framework.exec
+        },
+        "framework",
+        "info"
+      )
+    end
+
+    set ask(
+      "Memory reservation",
+      :default =>
+        manifest("mem") ||
+          manifest("framework", "info", "mem") ||
+          DEFAULTS["mem"],
+      :choices => ["128M", "256M", "512M", "1G", "2G"]
+    ), "mem"
+
+    set ask(
+      "How many instances?",
+      :default => manifest("instances") || DEFAULTS["instances"]
+    ), "instances"
+
+    unless manifest "services"
+      services = client.services_info
+      unless services.empty?
+        bind = ask "Would you like to bind any services to '#{name}'?", :default => false
+        bind_services(services.values.collect(&:keys).flatten) if bind
+      end
+    end
+
+    if many and ask("Configure for another application?", :default => false)
+      @application = ask "Application path?"
+      configure_app
+    end
+  end
+
+  def set(what, *where)
+    where.unshift "applications", @application
+
+    which = @manifest
+    where.each_with_index do |k, i|
+      if i + 1 == where.size
+        which[k] = what
+      else
+        which = (which[k] ||= {})
+      end
+    end
+
+    what
+  end
+
+  # Detect the appropriate framework.
+  def detect_framework(prompt_ok = true)
+    framework = VMC::Cli::Framework.detect(@application)
+    framework_correct = ask("Detected a #{framework}, is this correct?", :default => true) if prompt_ok && framework
+    if prompt_ok && (framework.nil? || !framework_correct)
+      display "#{"[WARNING]".yellow} Can't determine the Application Type." unless framework
+      framework = nil if !framework_correct
+      framework = VMC::Cli::Framework.lookup(
+        ask(
+          "Select Application Type",
+          :indexed => true,
+          :default => framework,
+          :choices => VMC::Cli::Framework.known_frameworks
+        )
+      )
+      display "Selected #{framework}"
+    end
+
+    framework
+  end
+
+  def bind_services(services)
+    svcs = services.collect(&:to_s).sort!
+
+    display "The following system services are available"
+    configure_service(
+      ask(
+        "Please select the one you wish to provision",
+        :indexed => true,
+        :choices => svcs
+      ).to_sym
+    )
+
+    if ask "Would you like to bind another service?", :default => false
+      bind_services(services)
+    end
+  end
+
+  def configure_service(vendor)
+    default_name = random_service_name(vendor)
+    name = ask "Specify the name of the service", :default => default_name
+
+    set vendor, "services", name, "type"
+  end
+
+  private
+    def ordered_by_deps(apps, abspaths = nil, processed = Set[])
+      unless abspaths
+        abspaths = {}
+        apps.each do |p, i|
+          ep = File.expand_path("../" + p, manifest_file)
+          abspaths[ep] = i
+        end
+      end
+
+      ordered = []
+      apps.each do |path, info|
+        epath = File.expand_path("../" + path, manifest_file)
+
+        if deps = info["depends-on"]
+          dep_apps = {}
+          deps.each do |dep|
+            edep = File.expand_path("../" + dep, manifest_file)
+
+            err "Circular dependency detected." if processed.include? edep
+
+            dep_apps[dep] = abspaths[edep]
+          end
+
+          processed.add(epath)
+
+          ordered += ordered_by_deps(dep_apps, abspaths, processed)
+          ordered << [path, info]
+        elsif not processed.include? epath
+          ordered << [path, info]
+          processed.add(epath)
+        end
+      end
+
+      ordered
+    end
+
+end

data/lib/cli/runner.rb

@@ -31,6 +31,7 @@ class VMC::Cli::Runner
       opts.on('--passwd PASS')     { |pass|  @options[:password] = pass }
       opts.on('--pass PASS')       { |pass|  @options[:password] = pass }
       opts.on('--password PASS')   { |pass|  @options[:password] = pass }
+      opts.on('--token-file TOKEN_FILE')     { |token_file|  @options[:token_file] = token_file }
       opts.on('--app NAME')        { |name|  @options[:name] = name }
       opts.on('--name NAME')       { |name|  @options[:name] = name }
       opts.on('--bind BIND')       { |bind|  @options[:bind] = bind }
@@ -52,6 +53,10 @@ class VMC::Cli::Runner
       opts.on('-d [MODE]')         { |mode|  @options[:debug] = mode || "run" }
       opts.on('--debug [MODE]')    { |mode|  @options[:debug] = mode || "run" }
 
+      # override manifest file
+      opts.on('-m FILE')           { |file|  @options[:manifest] = file }
+      opts.on('--manifest FILE')   { |file|  @options[:manifest] = file }
+
       opts.on('-q', '--quiet')     {         @options[:quiet] = true }
 
       # Don't use builtin zip
@@ -223,15 +228,15 @@ class VMC::Cli::Runner
 
     when 'start'
       usage('vmc start <appname>')
-      set_cmd(:apps, :start, 1)
+      set_cmd(:apps, :start, @args.size == 1 ? 1 : 0)
 
     when 'stop'
       usage('vmc stop <appname>')
-      set_cmd(:apps, :stop, 1)
+      set_cmd(:apps, :stop, @args.size == 1 ? 1 : 0)
 
     when 'restart'
       usage('vmc restart <appname>')
-      set_cmd(:apps, :restart, 1)
+      set_cmd(:apps, :restart, @args.size == 1 ? 1 : 0)
 
     when 'rename'
       usage('vmc rename <appname> <newname>')
@@ -247,7 +252,7 @@ class VMC::Cli::Runner
 
     when 'stats'
       usage('vmc stats <appname>')
-      set_cmd(:apps, :stats, 1)
+      set_cmd(:apps, :stats, @args.size == 1 ? 1 : 0)
 
     when 'map'
       usage('vmc map <appname> <url>')
@@ -278,12 +283,12 @@ class VMC::Cli::Runner
       set_cmd(:apps, :logs, 1)
 
     when 'instances', 'scale'
-      if @args.size == 1
-        usage('vmc instances <appname>')
-        set_cmd(:apps, :instances, 1)
-      else
+      if @args.size > 1
         usage('vmc instances <appname> <num|delta>')
         set_cmd(:apps, :instances, 2)
+      else
+        usage('vmc instances <appname>')
+        set_cmd(:apps, :instances, @args.size == 1 ? 1 : 0)
       end
 
     when 'crashes'
@@ -304,7 +309,7 @@ class VMC::Cli::Runner
 
     when 'update'
       usage('vmc update <appname> [--path PATH]')
-      set_cmd(:apps, :update, 1)
+      set_cmd(:apps, :update, @args.size == 1 ? 1 : 0)
 
     when 'services'
       usage('vmc services')
@@ -389,6 +394,14 @@ class VMC::Cli::Runner
       @args = @args.unshift('--options')
       parse_options!
 
+    when 'manifest'
+      usage('vmc manifest')
+      set_cmd(:manifest, :edit)
+
+    when 'extend-manifest'
+      usage('vmc extend-manifest')
+      set_cmd(:manifest, :extend, 1)
+
     else
       if verb
         display "vmc: Unknown command [#{verb}]"
@@ -437,7 +450,8 @@ class VMC::Cli::Runner
     parse_command!
 
     if @namespace && @action
-      eval("VMC::Cli::Command::#{@namespace.to_s.capitalize}").new(@options).send(@action.to_sym, *@args)
+      cmd = VMC::Cli::Command.const_get(@namespace.to_s.capitalize)
+      cmd.new(@options).send(@action, *@args.collect(&:dup))
     elsif @help_only || @usage
       display_usage
     else