static 1.0.0 → 1.0.1

data/vendor/vmc-0.5.0/Rakefile

@@ -0,0 +1,101 @@
+require "rake"
+require "rspec/core/rake_task"
+
+specfile, _ = Dir["*.gemspec"]
+SPEC = Gem::Specification.load(specfile)
+CURRENT_VERSION = SPEC.version.to_s.freeze
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace :deploy do
+  def last_staging_sha
+    `git rev-parse latest-staging`.strip
+  end
+
+  def last_release_sha
+    `git rev-parse latest-release`.strip
+  end
+
+  def last_staging_ref_was_released?
+    last_staging_sha == last_release_sha
+  end
+
+  def next_minor
+    Gem::Version.new(CURRENT_VERSION + ".0").bump.to_s
+  end
+
+  def next_rc
+    unless CURRENT_VERSION =~ /rc/
+      "#{next_minor}.rc1"
+    end
+  end
+
+  task :staging, :version do |_, args|
+    version = args.version || next_rc
+    sh "gem bump --push #{"--version #{version}" if version}" if last_staging_ref_was_released?
+    sh "git tag -f latest-staging"
+    sh "git push origin :latest-staging"
+    sh "git push origin latest-staging"
+  end
+
+  task :candidate do
+    sh "git fetch"
+    sh "git checkout latest-staging"
+    sh "gem release"
+    sh "git tag -f v#{CURRENT_VERSION}"
+    sh "git tag -f latest-release"
+    sh "git push origin :latest-release"
+    sh "git push origin latest-release"
+  end
+
+  task :release do
+    version = CURRENT_VERSION.sub(/\.rc\d+/, "")
+
+    prereleases = SPEC.runtime_dependencies.select(&:prerelease?)
+    unless prereleases.empty?
+      puts "The following dependencies must be released:"
+      prereleases.each do |pre|
+        puts "- #{pre.name}"
+      end
+
+      puts ""
+
+      raise
+    end
+
+    # grab the last release candidate
+    sh "git checkout latest-release -b release-v#{version}"
+
+    # update the version
+    sh "gem bump --version #{version}"
+
+    # switch to master
+    sh "git checkout master"
+
+    # merge the new version number back into master
+    sh "git merge release-v#{version}"
+
+    # apply tags
+    sh "git tag -f v#{version}"
+    sh "git tag -f latest-release"
+    sh "git tag -f latest-stable"
+    sh "git push origin master"
+    sh "git push origin :latest-release 2> /dev/null || exit 0"
+    sh "git push origin :latest-stable 2> /dev/null || exit 0"
+    sh "git push origin latest-release"
+    sh "git push origin latest-stable"
+    sh "git push origin v#{version}"
+
+    # check out the release tag
+    sh "git checkout latest-stable"
+
+    # build the gem and push the gem to rubygems
+    sh "rm -f *.gem"
+    sh "gem build *.gemspec"
+    sh "gem push *.gem"
+    sh "rm -f *.gem"
+
+    puts "You are now on the latest-release tag. You'll have to switch back to your working branch."
+  end
+end

data/vendor/vmc-0.5.0/bin/vmc

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# vim: ft=ruby
+
+require "rubygems"
+
+require "vmc"
+require "vmc/plugin"
+
+VMC::Plugin.load_all
+
+VMC::CLI.start(ARGV)

data/vendor/vmc-0.5.0/lib/vmc/cli/app/app.rb

@@ -0,0 +1,45 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Apps < Base
+    IS_UTF8 = !!(ENV["LC_ALL"] || ENV["LC_CTYPE"] || ENV["LANG"] || "")["UTF-8"].freeze
+
+    desc "Show app information"
+    group :apps
+    input :app, :desc => "App to show", :argument => :required,
+          :from_given => by_name(:app)
+    def app
+      app = input[:app]
+
+      if quiet?
+        line app.name
+      else
+        display_app(app)
+      end
+    end
+
+    def display_app(a)
+      status = app_status(a)
+
+      line "#{c(a.name, :name)}: #{status}"
+
+      indented do
+        line "platform: #{b(a.framework.name)} on #{b(a.runtime.name)}"
+
+        start_line "usage: #{b(human_mb(a.memory))}"
+        print " #{d(IS_UTF8 ? "\xc3\x97" : "x")} #{b(a.total_instances)}"
+        print " instance#{a.total_instances == 1 ? "" : "s"}"
+
+        line
+
+        unless a.urls.empty?
+          line "urls: #{a.urls.collect { |u| b(u) }.join(", ")}"
+        end
+
+        unless a.services.empty?
+          line "services: #{a.services.collect { |s| b(s.name) }.join(", ")}"
+        end
+      end
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/apps.rb

@@ -0,0 +1,99 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Apps < Base
+    desc "List your applications"
+    group :apps
+    input :space, :desc => "Show apps in given space",
+          :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :name, :desc => "Filter by name regexp"
+    input :runtime, :desc => "Filter by runtime regexp"
+    input :framework, :desc => "Filter by framework regexp"
+    input :url, :desc => "Filter by url regexp"
+    input :full, :desc => "Verbose output format", :default => false
+    def apps
+      if space = input[:space]
+        begin
+          space.summarize!
+        rescue CFoundry::APIError
+        end
+
+        apps =
+          with_progress("Getting applications in #{c(space.name, :name)}") do
+            space.apps
+          end
+      else
+        apps =
+          with_progress("Getting applications") do
+            client.apps(:depth => 2)
+          end
+      end
+
+      line unless quiet?
+
+      if apps.empty? and !quiet?
+        line "No applications."
+        return
+      end
+
+      apps.reject! do |a|
+        !app_matches?(a, input)
+      end
+
+      apps = apps.sort_by(&:name)
+
+      if input[:full]
+        spaced(apps) do |a|
+          invoke :app, :app => a
+        end
+      elsif quiet?
+        apps.each do |a|
+          line a.name
+        end
+      else
+        display_apps_table(apps)
+      end
+    end
+
+    def display_apps_table(apps)
+      table(
+        ["name", "status", "usage", v2? && "plan", "runtime", "url"],
+        apps.collect { |a|
+          [ c(a.name, :name),
+            app_status(a),
+            "#{a.total_instances} x #{human_mb(a.memory)}",
+            v2? && (a.production ? "prod" : "dev"),
+            a.runtime.name,
+            if a.urls.empty?
+              d("none")
+            elsif a.urls.size == 1
+              a.url
+            else
+              "#{a.url}, ..."
+            end
+          ]
+        })
+    end
+
+    def app_matches?(a, options)
+      if name = options[:name]
+        return false if a.name !~ /#{name}/
+      end
+
+      if runtime = options[:runtime]
+        return false if a.runtime.name !~ /#{runtime}/
+      end
+
+      if framework = options[:framework]
+        return false if a.framework.name !~ /#{framework}/
+      end
+
+      if url = options[:url]
+        return false if a.urls.none? { |u| u =~ /#{url}/ }
+      end
+
+      true
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/base.rb

@@ -0,0 +1,82 @@
+require "vmc/cli"
+
+module VMC
+  module App
+    class Base < CLI
+      # choose the right color for app/instance state
+      def state_color(s)
+        case s
+        when "STARTING"
+          :neutral
+        when "STARTED", "RUNNING"
+          :good
+        when "DOWN"
+          :bad
+        when "FLAPPING"
+          :error
+        when "N/A"
+          :unknown
+        else
+          :warning
+        end
+      end
+
+      def app_status(a)
+        health = a.health
+
+        if a.debug_mode == "suspend" && health == "0%"
+          c("suspended", :neutral)
+        else
+          c(health.downcase, state_color(health))
+        end
+      end
+
+      def memory_choices(exclude = 0)
+        info = client.info
+        used = info[:usage][:memory]
+        limit = info[:limits][:memory]
+        available = limit - used + exclude
+
+        mem = 64
+        choices = []
+        until mem > available
+          choices << human_mb(mem)
+          mem *= 2
+        end
+
+        choices
+      end
+
+      def human_mb(num)
+        human_size(num * 1024 * 1024, 0)
+      end
+
+      def human_size(num, precision = 1)
+        sizes = %w(G M K)
+        sizes.each.with_index do |suf, i|
+          pow = sizes.size - i
+          unit = 1024.0 ** pow
+          if num >= unit
+            return format("%.#{precision}f%s", num / unit, suf)
+          end
+        end
+
+        format("%.#{precision}fB", num)
+      end
+
+      def megabytes(str)
+        if str =~ /T$/i
+          str.to_i * 1024 * 1024
+        elsif str =~ /G$/i
+          str.to_i * 1024
+        elsif str =~ /M$/i
+          str.to_i
+        elsif str =~ /K$/i
+          str.to_i / 1024
+        else # assume megabytes
+          str.to_i
+        end
+      end
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/crashes.rb

@@ -0,0 +1,42 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Crashes < Base
+    desc "List an app's crashed instances"
+    group :apps, :info, :hidden => true
+    input :apps, :desc => "Applications whose crashed instances to list",
+          :argument => :splat, :singular => :app, :from_given => by_name(:app)
+    def crashes
+      apps = input[:apps]
+      fail "No applications given." if apps.empty?
+
+      spaced(apps) do |app|
+        instances =
+          with_progress("Getting crashed instances for #{c(app.name, :name)}") do
+            app.crashes
+          end
+
+        line unless quiet?
+
+        spaced(instances) do |i|
+          if quiet?
+            line i.id
+          else
+            display_crashed_instance(i)
+          end
+        end
+      end
+    end
+
+    def display_crashed_instance(i)
+      start_line "instance #{c("\##{i.id}", :instance)}: "
+      puts "#{b(c("crashed", :error))} "
+
+      indented do
+        if s = i.since
+          line "since: #{c(s.strftime("%F %r"), :neutral)}"
+        end
+      end
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/delete.rb

@@ -0,0 +1,95 @@
+require "set"
+
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Delete < Base
+    desc "Delete an application"
+    group :apps, :manage
+    input :apps, :desc => "Applications to delete", :argument => :splat,
+          :singular => :app, :from_given => by_name(:app)
+    input :routes, :desc => "Delete associated routes", :default => false
+    input :delete_orphaned, :desc => "Delete orphaned services",
+          :aliases => "-o", :default => proc { force? ? false : interact },
+          :forget => true
+    input :all, :desc => "Delete all applications", :default => false
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def delete
+      apps = client.apps
+
+      if input[:all]
+        return unless input[:really, "ALL APPS", :bad]
+
+        to_delete = apps
+        others = []
+      else
+        to_delete = input[:apps]
+        others = apps - to_delete
+      end
+
+      all_services = apps.collect(&:services).flatten
+      deleted_app_services = []
+
+      spaced(to_delete) do |app|
+        really = input[:all] || input[:really, app.name, :name]
+        next unless really
+
+        deleted_app_services += app.services
+
+        with_progress("Deleting #{c(app.name, :name)}") do
+          app.routes.collect(&:delete!) if input[:routes]
+          app.delete!
+        end
+      end
+
+      delete_orphaned_services(
+        find_orphaned_services(deleted_app_services, all_services))
+
+      to_delete
+    end
+
+    def find_orphaned_services(deleted, all)
+      orphaned = []
+
+      leftover = all.dup
+      deleted.each do |svc|
+        leftover.slice!(leftover.index(svc))
+        orphaned << svc unless leftover.include?(svc)
+      end
+
+      # clear out the relationships as the apps are now deleted
+      orphaned.each(&:invalidate!)
+    end
+
+    def delete_orphaned_services(orphans)
+      return if orphans.empty?
+
+      line unless quiet? || force?
+
+      orphans.select { |o| input[:delete_orphaned, o] }.each do |service|
+        # TODO: splat
+        invoke :delete_service, :service => service, :really => true
+      end
+    end
+
+    private
+
+    def ask_apps
+      apps = client.apps
+      fail "No applications." if apps.empty?
+
+      [ask("Delete which application?", :choices => apps.sort_by(&:name),
+           :display => proc(&:name))]
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+
+    def ask_delete_orphaned(service)
+      ask("Delete orphaned service #{c(service.name, :name)}?",
+          :default => false)
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/deprecated.rb

@@ -0,0 +1,11 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Deprecated < Base
+    desc "DEPRECATED. Use 'push' instead."
+    input :app, :argument => :optional
+    def update
+      fail "The 'update' command is no longer needed; use 'push' instead."
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/env.rb

@@ -0,0 +1,78 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Env < Base
+    VALID_ENV_VAR = /^[a-zA-Za-z_][[:alnum:]_]*$/
+
+    desc "Show all environment variables set for an app"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the environment of",
+          :argument => true, :from_given => by_name(:app)
+    def env
+      app = input[:app]
+
+      vars =
+        with_progress("Getting env for #{c(app.name, :name)}") do |s|
+          app.env
+        end
+
+      line unless quiet?
+
+      vars.each do |name, val|
+        line "#{c(name, :name)}: #{val}"
+      end
+    end
+
+    desc "Set an environment variable"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to set the variable for",
+          :argument => true, :from_given => by_name(:app)
+    input :name, :desc => "Variable name", :argument => true
+    input :value, :desc => "Variable value", :argument => :optional
+    input :restart, :desc => "Restart app after updating?", :default => true
+    def set_env
+      app = input[:app]
+      name = input[:name]
+
+      if value = input[:value]
+        name = input[:name]
+      elsif name["="]
+        name, value = name.split("=")
+      end
+
+      unless name =~ VALID_ENV_VAR
+        fail "Invalid variable name; must match #{VALID_ENV_VAR.inspect}"
+      end
+
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.env[name] = value
+        app.update!
+      end
+
+      if app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+
+
+    desc "Remove an environment variable"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to set the variable for",
+          :argument => true, :from_given => by_name(:app)
+    input :name, :desc => "Variable name", :argument => true
+    input :restart, :desc => "Restart app after updating?", :default => true
+    def unset_env
+      app = input[:app]
+      name = input[:name]
+
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.env.delete(name)
+        app.update!
+      end
+
+      if app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+  end
+end

data/vendor/vmc-0.5.0/lib/vmc/cli/app/files.rb

@@ -0,0 +1,137 @@
+require "thread"
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Files < Base
+    desc "Print out an app's file contents"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the files of",
+          :argument => true, :from_given => by_name(:app)
+    input :path, :desc => "Path of file to read", :argument => :optional,
+          :default => "/"
+    def file
+      app = input[:app]
+      path = input[:path]
+
+      file =
+        with_progress("Getting file contents") do
+          app.file(*path.split("/"))
+        end
+
+      if quiet?
+        print file
+      else
+        line
+
+        file.split("\n").each do |l|
+          line l
+        end
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Examine an app's files"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the files of",
+          :argument => true, :from_given => by_name(:app)
+    input :path, :desc => "Path of directory to list", :argument => :optional,
+          :default => "/"
+    def files
+      app = input[:app]
+      path = input[:path]
+
+      if quiet?
+        files =
+          with_progress("Getting file listing") do
+            app.files(*path.split("/"))
+          end
+
+        files.each do |file|
+          line file.join("/")
+        end
+      else
+        invoke :file, :app => app, :path => path
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Stream an app's file contents"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the files of",
+          :argument => true, :from_given => by_name(:app)
+    input :path, :desc => "Path of file to stream", :argument => :optional
+    def tail
+      app = input[:app]
+
+      lines = Queue.new
+      max_len = 0
+
+      if path = input[:path]
+        max_len = path.size
+        app.instances.each do |i|
+          Thread.new do
+            stream_path(lines, i, path.split("/"))
+          end
+        end
+      else
+        app.instances.each do |i|
+          i.files("logs").each do |path|
+            len = path.join("/").size
+            max_len = len if len > max_len
+
+            Thread.new do
+              stream_path(lines, i, path)
+            end
+          end
+        end
+      end
+
+      while line = lines.pop
+        instance, path, log = line
+
+        unless log.end_with?("\n")
+          log += i("%") if color?
+          log += "\n"
+        end
+
+        print "\##{c(instance.id, :instance)}  "
+        print "#{c(path.join("/").ljust(max_len), :name)}  "
+        print log
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    def stream_path(lines, instance, path)
+      if verbose?
+        lines << [instance, path, c("streaming...", :good) + "\n"]
+      end
+
+      instance.stream_file(*path) do |contents|
+        contents.each_line do |line|
+          lines << [instance, path, line]
+        end
+      end
+
+      lines << [instance, path, c("end of file", :bad) + "\n"]
+    rescue Timeout::Error
+      if verbose?
+        lines << [
+          instance,
+          path,
+          c("timed out; reconnecting...", :bad) + "\n"
+        ]
+      end
+
+      retry
+    end
+  end
+end