jdc 0.2.1.pre → 0.2.1

data/lib/manifests/manifests.rb

@@ -1,344 +0,0 @@
-require "yaml"
-require "set"
-require "jdc/cli/service/create"
-
-require "manifests/loader"
-
-module JDCManifests
-  MANIFEST_FILE = "manifest.yml"
-
-  @@showed_manifest_usage = false
-  @@manifest = nil
-
-  def manifest
-    return @@manifest if @@manifest
-
-    if manifest_file && File.exists?(manifest_file)
-      @@manifest = load_manifest(manifest_file)
-    end
-  end
-
-  def save_manifest(save_to = manifest_file)
-    fail "No manifest to save!" unless @@manifest
-
-    File.open(save_to, "w") do |io|
-      YAML.dump(@@manifest, io)
-    end
-  end
-
-  # find the manifest file to work with
-  def manifest_file
-    return @manifest_file if @manifest_file
-
-    unless path = input[:manifest]
-      where = Dir.pwd
-      while true
-        if File.exists?(File.join(where, MANIFEST_FILE))
-          path = File.join(where, MANIFEST_FILE)
-          break
-        elsif File.basename(where) == "/"
-          path = nil
-          break
-        else
-          where = File.expand_path("../", where)
-        end
-      end
-    end
-
-    return unless path
-
-    @manifest_file = File.expand_path(path)
-  end
-
-  # load and resolve a given manifest file
-  def load_manifest(file)
-    check_manifest! Loader.new(file, self).manifest
-  end
-
-  def check_manifest!(manifest_hash, output = $stdout)
-    manifest_hash[:applications].each{ |app| check_attributes!(app, output) }
-    manifest_hash
-  end
-
-  def check_attributes!(app, output = $stdout)
-    app.each do |k, v|
-      output.puts error_message_for_attribute(k) unless known_manifest_attributes.include? k
-    end
-  end
-
-  def error_message_for_attribute(attribute)
-    "\e[31mWarning: #{attribute} is not a valid manifest attribute. Please " +
-    "remove this attribute from your manifest to get rid of this warning\e[0m"
-  end
-
-  def known_manifest_attributes
-    [:applications, :buildpack, :command, :disk, :domain, :env,
-     :host, :inherit, :instances, :mem, :memory, :name,
-     :path, :properties, :runtime, :services, :stack]
-  end
-
-  # dynamic symbol resolution
-  def resolve_symbol(sym)
-    case sym
-    when "target-url"
-      client_target
-
-    when "target-base"
-      target_base
-
-    when "random-word"
-      sprintf("%04x", rand(0x0100000))
-
-    when /^ask (.+)/
-      ask($1)
-    end
-  end
-
-  # find apps by an identifier, which may be either a tag, a name, or a path
-  def find_apps(identifier)
-    return [] unless manifest
-
-    apps = apps_by(:name, identifier)
-
-    if apps.empty?
-      apps = apps_by(:path, from_manifest(identifier))
-    end
-
-    apps
-  end
-
-  # return all the apps described by the manifest
-  def all_apps
-    manifest[:applications]
-  end
-
-  def current_apps
-    manifest[:applications].select do |app|
-      next unless app[:path]
-      from_manifest(app[:path]) == Dir.pwd
-    end
-  end
-
-  # splits the user's input, resolving paths with the manifest,
-  # into internal/external apps
-  #
-  # internal apps are returned as their data in the manifest
-  #
-  # external apps are the strings that the user gave, to be
-  # passed along wholesale to the wrapped command
-  def apps_in_manifest(input = nil, use_name = true, &blk)
-    names_or_paths =
-      if input.has?(:apps)
-        # names may be given but be [], which will still cause
-        # interaction, so use #direct instead of #[] here
-        input.direct(:apps)
-      elsif input.has?(:app)
-        [input.direct(:app)]
-      elsif input.has?(:name)
-        [input.direct(:name)]
-      else
-        []
-      end
-
-    internal = []
-    external = []
-
-    names_or_paths.each do |x|
-      if x.is_a?(String)
-        if x =~ %r([/\\])
-          apps = find_apps(File.expand_path(x))
-
-          if apps.empty?
-            fail("Path #{b(x)} is not present in manifest #{b(relative_manifest_file)}.")
-          end
-        else
-          apps = find_apps(x)
-        end
-
-        if !apps.empty?
-          internal += apps
-        else
-          external << x
-        end
-      else
-        external << x
-      end
-    end
-
-    [internal, external]
-  end
-
-  def create_manifest_for(app, path)
-    meta = {
-      "name" => app.name,
-      "memory" => human_size(app.memory * 1024 * 1024, 0),
-      "instances" => app.total_instances,
-      "host" => app.host || "none",
-      "domain" => app.domain ? app.domain : "none",
-      "path" => path
-    }
-
-    services = app.services
-
-    unless services.empty?
-      meta["services"] = {}
-
-      services.each do |service_instance|
-        if service_instance.is_a?(JFoundry::V2::UserProvidedServiceInstance)
-          meta["services"][service_instance.name] = {
-            "label" => "user-provided",
-            "credentials" => service_instance.credentials.stringify_keys,
-          }
-        else
-          service_plan = service_instance.service_plan
-          service = service_plan.service
-
-          meta["services"][service_instance.name] = {
-            "label" => service.label,
-            "provider" => service.provider,
-            "version" => service.version,
-            "plan" => service_plan.name
-          }
-        end
-      end
-    end
-
-    if cmd = app.command
-      meta["command"] = cmd
-    end
-
-    if buildpack = app.buildpack
-      meta["buildpack"] = buildpack
-    end
-
-    meta
-  end
-
-  private
-
-  def relative_manifest_file
-    Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
-  end
-
-  def show_manifest_usage
-    return if @@showed_manifest_usage
-
-    path = relative_manifest_file
-    line "Using manifest file #{c(path, :name)}"
-    line
-
-    @@showed_manifest_usage = true
-  end
-
-  def no_apps
-    fail "No applications or manifest to operate on."
-  end
-
-  def warn_reset_changes
-    line c("Not applying manifest changes without --reset", :warning)
-    line "See `jdc diff` for more details."
-    line
-  end
-
-  def apps_by(attr, val)
-    manifest[:applications].select do |info|
-      info[attr] == val
-    end
-  end
-
-  # expand a path relative to the manifest file's directory
-  def from_manifest(path)
-    File.expand_path(path, File.dirname(manifest_file))
-  end
-
-
-  def ask_to_save(input, app)
-    return if manifest_file
-    return unless ask("Save configuration?", :default => false)
-
-    manifest = create_manifest_for(app, input[:path])
-
-    with_progress("Saving to #{c("manifest.yml", :name)}") do
-      File.open("manifest.yml", "w") do |io|
-        YAML.dump(
-          { "applications" => [manifest] },
-          io)
-      end
-    end
-  end
-
-  def env_hash(val)
-    if val.is_a?(Hash)
-      val
-    else
-      hash = {}
-
-      val.each do |pair|
-        name, val = pair.split("=", 2)
-        hash[name] = val
-      end
-
-      hash
-    end
-  end
-
-  def setup_env(app, info)
-    return unless info[:env]
-    app.env = env_hash(info[:env])
-  end
-
-  def setup_services(app, info)
-    return if !info[:services] || info[:services].empty?
-
-    offerings = client.services
-
-    to_bind = []
-
-    info[:services].each do |name, svc|
-      name = name.to_s
-
-      if instance = client.service_instance_by_name(name)
-        to_bind << instance
-      else
-        if svc[:label] == "user-provided"
-          invoke :create_service,
-            name: name,
-            offering: JDC::Service::UPDummy.new,
-            app: app,
-            credentials: svc[:credentials]
-        else
-          offering = offerings.find { |o|
-            o.label == (svc[:label] || svc[:type] || svc[:vendor]) &&
-              (!svc[:version] || o.version == svc[:version]) &&
-              (o.provider == (svc[:provider] || "core"))
-          }
-
-          fail "Unknown service offering: #{svc.inspect}." unless offering
-
-          plan = offering.service_plans.find { |p|
-            p.name == (svc[:plan] || "D100")
-          }
-
-          fail "Unknown service plan: #{svc[:plan]}." unless plan
-
-          invoke :create_service,
-            :name => name,
-            :offering => offering,
-            :plan => plan,
-            :app => app
-        end
-      end
-    end
-
-    to_bind.each do |s|
-      next if app.binds?(s)
-
-      # TODO: splat
-      invoke :bind_service, :app => app, :service => s
-    end
-  end
-
-  def target_base
-    client_target.sub(/^[^\.]+\./, "")
-  end
-end

data/lib/manifests/plugin.rb

@@ -1,140 +0,0 @@
-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

@@ -1,9 +0,0 @@
-### 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

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

data/lib/micro/plugin.rb

@@ -1,197 +0,0 @@
-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