jdc 0.1.2 → 0.2.0

data/lib/manifests/manifests.rb

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

@@ -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