vmc 0.4.0.beta.93 → 0.4.0.beta.94

data/vmc-ng/lib/vmc/cli/app/deprecated.rb

@@ -0,0 +1,11 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Deprecated < Base
+    desc "DEPRECATED. Use 'push' instead."
+    input :app, :argument => :optional
+    def update
+      fail "The 'update' command is no longer needed; use 'push' instead."
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app/env.rb

@@ -0,0 +1,86 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Env < Base
+    VALID_ENV_VAR = /^[a-zA-Za-z_][[:alnum:]_]*$/
+
+    desc "Show all environment variables set for an app"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to inspect the environment of",
+      :from_given => by_name("app")
+    def env
+      app = input[:app]
+
+      vars =
+        with_progress("Getting env for #{c(app.name, :name)}") do |s|
+          app.env
+        end
+
+      line unless quiet?
+
+      vars.each do |name, val|
+        line "#{c(name, :name)}: #{val}"
+      end
+    end
+
+    desc "Set an environment variable"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to set the variable for",
+      :from_given => by_name("app")
+    input :name, :argument => true,
+      :desc => "Environment variable name"
+    input :value, :argument => :optional,
+      :desc => "Environment variable value"
+    input :restart, :type => :boolean, :default => true,
+      :desc => "Restart app after updating?"
+    def set_env
+      app = input[:app]
+      name = input[:name]
+
+      if value = input[:value]
+        name = input[:name]
+      elsif name["="]
+        name, value = name.split("=")
+      end
+
+      unless name =~ VALID_ENV_VAR
+        fail "Invalid variable name; must match #{VALID_ENV_VAR.inspect}"
+      end
+
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.env[name] = value
+        app.update!
+      end
+
+      if app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+
+
+    desc "Remove an environment variable"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to set the variable for",
+      :from_given => by_name("app")
+    input :name, :argument => true,
+      :desc => "Environment variable name"
+    input :restart, :type => :boolean, :default => true,
+      :desc => "Restart app after updating?"
+    def unset_env
+      app = input[:app]
+      name = input[:name]
+
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.env.delete(name)
+        app.update!
+      end
+
+      if app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app/files.rb

@@ -0,0 +1,85 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Files < Base
+    desc "Print out an app's file contents"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to inspect the files of",
+      :from_given => by_name("app")
+    input :path, :argument => true, :default => "/",
+      :desc => "Path of file to read"
+    def file
+      app = input[:app]
+      path = input[:path]
+
+      file =
+        with_progress("Getting file contents") do
+          app.file(*path.split("/"))
+        end
+
+      if quiet?
+        print file
+      else
+        line
+
+        file.split("\n").each do |l|
+          line l
+        end
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Examine an app's files"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to inspect the files of",
+      :from_given => by_name("app")
+    input :path, :argument => :optional, :default => "/",
+      :desc => "Path of directory to list"
+    def files
+      app = input[:app]
+      path = input[:path]
+
+      if quiet?
+        files =
+          with_progress("Getting file listing") do
+            app.files(*path.split("/"))
+          end
+
+        files.each do |file|
+          line file.join("/")
+        end
+      else
+        invoke :file, :app => app, :path => path
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Stream an app's file contents"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to inspect the file of",
+      :from_given => by_name("app")
+    input :path, :argument => true, :default => "/",
+      :desc => "Path of file to stream"
+    def tail
+      app = input[:app]
+      path = input[:path]
+
+      app.stream_file(*path.split("/")) do |contents|
+        print contents
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app/health.rb

@@ -0,0 +1,27 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Health < Base
+    desc "Get application health"
+    group :apps, :info, :hidden => true
+    input :apps, :argument => :splat, :singular => :app,
+      :desc => "Applications to start",
+      :from_given => by_name("app")
+    def health
+      apps = input[:apps]
+      fail "No applications given." if apps.empty?
+
+      health =
+        with_progress("Getting health status") do
+          apps.collect { |a| [a, app_status(a)] }
+        end
+
+      line unless quiet?
+
+      spaced(health) do |app, status|
+        start_line "#{c(app.name, :name)}: " unless quiet?
+        puts status
+      end
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app/instances.rb

@@ -0,0 +1,49 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Instances < Base
+    desc "List an app's instances"
+    group :apps, :info, :hidden => true
+    input :apps, :argument => :splat, :singular => :app,
+      :desc => "Applications whose instances to list",
+      :from_given => by_name("app")
+    def instances
+      apps = input[:apps]
+      fail "No applications given." if apps.empty?
+
+      spaced(apps) do |app|
+        instances =
+          with_progress("Getting instances for #{c(app.name, :name)}") do
+            app.instances
+          end
+
+        spaced(instances) do |i|
+          if quiet?
+            line i.id
+          else
+            display_instance(i)
+          end
+        end
+      end
+    end
+
+    def display_instance(i)
+      start_line "instance #{c("\##{i.id}", :instance)}: "
+      puts "#{b(c(i.state.downcase, state_color(i.state)))} "
+
+      indented do
+        if s = i.since
+          line "started: #{c(s.strftime("%F %r"), :neutral)}"
+        end
+
+        if d = i.debugger
+          line "debugger: port #{b(d[:port])} at #{b(d[:ip])}"
+        end
+
+        if c = i.console
+          line "console: port #{b(c[:port])} at #{b(c[:ip])}"
+        end
+      end
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app/logs.rb

@@ -0,0 +1,80 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Logs < Base
+    desc "Print out an app's logs"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to get the logs of",
+      :from_given => by_name("app")
+    input :instance, :default => "0",
+      :desc => "Instance of application to get the logs of"
+    input :all, :type => :boolean, :default => false,
+      :desc => "Get logs for every instance"
+    def logs
+      app = input[:app]
+
+      instances =
+        if input[:all] || input[:instance] == "all"
+          app.instances
+        else
+          app.instances.select { |i| i.id == input[:instance] }
+        end
+
+      if instances.empty?
+        if input[:all]
+          fail "No instances found."
+        else
+          fail "Instance #{app.name} \##{input[:instance]} not found."
+        end
+      end
+
+      spaced(instances) do |i|
+        show_instance_logs(app, i)
+      end
+    end
+
+    desc "Print out the logs for an app's crashed instances"
+    group :apps, :info, :hidden => true
+    input :app, :argument => true,
+      :desc => "Application to get the logs of",
+      :from_given => by_name("app")
+    def crashlogs
+      app = input[:app]
+
+      crashes = app.crashes
+
+      fail "No crashed instances found." if crashes.empty?
+
+      spaced(crashes) do |i|
+        show_instance_logs(app, i)
+      end
+    end
+
+    def show_instance_logs(app, i)
+      return unless i.id
+
+      logs =
+        with_progress(
+            "Getting logs for #{c(app.name, :name)} " +
+              c("\##{i.id}", :instance)) do
+          i.files("logs")
+        end
+
+      line unless quiet?
+
+      spaced(logs) do |log|
+        begin
+          body =
+            with_progress("Reading " + b(log.join("/"))) do |s|
+              i.file(*log)
+            end
+
+          lines body
+          line unless body.empty?
+        rescue CFoundry::NotFound
+        end
+      end
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app/push.rb

@@ -0,0 +1,336 @@
+require "vmc/detect"
+
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Push < Base
+    desc "Push an application, syncing changes if it exists"
+    group :apps, :manage
+    input(:name, :argument => true, :desc => "Application name") {
+      ask("Name")
+    }
+    input :path, :default => ".",
+      :desc => "Path containing the application"
+    input(:url, :desc => "URL bound to app") { |name|
+      choices = url_choices(name)
+
+      options = {
+        :choices => choices + ["none"],
+        :allow_other => true
+      }
+
+      options[:default] = choices.first if choices.size == 1
+
+      url = ask "URL", options
+
+      unless url == "none"
+        url
+      end
+    }
+    input(:memory, :desc => "Memory limit") { |default|
+      ask("Memory Limit",
+          :choices => memory_choices,
+          :allow_other => true,
+          :default => default || "64M")
+    }
+    input(:instances, :type => :integer,
+          :desc => "Number of instances to run") {
+      ask("Instances", :default => 1)
+    }
+    input(:framework, :from_given => find_by_name("framework"),
+          :desc => "Framework to use") { |all, choices, default, other|
+      ask_with_other("Framework", all, choices, default, other)
+    }
+    input(:runtime, :from_given => find_by_name("runtime"),
+          :desc => "Runtime to use") { |all, choices, default, other|
+      ask_with_other("Runtime", all, choices, default, other)
+    }
+    input(:command, :desc => "Startup command for standalone app") {
+      ask("Startup command")
+    }
+    input :plan, :default => "D100",
+      :desc => "Application plan (e.g. D100, P200)"
+    input :start, :type => :boolean, :default => true,
+      :desc => "Start app after pushing?"
+    input :restart, :type => :boolean, :default => true,
+      :desc => "Restart app after updating?"
+    input(:create_services, :type => :boolean,
+          :desc => "Interactively create services?") {
+      line unless quiet?
+      ask "Create services for application?", :default => false
+    }
+    input(:bind_services, :type => :boolean,
+          :desc => "Interactively bind services?") {
+      ask "Bind other services to application?", :default => false
+    }
+    def push
+      name = input[:name]
+      path = File.expand_path(input[:path])
+
+      if app = client.app_by_name(name)
+        sync_app(app, path)
+      else
+        create_app(name, path)
+      end
+    end
+
+    def sync_app(app, path)
+      upload_app(app, path)
+
+      diff = {}
+
+      if input.given?(:memory)
+        mem = megabytes(input[:memory])
+
+        if mem != app.memory
+          diff[:memory] = [app.memory, mem]
+          app.memory = mem
+        end
+      end
+
+      if input.given?(:instances)
+        instances = input[:instances]
+
+        if instances != app.total_instances
+          diff[:instances] = [app.total_instances, instances]
+          app.total_instances = instances
+        end
+      end
+
+      if input.given?(:framework)
+        all_frameworks = client.frameworks
+
+        framework = input[:framework, all_frameworks, all_frameworks]
+
+        if framework != app.framework
+          diff[:framework] = [app.framework.name, framework.name]
+          app.framework = framework
+        end
+      end
+
+      if input.given?(:runtime)
+        all_runtimes = client.runtimes
+
+        runtime = input[:runtime, all_runtimes, all_runtimes]
+
+        if runtime != app.runtime
+          diff[:runtime] = [app.runtime.name, runtime.name]
+          app.runtime = runtime
+        end
+      end
+
+      if input.given?(:command) && input[:command] != app.command
+        command = input[:command]
+
+        if command != app.command
+          diff[:command] = [app.command, command]
+          app.command = command
+        end
+      end
+
+      if input.given?(:plan) && v2?
+        production = !!(input[:plan] =~ /^p/i)
+
+        if production != app.production
+          diff[:production] = [bool(app.production), bool(production)]
+          app.production = production
+        end
+      end
+
+      unless diff.empty?
+        line "Changes:"
+
+        indented do
+          diff.each do |name, change|
+            old, new = change
+            line "#{c(name, :name)}: #{old} #{c("->", :dim)} #{new}"
+          end
+        end
+
+        with_progress("Updating #{c(app.name, :name)}") do
+          app.update!
+        end
+      end
+
+      if input[:restart] && app.started?
+        invoke :restart, :app => app
+      end
+    end
+
+    def create_app(name, path)
+      app = client.app
+      app.name = name
+      app.space = client.current_space if client.current_space
+      app.total_instances = input[:instances]
+      app.production = !!(input[:plan] =~ /^p/i) if v2?
+
+      detector = VMC::Detector.new(client, path)
+      all_frameworks = detector.all_frameworks
+      all_runtimes = detector.all_runtimes
+
+      if detected_framework = detector.detect_framework
+        framework = input[
+          :framework,
+          all_frameworks,
+          [detected_framework],
+          detected_framework,
+          :other
+        ]
+      else
+        framework = input[:framework, all_frameworks, all_frameworks]
+      end
+
+
+      if framework.name == "standalone"
+        detected_runtimes = detector.detect_runtimes
+      else
+        detected_runtimes = detector.runtimes(framework)
+      end
+
+      if detected_runtimes.size == 1
+        default_runtime = detected_runtimes.first
+      end
+
+      if detected_runtimes.empty?
+        runtime = input[:runtime, all_runtimes, all_runtimes]
+      else
+        runtime = input[
+          :runtime,
+          all_runtimes,
+          detected_runtimes,
+          default_runtime,
+          :other
+        ]
+      end
+
+
+      fail "Invalid framework '#{input[:framework]}'" unless framework
+      fail "Invalid runtime '#{input[:runtime]}'" unless runtime
+
+      app.framework = framework
+      app.runtime = runtime
+
+      app.command = input[:command] if framework.name == "standalone"
+
+      default_memory = detector.suggested_memory(framework) || 64
+      app.memory = megabytes(input[:memory, human_mb(default_memory)])
+
+      app = filter(:create_app, app)
+
+      with_progress("Creating #{c(app.name, :name)}") do
+        app.create!
+      end
+
+      line unless quiet?
+
+      url = input[:url, name]
+
+      mapped_url = false
+      until !url || mapped_url
+        begin
+          invoke :map, :app => app, :url => url
+          mapped_url = true
+        rescue CFoundry::RouteHostTaken, CFoundry::UriAlreadyTaken => e
+          line c(e.description, :bad)
+          line
+
+          input.forget(:url)
+          url = input[:url, name]
+
+          # version bumps on v1 even though mapping fails
+          app.invalidate! unless v2?
+        end
+      end
+
+      bindings = []
+
+      if input[:create_services] && !force?
+        while true
+          invoke :create_service, { :app => app }, :plan => :interact
+          break unless ask "Create another service?", :default => false
+        end
+      end
+
+      if input[:bind_services] && !force?
+        instances = client.service_instances
+
+        while true
+          invoke :bind_service, :app => app
+
+          break if (instances - app.services).empty?
+
+          break unless ask("Bind another service?", :default => false)
+        end
+      end
+
+      app = filter(:push_app, app)
+
+      begin
+        upload_app(app, path)
+      rescue
+        err "Upload failed. Try again with 'vmc push'."
+        raise
+      end
+
+      invoke :start, :app => app if input[:start]
+    end
+
+    private
+
+    def upload_app(app, path)
+      with_progress("Uploading #{c(app.name, :name)}") do
+        app.upload(path)
+      end
+    end
+
+    def bool(b)
+      if b
+        c("true", :yes)
+      else
+        c("false", :no)
+      end
+    end
+
+    def url_choices(name)
+      if v2?
+        client.current_space.domains.sort_by(&:name).collect do |d|
+          # TODO: check availability
+          "#{name}.#{d.name}"
+        end
+      else
+        ["#{name}.#{target_base}"]
+      end
+    end
+
+    def target_base
+      client.target.sub(/^https?:\/\/([^\.]+\.)?(.+)\/?/, '\2')
+    end
+
+    def ask_with_other(message, all, choices, default, other)
+      choices = choices.sort_by(&:name)
+      choices << other if other
+
+      opts = {
+        :choices => choices,
+        :display => proc { |x|
+          if other && x == other
+            "other"
+          else
+            x.name
+          end
+        }
+      }
+
+      opts[:default] = default if default
+
+      res = ask(message, opts)
+
+      if other && res == other
+        opts[:choices] = all
+        res = ask(message, opts)
+      end
+
+      res
+    end
+  end
+end