jdc 0.2.1 → 0.2.2.pre

data/lib/manifests/plugin.rb

@@ -0,0 +1,140 @@
+require "pathname"
+require "jdc/plugin"
+require "manifests/manifests"
+
+class ManifestsPlugin < JDC::App::Base
+  include JDCManifests
+
+  def self.default_to_app_from_manifest(command, fail_without_app)
+    name_made_optional = change_argument(command, :app, :optional)
+    around(command) do |cmd, input|
+      wrap_with_optional_name(name_made_optional, cmd, input, fail_without_app)
+    end
+  end
+
+  option :manifest, :aliases => "-m", :value => :file, :desc => "Path to manifest file to use"
+
+
+  [:start, :restart, :instances, :logs, :env, :health, :stats, :scale, :app, :stop, :delete, :events].each do |command|
+    ::ManifestsPlugin.default_to_app_from_manifest command, true
+  end
+
+  add_input :push, :reset, :desc => "Reset to values in the manifest", :default => false
+
+  around(:push) do |push, input|
+    wrap_push(push, input)
+  end
+
+  private
+
+  def wrap_with_optional_name(name_made_optional, cmd, input, fail_without_app)
+    return cmd.call if input[:all]
+
+    unless manifest
+      # if the command knows how to handle this
+      if input.has?(:app) || !name_made_optional || !fail_without_app
+        return cmd.call
+      else
+        return no_apps
+      end
+    end
+
+    internal, external = apps_in_manifest(input)
+
+    return cmd.call if internal.empty? && !external.empty?
+
+    show_manifest_usage
+
+    if internal.empty? && external.empty?
+      internal = current_apps if internal.empty?
+      internal = all_apps if internal.empty?
+    end
+
+    internal = internal.collect { |app| app[:name] }
+
+    apps = internal + external
+    return no_apps if fail_without_app && apps.empty?
+
+    apps.each.with_index do |app, num|
+      line unless quiet? || num == 0
+      cmd.call(input.without(:apps).merge_given(:app => app))
+    end
+  end
+
+  def apply_changes(app, input)
+    app.memory = megabytes(input[:memory]) if input.has?(:memory)
+    app.total_instances = input[:instances] if input.has?(:instances)
+    app.command = input[:command] if input.has?(:command)
+    app.buildpack = input[:buildpack] if input.has?(:buildpack)
+  end
+
+  def wrap_push(push, input)
+    unless manifest
+      create_and_save_manifest(push, input)
+      return
+    end
+
+    line(c("--path is ignored when using a manifest. Please specify the path in the manifest.", :warning)) if input.has?(:path)
+
+    particular, external = apps_in_manifest(input)
+
+    unless external.empty?
+      fail "Could not find #{b(external.join(", "))}' in the manifest."
+    end
+
+    apps = particular.empty? ? all_apps : particular
+
+    show_manifest_usage
+
+    spaced(apps) do |app_manifest|
+      push_with_manifest(app_manifest, push, input)
+    end
+  end
+
+  def push_with_manifest(app_manifest, push, input)
+    with_filters(
+      :push => {
+        :create_app => proc { |a|
+          setup_env(a, app_manifest)
+          a
+        },
+        :push_app => proc { |a|
+          setup_services(a, app_manifest)
+          a
+        }
+      }) do
+      app_input = push_input_for(app_manifest, input)
+
+      push.call(app_input)
+    end
+  end
+
+  def push_input_for(app_manifest, input)
+    existing_app = client.app_by_name(app_manifest[:name])
+    rebased_input = input.rebase_given(app_manifest)
+
+    if !existing_app || input[:reset]
+      input = rebased_input
+    else
+      warn_reset_changes if manifest_differs?(existing_app, rebased_input)
+    end
+
+    input.merge(
+      :path => from_manifest(app_manifest[:path]),
+      :name => app_manifest[:name],
+      :bind_services => false,
+      :create_services => false)
+  end
+
+  def manifest_differs?(app, input)
+    apply_changes(app, input)
+    app.changed?
+  end
+
+  def create_and_save_manifest(push, input)
+    with_filters(
+        :push => { :push_app => proc { |a| ask_to_save(input, a); a } }) do
+      push.call
+    end
+  end
+end

data/lib/micro/README.md

@@ -0,0 +1,9 @@
+### Info
+This plugin allows you to manage your Micro Jing Dong Foundry VM.
+
+### Usage
+```
+micro-status VMX [PASSWORD]   Display Micro Jing Dong Foundry VM status
+micro-offline VMX [PASSWORD]	Micro Jing Dong Foundry offline mode
+micro-online VMX [PASSWORD] 	Micro Jing Dong Foundry online mode
+```

data/lib/micro/errors.rb

@@ -0,0 +1,4 @@
+module JDCMicro
+  class MCFError < RuntimeError
+  end
+end

data/lib/{jdc → micro}/micro.rb

@@ -1,32 +1,32 @@
 require 'find'
+require "micro/errors"
 
-module JDC::Micro
+module JDCMicro
   def config_file(file)
-    File.join(File.dirname(__FILE__), '..', '..', 'config', 'micro', file)
+    File.expand_path("../../../../config/#{file}", __FILE__)
   end
 
   def escape_path(path)
     path = File.expand_path(path)
     if RUBY_PLATFORM =~ /mingw|mswin32|cygwin/
       if path.include?(' ')
-        return '"' + path + '"'
+        '"' + path + '"'
       else
-        return path
+        path
       end
     else
-      return path.gsub(' ', '\ ')
+      path.gsub(' ', '\ ')
     end
   end
 
   def locate_file(file, directory, search_paths)
     search_paths.each do |path|
       expanded_path = File.expand_path(path)
-      if File.exists?(expanded_path)
-        Find.find(expanded_path) do |current|
-          if File.directory?(current) && current.include?(directory)
-            full_path = File.join(current, file)
-            return self.escape_path(full_path) if File.exists?(full_path)
-          end
+      next unless File.exists?(expanded_path)
+      Find.find(expanded_path) do |current|
+        if File.directory?(current) && current.include?(directory)
+          full_path = File.join(current, file)
+          return escape_path(full_path) if File.exists?(full_path)
         end
       end
     end
@@ -37,14 +37,14 @@ module JDC::Micro
   def run_command(command, args=nil)
     # TODO switch to using posix-spawn instead
     result = %x{#{command} #{args} 2>&1}
-    unless $?.exitstatus == 0
+    if $?.exitstatus == 0
+      result.split(/\n/)
+    else
       if block_given?
         yield
       else
-        raise "failed to execute #{command} #{args}:\n#{result}"
+        raise JDCMicro::MCFError, "failed to execute #{command} #{args}:\n#{result}"
       end
-    else
-      result.split(/\n/)
     end
   end
 

data/lib/micro/plugin.rb

@@ -0,0 +1,197 @@
+require "yaml"
+require "multi_json"
+require "jdc/cli"
+require "micro/micro"
+require "micro/vmrun"
+require "micro/switcher/base"
+require "micro/switcher/darwin"
+require "micro/switcher/linux"
+require "micro/switcher/windows"
+
+module JDCMicro
+  class McfCommand < JDC::CLI
+    MICRO_FILE = '~/.jdc/micro.yml'
+
+    desc "Display Micro Cloud Foundry VM status"
+    input :vmx, :argument => :required,
+      :desc => "Path to micro.vmx"
+    input :password, :argument => :optional,
+      :desc => "Cleartext password for guest VM vcap user"
+    def micro_status
+      mode = runner.offline? ? 'offline' : 'online'
+
+      line "Micro Cloud Foundry VM currently in #{b(mode)} mode"
+      line "VMX Path: #{c(runner.vmx, :good)}"
+      line "Domain: #{c(runner.domain, :good)}"
+      line "IP Address: #{c(runner.ip, :good)}"
+    end
+
+    desc "Micro Cloud Foundry offline mode"
+    input :vmx, :argument => :required,
+      :desc => "Path to micro.vmx"
+    input :password, :argument => :optional,
+      :desc => "Cleartext password for guest VM vcap user"
+    def micro_offline
+      if !runner.nat?
+        if ask("Reconfigure MCF VM network to nat mode and reboot?", :default => true)
+          with_progress("Rebooting MCF VM") do
+            runner.reset_to_nat!
+          end
+        else
+          fail "Aborted"
+        end
+      end
+
+      with_progress("Setting MCF VM to offline mode") do
+        runner.offline!
+      end
+
+      with_progress("Setting host DNS server") do
+        runner.set_host_dns!
+      end
+    end
+
+    desc "Micro Cloud Foundry online mode"
+    input :vmx, :argument => :required,
+      :desc => "Path to micro.vmx"
+    input :password, :argument => :optional,
+      :desc => "Cleartext password for guest VM vcap user"
+    def micro_online
+      runner
+      with_progress("Unsetting host DNS server") do
+        runner.unset_host_dns!
+      end
+
+      with_progress("Setting MCF VM to online mode") do
+        runner.online!
+      end
+    end
+
+    def runner
+      return @runner if @runner
+
+      config = build_config
+      @runner = switcher(config)
+      check_vm_running
+      store_config(config)
+
+      @runner
+    end
+
+    def check_vm_running
+      unless runner.running?
+        if ask("MCF VM is not running. Do you want to start it?", :default => true)
+          with_progress("Starting MCF VM") do
+            runner.start!
+          end
+        else
+          fail "MCF VM needs to be running."
+        end
+      end
+
+      unless runner.ready?
+        fail "MCF VM initial setup needs to be completed before using 'jdc micro'"
+      end
+    end
+
+    def switcher(config)
+      case McfCommand.platform
+      when :darwin
+        JDCMicro::Switcher::Darwin.new(config)
+      when :linux
+        JDCMicro::Switcher::Linux.new(config)
+      when :windows
+        JDCMicro::Switcher::Windows.new(config)
+      when :dummy # for testing only
+        JDCMicro::Switcher::Dummy.new(config)
+      else
+        fail "unsupported platform: #{McfCommand.platform}"
+      end
+    end
+
+    # Returns the configuration needed to run the micro related subcommands.
+    # First loads saved config from file (if there is any), then overrides
+    # loaded values with command line arguments, and finally tries to guess
+    # in case neither was used:
+    #   vmx       location of micro.vmx file
+    #   vmrun     location of vmrun command
+    #   password  password for vcap user (in the guest vm)
+    #   platform  current platform
+    def build_config
+      conf = micro # returns {} if there isn't a saved config
+
+      override(conf, :vmx, true) do
+        locate_vmx(McfCommand.platform)
+      end
+
+      override(conf, :vmrun, true) do
+        JDCMicro::VMrun.locate(McfCommand.platform)
+      end
+
+      override(conf, :password) do
+        ask("Please enter your MCF VM password (vcap user) password", :echo => "*")
+      end
+
+      conf[:platform] = McfCommand.platform
+
+      conf
+    end
+
+    # Save the cleartext password if --save is supplied.
+    # Note: it is due to vix we have to use a cleartext password :(
+    # Only if --password is used and not --save is the password deleted from the
+    # config file before it is stored to disk.
+    def store_config(config)
+      if input[:save]
+        warn("cleartext password saved in: #{MICRO_FILE}")
+      end
+
+      store_micro(config)
+    end
+
+    # override with command line arguments and yield the block in case the option isn't set
+    def override(config, option, escape=false, &blk)
+      # override if given on the command line
+      if opt = input[option]
+        opt = JDCMicro.escape_path(opt) if escape
+        config[option] = opt
+      end
+      config[option] = yield unless config[option]
+    end
+
+    def locate_vmx(platform)
+      paths = YAML.load_file(JDCMicro.config_file('paths.yml'))
+      vmx_paths = paths[platform.to_s]['vmx']
+      vmx = JDCMicro.locate_file('micro.vmx', 'micro', vmx_paths)
+      fail "Unable to locate micro.vmx, please supply --vmx option" unless vmx
+      vmx
+    end
+
+    def self.platform
+      case RUBY_PLATFORM
+      when /darwin/  # x86_64-darwin11.2.0
+        :darwin
+      when /linux/   # x86_64-linux
+        :linux
+      when /mingw|mswin32|cygwin/ # i386-mingw32
+        :windows
+      else
+        RUBY_PLATFORM
+      end
+    end
+
+    def micro
+      micro_file = File.expand_path(MICRO_FILE)
+      return {} unless File.exists? micro_file
+      contents = File.read(micro_file).strip
+      MultiJson.load(contents)
+    end
+
+    def store_micro(micro)
+      micro_file = File.expand_path(MICRO_FILE)
+      File.open(micro_file, 'w') do |file|
+        file.write(MultiJson.dump(micro))
+      end
+    end
+  end
+end

data/lib/micro/switcher/base.rb

@@ -0,0 +1,79 @@
+require "micro/errors"
+
+module JDCMicro::Switcher
+  class Base
+
+    def initialize(config)
+      @config = config
+
+      @vmrun = JDCMicro::VMrun.new(config)
+    end
+
+    #wrapper methods
+    def vmx
+      @vmrun.vmx
+    end
+
+    def domain
+      @vmrun.domain
+    end
+
+    def ip
+      @vmrun.ip
+    end
+
+    def running?
+      @vmrun.running?
+    end
+
+    def start!
+      @vmrun.start!
+    end
+
+    def ready?
+      @vmrun.ready?
+    end
+
+    def offline?
+      @vmrun.offline?
+    end
+
+    def nat?
+      @config['online_connection_type'] ||= @vmrun.connection_type
+      @config["online_connection_type"] == "nat"
+    end
+
+    def reset_to_nat!
+      @vmrun.connection_type = 'nat'
+      @vmrun.reset
+    end
+
+    def set_host_dns!
+      @config['domain'] ||= @vmrun.domain
+      @config['ip'] ||= @vmrun.ip
+      set_nameserver(@config['domain'], @config['ip'])
+    end
+
+    def unset_host_dns!
+      @config['domain'] ||= @vmrun.domain
+      @config['ip'] ||= @vmrun.ip
+      unset_nameserver(@config['domain'], @config['ip'])
+    end
+
+    def offline!
+      if  @vmrun.offline?
+        raise JDCMicro::MCFError, "Micro Cloud Foundry VM already in offline mode"
+      else
+        @vmrun.offline!
+      end
+    end
+
+    def online!
+      if @vmrun.offline?
+        @vmrun.online!
+      else
+        raise JDCMirco::MCFError, "Micro Cloud Foundry already in online mode"
+      end
+    end
+  end
+end