cloulu 0.0.0 → 0.1.1

data/lib/manifests-vmc-plugin.rb

@@ -0,0 +1,313 @@
+require "yaml"
+require "set"
+
+require "manifests-vmc-plugin/loader"
+
+
+module VMCManifests
+  MANIFEST_FILE = "manifest.yml"
+
+  @@showed_manifest_usage = false
+
+  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)
+    Loader.new(file, self).manifest
+  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,
+      "framework" => app.framework.name,
+      "runtime" => app.runtime.name,
+      "memory" => human_size(app.memory * 1024 * 1024, 0),
+      "instances" => app.total_instances,
+      "url" => app.url ? app.url.sub(target_base, '${target-base}') : "none",
+      "path" => path
+    }
+
+    services = app.services
+
+    unless services.empty?
+      meta["services"] = {}
+
+      services.each do |i|
+        if v2?
+          p = i.service_plan
+          s = p.service
+
+          meta["services"][i.name] = {
+            "label" => s.label,
+            "provider" => s.provider,
+            "version" => s.version,
+            "plan" => p.name
+          }
+        else
+          meta["services"][i.name] = {
+            "vendor" => i.vendor,
+            "version" => i.version,
+            "tier" => i.tier
+          }
+        end
+      end
+    end
+
+    if cmd = app.command
+      meta["command"] = cmd
+    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 `vmc 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
+        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
+
+        if v2?
+          plan = offering.service_plans.find { |p|
+            p.name == (svc[:plan] || "D100")
+          }
+
+          fail "Unknown service plan: #{svc[:plan]}." unless plan
+        end
+
+        invoke :create_service,
+          :name => name,
+          :offering => offering,
+          :plan => plan,
+          :app => app
+      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/mothership/base.rb

@@ -0,0 +1,99 @@
+require "mothership/command"
+require "mothership/inputs"
+
+class Mothership
+  # all commands
+  @@commands = {}
+
+  attr_accessor :input
+
+  # Initialize with the command being executed.
+  def initialize(command = nil, input = nil)
+    @command = command
+    @input = input
+  end
+
+  class << self
+    # all of the defined commands
+    def commands
+      @@commands
+    end
+
+    # start defining a new command with the given description
+    def desc(description)
+      @command = Command.new(self, description)
+    end
+
+    # define an input for the current command or the global command
+    def input(name, options = {}, &interact)
+      raise "no current command" unless @command
+
+      @command.add_input(name, options, &interact)
+    end
+
+    # specify a module that defines interactions for each input
+    def interactions(mod)
+      @command.interactions = mod
+    end
+
+    # register a command
+    def method_added(name)
+      return unless @command
+
+      @command.name = name
+      @@commands[name] = @command
+
+      @command = nil
+    end
+
+    def alias_command(new, orig = nil)
+      @@commands[new] = orig ? @@commands[orig] : @command
+    end
+  end
+
+  def execute(cmd, argv, global = {})
+    cmd.invoke({}, Parser.new(cmd).parse_argv(argv), global)
+  rescue Mothership::Error => e
+    $stderr.puts e
+    $stderr.puts ""
+    Mothership::Help.command_usage(cmd, $stderr)
+
+    exit_status 1
+  end
+
+  # wrap this with your error handling/etc.
+  def run(name)
+    send(name)
+  end
+
+  # invoke a command with inputs
+  def invoke(
+      name, inputs = {}, given = {}, global = @input ? @input.global : {})
+    if cmd = @@commands[name]
+      cmd.invoke(inputs, given, global)
+    else
+      unknown_command(name)
+    end
+  end
+
+  # explicitly perform the interaction of an input
+  #
+  # if no input specified, assume current input and reuse the arguments
+  #
+  # example:
+  #   input(:foo, :default => proc { |foos|
+  #           foos.find { |f| f.name == "XYZ" } ||
+  #             interact
+  #         }) { |foos|
+  #     ask("Foo?", :choices => foos, :display => proc(&:name))
+  #   }
+  def interact(input = nil, *args)
+    unless input
+      input, args = @input.current_input
+    end
+
+    raise "no active input" unless input
+
+    @input.interact(input, self, *args)
+  end
+end

data/lib/mothership/callbacks.rb

@@ -0,0 +1,85 @@
+class Mothership
+  # temporary filters via #with_filters
+  #
+  # command => { tag => [callbacks] }
+  @@filters = Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = [] } }
+
+  class << self
+    # register a callback that's evaluated before a command is run
+    def before(name, &callback)
+      @@commands[name].before << [callback, self]
+    end
+
+    # register a callback that's evaluated after a command is run
+    def after(name, &callback)
+      @@commands[name].after << [callback, self]
+    end
+
+    # register a callback that's evaluated around a command, controlling its
+    # evaluation (i.e. inputs)
+    def around(name, &callback)
+      @@commands[name].around << [callback, self]
+    end
+
+    # register a callback that's evaluated when a command uses the given
+    # filter
+    def filter(name, tag, &callback)
+      @@commands[name].filters[tag] << [callback, self]
+    end
+
+    # change an argument's status, i.e. optional, splat, or required
+    def change_argument(name, arg, to)
+      changed = false
+
+      @@commands[name].arguments.each do |a|
+        if a[:name] == arg
+          a[:type] = to
+          changed = true
+        end
+      end
+
+      changed
+    end
+
+    # add an input/flag to a command
+    def add_input(cmd, name, options = {}, &interact)
+      @@commands[cmd].add_input(name, options, &interact)
+    end
+  end
+
+  # filter a value through any plugins
+  def filter(tag, val)
+    if @@filters.key?(@command.name) &&
+         @@filters[@command.name].key?(tag)
+      @@filters[@command.name][tag].each do |f, ctx|
+        val = ctx.instance_exec(val, &f)
+      end
+    end
+
+    @command.filters[tag].each do |f, c|
+      val = c.new.instance_exec(val, &f)
+    end
+
+    val
+  end
+
+  # temporary dynamically-scoped filters
+  def with_filters(filters)
+    filters.each do |cmd, callbacks|
+      callbacks.each do |tag, callback|
+        @@filters[cmd][tag] << [callback, self]
+      end
+    end
+
+    yield
+  ensure
+    filters.each do |cmd, callbacks|
+      callbacks.each do |tag, callback|
+        @@filters[cmd][tag].pop
+        @@filters[cmd].delete(tag) if @@filters[cmd][tag].empty?
+      end
+
+      @@filters.delete(cmd) if @@filters[cmd].empty?
+    end
+  end
+end

data/lib/mothership/command.rb

@@ -0,0 +1,146 @@
+require "mothership/inputs"
+
+class Mothership
+  class Command
+    attr_accessor :name, :description, :interactions
+
+    attr_reader :context, :inputs, :arguments, :flags
+
+    attr_reader :before, :after, :around, :filters
+
+    def initialize(context, description = nil)
+      @context = context
+      @description = description
+      @aliases = []
+
+      # inputs accepted by command
+      @inputs = {}
+
+      # inputs that act as arguments
+      @arguments = []
+
+      # flag -> input (e.g. --name -> :name)
+      @flags = {}
+
+      # various callbacks
+      @before = []
+      @after = []
+      @around = []
+      @filters = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def inspect
+      "\#<Command '#{@name}'>"
+    end
+
+    def display_name
+      @name.to_s.gsub("_", "-")
+    end
+
+    def usage
+      args = [display_name]
+      @arguments.each do |a|
+        name = (a[:value] || a[:name]).to_s.upcase
+        input = @inputs[a[:name]]
+
+        if a[:type] == :splat
+          args << "#{name}..."
+        elsif a[:type] == :optional || input.key?(:default) || \
+                input.key?(:interact)
+          args << "[#{name}]"
+        else
+          args << name
+        end
+      end
+
+      args.join(" ")
+    end
+
+    def invoke(inputs = {}, given = {}, global = {})
+      @before.each { |f, c| c.new.instance_exec(&f) }
+
+      name = @name
+
+      ctx = @context.new(self)
+      ctx.extend @interactions if @interactions
+
+      ctx.input = Inputs.new(self, ctx, inputs, given, global)
+
+
+      action = proc do |*given_inputs|
+        ctx.input = given_inputs.first || ctx.input
+        ctx.run(name)
+      end
+
+      cmd = self
+      @around.each do |a, c|
+        before = action
+
+        sub = c.new(cmd, ctx.input)
+        action = proc do |*given_inputs|
+          ctx.input = given_inputs.first || ctx.input
+          sub.instance_exec(before, ctx.input, &a)
+        end
+      end
+
+      res = ctx.instance_exec(ctx.input, &action)
+
+      @after.each { |f, c| c.new.instance_exec(&f) }
+
+      res
+    end
+
+    def add_input(name, options = {}, &interact)
+      options[:interact] = interact if interact
+      options[:description] = options.delete(:desc) if options.key?(:desc)
+
+      options[:type] ||=
+        case options[:default]
+        when true, false
+          :boolean
+        when Integer
+          :integer
+        when Float
+          :floating
+        end
+
+      unless options[:hidden]
+        @flags["--#{name.to_s.gsub("_", "-")}"] = name
+
+        if options[:singular]
+          @flags["--#{options[:singular]}"] = name
+        end
+
+        if aliases = options[:aliases] || options[:alias]
+          Array(aliases).each do |a|
+            @flags[a] = name
+          end
+        end
+      end
+
+      # :argument => true means accept as single argument
+      # :argument => :foo is shorthand for :argument => {:type => :foo}
+      if opts = options[:argument]
+        type =
+          case opts
+          when true
+            :normal
+          when Symbol
+            opts
+          when Hash
+            opts[:type]
+          end
+
+        options[:argument] = type
+
+        @arguments <<
+          { :name => name,
+            :type => type,
+            :value => options[:value]
+          }
+      end
+
+      @inputs[name] = options
+    end
+  end
+end

data/lib/mothership/errors.rb

@@ -0,0 +1,38 @@
+class Mothership
+  class Error < RuntimeError
+  end
+
+  class MissingArgument < Error
+    def initialize(cmd, arg)
+      @command = cmd
+      @argument = arg
+    end
+
+    def to_s
+      "#{@command.display_name}: missing input '#{@argument}'"
+    end
+  end
+
+  class ExtraArguments < Error
+    def initialize(cmd, extra)
+      @command = cmd
+      @extra = extra
+    end
+
+    def to_s
+      "#{@command.display_name}: too many arguments; extra: #{@extra.join(" ")}"
+    end
+  end
+
+  class TypeMismatch < Error
+    def initialize(cmd, input, type)
+      @command = cmd
+      @input = input
+      @type = type
+    end
+
+    def to_s
+      "#{@command.display_name}: expected #{@type} value for #{@input}"
+    end
+  end
+end