vmc 0.5.0.beta.7 → 0.5.0.beta.10

data/Rakefile

@@ -1,39 +1,38 @@
 require "rake"
+require "rspec/core/rake_task"
 
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "vmc/version"
 
+RSpec::Core::RakeTask.new(:spec)
 task :default => :spec
 
-desc "Run specs"
-task :spec => "bundler:install" do
-  sh("rspec")
-end
-
-namespace :bundler do
-  desc "Install bundler and gems"
-  task "install" do
-    sh("(gem list --local bundler | grep bundler || gem install bundler) && (bundle check || bundle install)")
+namespace :deploy do
+  def last_staging_sha
+    `git rev-parse latest-staging`.strip
   end
-end
 
-namespace :gem do
-  desc "Build Gem"
-  task :build do
-    sh "gem build vmc.gemspec"
+  def last_release_sha
+    `git rev-parse latest-release`.strip
   end
 
-  desc "Install Gem"
-  task :install => :build do
-    sh "gem install --local vmc-#{VMC::VERSION}"
-    sh "rm vmc-#{VMC::VERSION}.gem"
+  def last_staging_ref_was_released?
+    last_staging_sha == last_release_sha
   end
 
-  desc "Uninstall Gem"
-  task :uninstall do
-    sh "gem uninstall vmc"
+  task :staging, :version do |_, args|
+    sh "gem bump --push #{"--version #{args.version}" if args.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
 
-  desc "Reinstall Gem"
-  task :reinstall => [:uninstall, :install]
+  task :gem do
+    sh "git fetch"
+    sh "git checkout #{last_staging_sha}"
+    sh "gem release --tag"
+    sh "git tag -f latest-release"
+    sh "git push origin :latest-release"
+    sh "git push origin latest-release"
+  end
 end

data/lib/vmc/cli.rb

@@ -73,7 +73,7 @@ module VMC
         if force?
           fail "Please log in with 'vmc login'."
         else
-          line c("Please log in with 'vmc login'.", :warning)
+          line c("Please log in first to proceed.", :warning)
           line
           invoke :login
           invalidate_client
@@ -224,12 +224,7 @@ module VMC
     end
 
     def err(msg, status = 1)
-      if quiet?
-        $stderr.puts(msg)
-      else
-        puts c(msg, :error)
-      end
-
+      $stderr.puts c(msg, :error)
       exit_status status
     end
 
@@ -282,6 +277,7 @@ module VMC
     end
 
     def client_target
+      check_target
       File.read(target_file).chomp
     end
 
@@ -304,25 +300,29 @@ module VMC
       new_toks = File.expand_path(VMC::TOKENS_FILE)
       old_toks = File.expand_path(VMC::OLD_TOKENS_FILE)
 
-      if File.exist? new_toks
+      info = if File.exist? new_toks
         YAML.load_file(new_toks)
       elsif File.exist? old_toks
         MultiJson.load(File.read(old_toks))
       else
         {}
       end
-    end
 
-    def target_info(target = client_target)
-      info = targets_info[target]
+      normalize_targets_info(info)
+    end
 
-      if info.is_a? String
-        { :token => info }
-      else
-        info || {}
+    def normalize_targets_info(info_by_url)
+      info_by_url.reduce({}) do |hash, pair|
+        key, value = pair
+        hash[key] = value.is_a?(String) ? {:token => value } : value
+        hash
       end
     end
 
+    def target_info(target = client_target)
+      targets_info[target] || {}
+    end
+
     def save_targets(ts)
       ensure_config_dir
 
@@ -348,7 +348,7 @@ module VMC
     end
 
     def v2?
-      client.is_a?(CFoundry::V2::Client)
+      client.version == 2
     end
 
     def invalidate_client
@@ -360,15 +360,16 @@ module VMC
       return @@client if defined?(@@client) && @@client
 
       info = target_info(target)
+      token = info[:token] && CFoundry::AuthToken.from_hash(info)
 
       @@client =
         case info[:version]
         when 2
-          CFoundry::V2::Client.new(target, info[:token])
+          CFoundry::V2::Client.new(target, token)
         when 1
-          CFoundry::V1::Client.new(target, info[:token])
+          CFoundry::V1::Client.new(target, token)
         else
-          CFoundry::Client.new(target, info[:token])
+          CFoundry::Client.new(target, token)
         end
 
       @@client.proxy = input[:proxy]
@@ -378,14 +379,7 @@ module VMC
       @@client.log = File.expand_path("#{LOGS_DIR}/#{uri.host}.log")
 
       unless info.key? :version
-        info[:version] =
-          case @@client
-          when CFoundry::V2::Client
-            2
-          else
-            1
-          end
-
+        info[:version] = @@client.version
         save_target_info(info, target)
       end
 

data/lib/vmc/cli/app/push.rb

@@ -21,6 +21,7 @@ module VMC::App
     input :plan,      :desc => "Application plan", :default => "D100"
     input :start,     :desc => "Start app after pushing?", :default => true
     input :restart,   :desc => "Restart app after updating?", :default => true
+    input :buildpack, :desc => "Custom buildpack URL", :default => nil
     input :create_services, :desc => "Interactively create services?",
           :type => :boolean, :default => proc { force? ? false : interact }
     input :bind_services, :desc => "Interactively bind services?",

data/lib/vmc/cli/app/push/create.rb

@@ -14,6 +14,7 @@ module VMC::App
       inputs[:framework] = framework = determine_framework
       inputs[:command] = input[:command] if can_have_custom_start_command?(framework)
       inputs[:runtime] = determine_runtime(framework)
+      inputs[:buildpack] = input[:buildpack] if v2?
 
       human_mb = human_mb(detector.suggested_memory(framework) || 64)
       inputs[:memory] = megabytes(input[:memory, human_mb])
@@ -22,7 +23,7 @@ module VMC::App
     end
 
     def determine_framework
-      return input[:framework] if input.given?(:framework)
+      return input[:framework] if input.has?(:framework)
 
       if (detected_framework = detector.detect_framework)
         input[:framework, [detected_framework], detected_framework, :other]
@@ -32,7 +33,7 @@ module VMC::App
     end
 
     def determine_runtime(framework)
-      return input[:runtime] if input.given?(:runtime)
+      return input[:runtime] if input.has?(:runtime)
 
       detected_runtimes =
         if framework.name == "standalone"

data/lib/vmc/cli/app/push/sync.rb

@@ -1,12 +1,13 @@
 module VMC::App
   module Sync
     def apply_changes(app)
-      app.memory = megabytes(input[:memory]) if input.given?(:memory)
-      app.total_instances = input[:instances] if input.given?(:instances)
-      app.command = input[:command] if input.given?(:command)
-      app.production = input[:plan].upcase.start_with?("P") if input.given?(:plan)
-      app.framework = input[:framework] if input.given?(:framework)
-      app.runtime = input[:runtime] if input.given?(:runtime)
+      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 display_changes(app)
@@ -14,8 +15,10 @@ module VMC::App
 
       line "Changes:"
 
-      app.changes.each do |attr, (old, new)|
-        line "#{c(attr, :name)}: #{diff_str(attr, old)} -> #{diff_str(attr, new)}"
+      indented do
+        app.changes.each do |attr, (old, new)|
+          line "#{c(attr, :name)}: #{diff_str(attr, old)} -> #{diff_str(attr, new)}"
+        end
       end
     end
 

data/lib/vmc/cli/app/scale.rb

@@ -6,51 +6,53 @@ module VMC::App
     group :apps, :info, :hidden => true
     input :app, :desc => "Application to update", :argument => true,
           :from_given => by_name(:app)
-    input :instances, :desc => "Number of instances to run", :type => :numeric
+    input :instances, :desc => "Number of instances to run",
+          :type => :numeric
     input :memory, :desc => "Memory limit"
+    input :disk, :desc => "Disk quota"
     input :plan, :desc => "Application plan", :default => "D100"
     input :restart, :desc => "Restart app after updating?", :default => true
     def scale
       app = input[:app]
 
-      if input.given?(:instances)
+      if input.has?(:instances)
         instances = input[:instances, app.total_instances]
       end
 
-      if input.given?(:memory)
+      if input.has?(:memory)
         memory = input[:memory, app.memory]
       end
 
-      if input.given?(:plan)
+      if input.has?(:disk)
+        disk = input[:disk, human_mb(app.disk_quota)]
+      end
+
+      if input.has?(:plan)
         fail "Plans not supported on target cloud." unless v2?
 
         plan_name = input[:plan]
         production = !!(plan_name =~ /^p/i)
       end
 
-      unless instances || memory || plan_name
+      unless instances || memory || disk || plan_name
         instances = input[:instances, app.total_instances]
         memory = input[:memory, app.memory]
       end
 
-      memory = megabytes(memory) if memory
+      app.total_instances = instances if input.has?(:instances)
+      app.memory = megabytes(memory) if input.has?(:memory)
+      app.disk_quota = megabytes(disk) if input.has?(:disk)
+      app.production = production if input.has?(:plan)
 
-      instances_changed = instances && instances != app.total_instances
-      memory_changed = memory && memory != app.memory
-      plan_changed = plan_name && production != app.production
-
-      unless memory_changed || instances_changed || plan_changed
-        fail "No changes!"
-      end
+      fail "No changes!" unless app.changed?
 
       with_progress("Scaling #{c(app.name, :name)}") do
-        app.total_instances = instances if instances_changed
-        app.memory = memory if memory_changed
-        app.production = production if plan_changed
         app.update!
       end
 
-      if memory_changed && app.started? && input[:restart]
+      needs_restart = app.changes.key?(:memory) || app.changes.key?(:disk_quota)
+
+      if needs_restart && app.started? && input[:restart]
         invoke :restart, :app => app
       end
     end

data/lib/vmc/cli/domain/map.rb

@@ -0,0 +1,55 @@
+require "vmc/cli/domain/base"
+
+module VMC::Domain
+  class Map < Base
+    desc "Map a domain to an organization or space"
+    group :domains
+    input :name, :desc => "Domain to map", :argument => :required
+    input :organization, :desc => "Organization to map the domain to",
+          :aliases => %w{--org -o},
+          :default => proc { client.current_organization },
+          :from_given => by_name(:organization)
+    input :space, :desc => "Space to map the domain to",
+          :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :shared, :desc => "Create a shared domain", :default => false
+    def map_domain
+      domain = client.domain_by_name(input[:name])
+
+      given_org = input.has?(:organization)
+      given_space = input.has?(:space)
+
+      org = input[:organization]
+      space = input[:space]
+
+      given_space = true unless given_org || given_space
+
+      unless domain
+        domain = client.domain
+        domain.name = input[:name]
+        domain.owning_organization = org unless input[:shared]
+        domain.wildcard = true
+
+        with_progress("Creating domain #{c(domain.name, :name)}") do
+          domain.create!
+          org.add_domain(domain) if org && !given_org && !given_space
+        end
+      end
+
+      if given_space
+        add_domain(domain, space.organization)
+        add_domain(domain, space)
+      elsif given_org
+        add_domain(domain, org)
+      end
+    end
+
+    private
+
+    def add_domain(domain, target)
+      with_progress("Mapping #{c(domain.name, :name)} to #{c(target.name, :name)}") do
+        target.add_domain(domain)
+      end
+    end
+  end
+end

data/lib/vmc/cli/domain/unmap.rb

@@ -0,0 +1,56 @@
+require "vmc/cli/domain/base"
+
+module VMC::Domain
+  class Unmap < Base
+    desc "Unmap a domain from an organization or space"
+    group :domains
+    input :domain, :desc => "Domain to unmap", :argument => :required,
+          :from_given => by_name("domain")
+    input :organization, :desc => "Organization to unmap the domain from",
+          :aliases => %w{--org -o},
+          :default => proc { client.current_organization },
+          :from_given => by_name(:organization)
+    input :space, :desc => "Space to unmap the domain from",
+          :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :delete, :desc => "Delete domain", :type => :boolean
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def unmap_domain
+      domain = input[:domain]
+
+      given_org = input.has?(:organization)
+      given_space = input.has?(:space)
+
+      org = input[:organization]
+      space = input[:space]
+
+      if input[:delete]
+        return unless input[:really, domain.name, :name]
+
+        with_progress("Deleting domain #{c(domain.name, :name)}") do
+          domain.delete!
+        end
+
+        return
+      end
+
+      given_space = true unless given_org || given_space
+
+      remove_domain(domain, space) if given_space
+      remove_domain(domain, org) if given_org
+    end
+
+    private
+
+    def remove_domain(domain, target)
+      with_progress("Unmapping #{c(domain.name, :name)} from #{c(target.name, :name)}") do
+        target.remove_domain(domain)
+      end
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+  end
+end

data/lib/vmc/cli/route/map.rb

@@ -0,0 +1,74 @@
+require "vmc/cli/route/base"
+
+module VMC::Route
+  class Map < Base
+    def precondition; end
+
+    desc "Add a URL mapping"
+    group :apps, :info, :hidden => true
+    input :url, :desc => "URL to map", :argument => true
+    input :app, :desc => "Application to add the URL to", :argument => :optional,
+          :from_given => by_name(:app)
+    input :space, :desc => "Space to add the URL to",
+          :from_given => by_name(:space)
+    def map
+      if input.has?(:space)
+        space = input[:space]
+      else
+        app = input[:app]
+        space = app.space if v2?
+      end
+
+      url = input[:url].sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+      if v2?
+        host, domain_name = url.split(".", 2)
+        domain = find_domain(space, domain_name)
+        route = find_or_create_route(domain, host, space)
+        bind_route(route, app) if app
+      else
+        with_progress("Updating #{c(app.name, :name)}") do
+          app.urls << url
+          app.update!
+        end
+      end
+    end
+
+    private
+
+    def bind_route(route, app)
+      with_progress("Binding #{c(route.name, :name)} to #{c(app.name, :name)}") do
+        app.add_route(route)
+      end
+    end
+
+    def find_or_create_route(domain, host, space)
+      find_route(domain, host) || create_route(domain, host, space)
+    end
+
+    def find_route(domain, host)
+      client.routes_by_host(host, :depth => 0).find { |r| r.domain == domain }
+    end
+
+    def create_route(domain, host, space)
+      route = client.route
+      route.host = host
+      route.domain = domain
+      route.space = space
+
+      with_progress("Creating route #{c(route.name, :name)}") { route.create! }
+
+      route
+    end
+
+    def find_domain(space, name)
+      domain = space.domain_by_name(name, :depth => 0)
+      fail "Invalid domain '#{name}'" unless domain
+      domain
+    end
+
+    def ask_app
+      ask("Which application?", :choices => client.apps, :display => proc(&:name))
+    end
+  end
+end