cloulu 0.0.0 → 0.1.1

data/lib/cfoundry/v2/space.rb

@@ -0,0 +1,18 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Space < Model
+    attribute :name, :string
+    to_one    :organization
+    to_many   :developers, :as => :user
+    to_many   :managers, :as => :user
+    to_many   :auditors, :as => :user
+    to_many   :apps
+    to_many   :domains
+    to_many   :service_instances
+
+    scoped_to_organization
+
+    queryable_by :name, :organization_guid, :developer_guid, :app_guid
+  end
+end

data/lib/cfoundry/v2/user.rb

@@ -0,0 +1,64 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class User < Model
+    to_many   :spaces
+    to_many   :organizations
+    to_many   :managed_organizations, :as => :organization
+    to_many   :billing_managed_organizations, :as => :organization
+    to_many   :audited_organizations, :as => :organization
+    to_many   :managed_spaces, :as => :space
+    to_many   :audited_spaces, :as => :space
+    attribute :admin, :boolean
+    to_one    :default_space, :as => :space
+
+    attribute :guid, :string # guid is explicitly set for users
+
+    queryable_by :space_guid, :organization_guid, :managed_organization_guid,
+      :billing_managed_organization_guid, :audited_organization_guid,
+      :managed_space_guid, :audited_space_guid
+
+    def guid
+      @guid
+    end
+
+    alias set_guid_attribute guid=
+
+    def guid=(x)
+      @guid = x
+      set_guid_attribute(x)
+    end
+
+    alias :admin? :admin
+
+    def change_password!(new, old)
+      @client.base.uaa.change_password(@guid, new, old)
+    end
+
+    # optional metadata from UAA
+    attr_accessor :emails, :name
+
+    def email
+      return unless @emails && @emails.first
+      @emails.first[:value]
+    end
+
+    def given_name
+      return unless @name && @name[:givenName] != email
+      @name[:givenName]
+    end
+
+    def family_name
+      return unless @name && @name[:familyName] != email
+      @name[:familyName]
+    end
+
+    def full_name
+      if @name && @name[:fullName]
+        @name[:fullName]
+      elsif given_name && family_name
+        "#{given_name} #{family_name}"
+      end
+    end
+  end
+end

data/lib/cfoundry/validator.rb

@@ -0,0 +1,39 @@
+module CFoundry
+  module Validator
+    class << self
+      def value_matches?(val, type)
+        case type
+        when Class
+          val.is_a?(type)
+        when Regexp
+          val.is_a?(String) && val =~ type
+        when :url
+          value_matches?(val, URI::regexp(%w(http https)))
+        when :https_url
+          value_matches?(val, URI::regexp("https"))
+        when :boolean
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+        when Array
+          val.all? do |x|
+            value_matches?(x, type.first)
+          end
+        when Hash
+          val.is_a?(Hash) &&
+            type.all? { |name, subtype|
+              val.key?(name) && value_matches?(val[name], subtype)
+            }
+        when nil
+          true
+        else
+          val.is_a?(Object.const_get(type.to_s.capitalize))
+        end
+      end
+
+      def validate_type(val, type)
+        unless value_matches?(val, type)
+          raise CFoundry::Mismatch.new(type, val)
+        end
+      end
+    end
+  end
+end

data/lib/cfoundry/version.rb

@@ -0,0 +1,4 @@
+module CFoundry # :nodoc:
+  # CFoundry library version number.
+  VERSION = "0.5.2".freeze
+end

data/lib/cfoundry/zip.rb

@@ -0,0 +1,56 @@
+require "zip/zipfilesystem"
+
+module CFoundry
+  # Generic Zpi API. Uses rubyzip underneath, but may be changed in the future
+  # to use system zip command if necessary.
+  module Zip
+    # Directory entries to exclude from packing.
+    PACK_EXCLUSION_GLOBS = %w(.. . *~ #*# *.log)
+
+    module_function
+
+    # Get the entries in the zip file. Returns an array of the entire
+    # contents, recursively (not just top-level).
+    def entry_lines(file)
+      entries = []
+      ::Zip::ZipFile.foreach(file) do |zentry|
+        entries << zentry
+      end
+      entries
+    end
+
+    # Unpack a zip +file+ to directory +dest+.
+    def unpack(file, dest)
+      ::Zip::ZipFile.foreach(file) do |zentry|
+        epath = "#{dest}/#{zentry}"
+        dirname = File.dirname(epath)
+        FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+        zentry.extract(epath) unless File.exists?(epath)
+      end
+    end
+
+    # Determine what files in +dir+ to pack.
+    def files_to_pack(dir)
+      Dir.glob("#{dir}/**/*", File::FNM_DOTMATCH).select do |f|
+        File.exists?(f) &&
+          PACK_EXCLUSION_GLOBS.none? do |e|
+            File.fnmatch(e, File.basename(f))
+          end
+      end
+    end
+
+    # Package directory +dir+ as file +zipfile+.
+    def pack(dir, zipfile)
+      files = files_to_pack(dir)
+      return false if files.empty?
+
+      ::Zip::ZipFile.open(zipfile, true) do |zf|
+        files.each do |f|
+          zf.add(f.sub("#{dir}/",''), f)
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/cfoundry.rb

@@ -0,0 +1,2 @@
+require "cfoundry/version"
+require "cfoundry/client"

data/lib/manifests-vmc-plugin/errors.rb

@@ -0,0 +1,21 @@
+module VMCManifests
+  class CircularDependency < RuntimeError
+    def initialize(app)
+      @app = app
+    end
+
+    def to_s
+      "Circular dependency in application '#@app'"
+    end
+  end
+
+  class UnknownSymbol < RuntimeError
+    def initialize(sym)
+      @sym = sym
+    end
+
+    def to_s
+      "Undefined symbol in manifest: '#@sym'"
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/builder.rb

@@ -0,0 +1,34 @@
+module VMCManifests
+  module Builder
+    # parse a manifest and merge with its inherited manifests
+    def build(file)
+      manifest = YAML.load_file file
+
+      Array(manifest["inherit"]).each do |path|
+        manifest = merge_parent(path, manifest)
+      end
+
+      manifest
+    end
+
+    private
+
+    # merge the manifest at `parent_path' into the `child'
+    def merge_parent(parent_path, child)
+      merge_manifest(build(from_manifest(parent_path)), child)
+    end
+
+    # deep hash merge
+    def merge_manifest(parent, child)
+      merge = proc do |_, old, new|
+        if new.is_a?(Hash) && old.is_a?(Hash)
+          old.merge(new, &merge)
+        else
+          new
+        end
+      end
+
+      parent.merge(child, &merge)
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/normalizer.rb

@@ -0,0 +1,149 @@
+module VMCManifests
+  module Normalizer
+    MANIFEST_META = ["applications", "properties"]
+
+    def normalize!(manifest)
+      toplevel = toplevel_attributes(manifest)
+
+      apps = manifest["applications"]
+      apps ||= [{}]
+
+      default_paths_to_keys!(apps)
+
+      apps = convert_to_array(apps)
+
+      merge_toplevel!(toplevel, manifest, apps)
+      normalize_apps!(apps)
+
+      manifest["applications"] = apps
+
+      normalize_paths!(apps)
+
+      keyval = normalize_key_val(manifest)
+      manifest.clear.merge!(keyval)
+
+      nil
+    end
+
+    private
+
+    def normalize_paths!(apps)
+      apps.each do |app|
+        app["path"] = from_manifest(app["path"])
+      end
+    end
+
+    def convert_to_array(apps)
+      return apps if apps.is_a?(Array)
+
+      ordered_by_deps(apps)
+    end
+
+    # sort applications in dependency order
+    # e.g. if A depends on B, B will be listed before A
+    def ordered_by_deps(apps, processed = Set[])
+      ordered = []
+      apps.each do |tag, info|
+        next if processed.include?(tag)
+
+        if deps = Array(info["depends-on"])
+          dep_apps = {}
+          deps.each do |dep|
+            dep_apps[dep] = apps[dep]
+          end
+
+          processed.add(tag)
+
+          ordered += ordered_by_deps(dep_apps, processed)
+          ordered << info
+        else
+          ordered << info
+          processed.add(tag)
+        end
+      end
+
+      ordered.each { |app| app.delete("depends-on") }
+
+      ordered
+    end
+
+    def default_paths_to_keys!(apps)
+      return if apps.is_a?(Array)
+
+      apps.each do |tag, app|
+        app["path"] ||= tag
+      end
+    end
+
+    def normalize_apps!(apps)
+      apps.each do |app|
+        normalize_app!(app)
+      end
+    end
+
+    def merge_toplevel!(toplevel, manifest, apps)
+      return if toplevel.empty?
+
+      apps.collect! do |a|
+        toplevel.merge(a)
+      end
+
+      toplevel.each do |k, _|
+        manifest.delete k
+      end
+    end
+
+    def normalize_app!(app)
+      if app["framework"].is_a?(Hash)
+        app["framework"] = app["framework"]["name"]
+      end
+
+      if app.key?("mem")
+        app["memory"] = app.delete("mem")
+      end
+
+      if app.key?("url") && app["url"].nil?
+        app["url"] = "none"
+      end
+
+      if app.key?("subdomain")
+        if app.key?("host")
+          app.delete("subdomain")
+        else
+          app["host"] = app.delete("subdomain")
+        end
+      end
+    end
+
+    def toplevel_attributes(manifest)
+      top =
+        manifest.reject { |k, _|
+          MANIFEST_META.include? k
+        }
+
+      # implicit toplevel path of .
+      top["path"] ||= "."
+
+      top
+    end
+
+    def normalize_key_val(val)
+      case val
+      when Hash
+        stringified = {}
+
+        val.each do |k, v|
+          stringified[k.to_sym] = normalize_key_val(v)
+        end
+
+        stringified
+      when Array
+        val.collect { |x| normalize_key_val(x) }
+      when nil
+        nil
+      else
+        val.to_s
+      end
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/resolver.rb

@@ -0,0 +1,79 @@
+module VMCManifests
+  module Resolver
+    def resolve(manifest, resolver)
+      new = {}
+
+      new[:applications] = manifest[:applications].collect do |app|
+        resolve_lexically(resolver, app, [manifest])
+      end
+
+      resolve_lexically(resolver, new, [new])
+    end
+
+    private
+
+    # resolve symbols, with hashes introducing new lexical symbols
+    def resolve_lexically(resolver, val, ctx)
+      case val
+      when Hash
+        new = {}
+
+        val.each do |k, v|
+          new[k] = resolve_lexically(resolver, v, [val] + ctx)
+        end
+
+        new
+      when Array
+        val.collect do |v|
+          resolve_lexically(resolver, v, ctx)
+        end
+      when String
+        val.gsub(/\$\{([^\}]+)\}/) do
+          resolve_symbol(resolver, $1, ctx)
+        end
+      else
+        val
+      end
+    end
+
+    # resolve a symbol to its value, and then resolve that value
+    def resolve_symbol(resolver, sym, ctx)
+      if found = find_symbol(sym.to_sym, ctx)
+        resolve_lexically(resolver, found, ctx)
+        found
+      elsif dynamic = resolver.resolve_symbol(sym)
+        dynamic
+      else
+        fail("Unknown symbol in manifest: #{sym}")
+      end
+    end
+
+    # search for a symbol introduced in the lexical context
+    def find_symbol(sym, ctx)
+      ctx.each do |h|
+        if val = resolve_in(h, sym)
+          return val
+        end
+      end
+
+      nil
+    end
+
+    # find a value, searching in explicit properties first
+    def resolve_in(hash, *where)
+      find_in_hash(hash, [:properties] + where) ||
+        find_in_hash(hash, where)
+    end
+
+    # helper for following a path of values in a hash
+    def find_in_hash(hash, where)
+      what = hash
+      where.each do |x|
+        return nil unless what.is_a?(Hash)
+        what = what[x]
+      end
+
+      what
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader.rb

@@ -0,0 +1,31 @@
+require "manifests-vmc-plugin/loader/builder"
+require "manifests-vmc-plugin/loader/normalizer"
+require "manifests-vmc-plugin/loader/resolver"
+
+module VMCManifests
+  class Loader
+    include Builder
+    include Normalizer
+    include Resolver
+
+    def initialize(file, resolver)
+      @file = file
+      @resolver = resolver
+    end
+
+    def manifest
+      info = build(@file)
+      normalize! info
+      resolve info, @resolver
+    end
+
+    private
+
+    # expand a path relative to the manifest file's directory
+    def from_manifest(path)
+      return path unless @file
+
+      File.expand_path(path, File.dirname(@file))
+    end
+  end
+end

data/lib/manifests-vmc-plugin/plugin.rb

@@ -0,0 +1,145 @@
+require "pathname"
+
+require "vmc/plugin"
+require "manifests-vmc-plugin"
+
+
+class ManifestsPlugin < VMC::App::Base
+  include VMCManifests
+
+  option :manifest, :aliases => "-m", :value => :file,
+    :desc => "Path to manifest file to use"
+
+
+  [ :start, :restart, :instances, :logs, :env, :health, :stats,
+    :scale, :app, :stop, :delete
+  ].each do |wrap|
+    name_made_optional = change_argument(wrap, :app, :optional)
+
+    around(wrap) do |cmd, input|
+      wrap_with_optional_name(name_made_optional, cmd, input)
+    end
+  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)
+    return cmd.call if input[:all]
+
+    unless manifest
+      # if the command knows how to handle this
+      if input.has?(:app) || !name_made_optional
+        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 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.production = input[:plan].upcase.start_with?("P") if input.has?(:plan)
+    app.framework = input[:framework] if input.has?(:framework)
+    app.runtime = input[:runtime] if input.has?(:runtime)
+    app.buildpack = input[:buildpack] if input.has?(:buildpack)
+  end
+
+  def wrap_push(push, input)
+    unless manifest
+      create_and_save_manifest(push, input)
+      return
+    end
+
+    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/manifests-vmc-plugin/version.rb

@@ -0,0 +1,3 @@
+module VMCManifests
+  VERSION = "0.6.2".freeze
+end