af 0.3.22 → 0.5.0.beta.1

data/lib/vmc/cli/organization/orgs.rb

@@ -0,0 +1,35 @@
+require "vmc/cli/organization/base"
+
+module VMC::Organization
+  class Orgs < Base
+    desc "List available organizations"
+    group :organizations, :hidden => true
+    input :full, :desc => "Show full information for apps, services, etc.",
+          :default => false
+    def orgs
+      orgs =
+        with_progress("Getting organizations") do
+          client.organizations.sort_by(&:name)
+        end
+
+      return if orgs.empty?
+
+      line unless quiet?
+
+      if input[:full]
+        orgs.each do |o|
+          invoke :org, :organization => o, :full => true
+        end
+      else
+        table(
+          %w{name spaces domains},
+          orgs.collect { |o|
+            [ c(o.name, :name),
+              name_list(o.spaces),
+              name_list(o.domains)
+            ]
+          })
+      end
+    end
+  end
+end

data/lib/vmc/cli/organization/rename.rb

@@ -0,0 +1,36 @@
+require "vmc/cli/organization/base"
+
+module VMC::Organization
+  class Rename < Base
+    desc "Rename an organization"
+    group :organizations, :hidden => true
+    input :organization, :desc => "Organization to rename",
+          :aliases => ["--org", "-o"], :argument => :optional,
+          :from_given => by_name(:organization)
+    input :name, :desc => "New organization name", :argument => :optional
+    def rename_org
+      organization = input[:organization]
+      name = input[:name]
+
+      organization.name = name
+
+      with_progress("Renaming to #{c(name, :name)}") do
+        organization.update!
+      end
+    end
+
+    private
+
+    def ask_name
+      ask("New name")
+    end
+
+    def ask_organization
+      organizations = client.organizations
+      fail "No organizations." if organizations.empty?
+
+      ask("Rename which organization?", :choices => organizations.sort_by(&:name),
+          :display => proc(&:name))
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require "vmc/cli"
+
+module VMC
+  module Route
+    class Base < CLI
+      def precondition
+        super
+        fail "This command is v2-only." unless v2?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+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 :app, :desc => "Application to add the URL to",
+          :argument => :optional, :from_given => by_name(:app)
+    input :host, :desc => "Host name for the route",
+          :argument => :optional, :default => ""
+    input :domain, :desc => "Domain to add the route to",
+          :argument => true,
+          :from_given => proc { |name, space|
+            if v2?
+              space.domain_by_name(name) ||
+                fail_unknown("domain", name)
+            else
+              name
+            end
+          }
+    def map
+      app = input[:app]
+      space = app.space if v2?
+
+      host = input[:host]
+      domain = input[:domain, space]
+
+      if v2?
+        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 << domain
+          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)}") do
+        route.create!
+      end
+
+      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

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

@@ -0,0 +1,26 @@
+require "vmc/cli/route/base"
+
+module VMC::Route
+  class Routes < Base
+    desc "List routes in a space"
+    group :routes, :hidden => true
+
+    def routes
+      # TODO: scope to space once space.routes is possible
+      routes =
+          with_progress("Getting routes") do
+            client.routes
+          end
+
+      line unless quiet?
+
+      table(
+          %w{host domain},
+          routes.sort_by { |r| "#{r.domain.name} #{r.host}" }.collect { |r|
+            [c(r.host, :name),
+             r.domain.name
+            ]
+          })
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require "vmc/cli/route/base"
+
+module VMC::Route
+  class Unmap < Base
+    desc "Remove a URL mapping"
+    group :apps, :info, :hidden => true
+    input :url, :desc => "URL to unmap", :argument => :optional,
+          :from_given => find_by_name("route") { client.routes }
+    input :app, :desc => "Application to remove the URL from",
+          :argument => :optional, :from_given => by_name(:app)
+    input :delete, :desc => "Delete route", :type => :boolean
+    input :all, :desc => "Act on all routes", :type => :boolean
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def unmap
+      return invoke :v1_unmap, input.inputs, input.given unless v2?
+
+      if input[:all]
+        if input.has?(:app)
+          app = target = input[:app]
+          return unless !input[:delete] || input[:really, "ALL URLS bound to #{target.name}", :bad]
+        else
+          target = client
+          return unless !input[:delete] || input[:really, "ALL URLS", :bad]
+        end
+
+        target.routes.each do |r|
+          begin
+            invoke :unmap, :delete => input[:delete], :url => r, :really => true, :app => app
+          rescue CFoundry::APIError => e
+            err "#{e.class}: #{e.message}"
+          end
+        end
+
+        return
+      end
+
+      app = input[:app]
+      url = input[:url, app ? app.routes : client.routes]
+
+      if input[:delete]
+        with_progress("Deleting route #{c(url.name, :name)}") do
+          url.delete!
+        end
+      elsif app
+        with_progress("Unbinding #{c(url.name, :name)} from #{c(app.name, :name)}") do
+          app.remove_route(url)
+        end
+      else
+        fail "Missing either --delete or --app."
+      end
+    end
+
+
+    desc "V1 ONLY UNMAP YOU SHOULD NOT SEE THIS"
+    input :url, :desc => "URL to unmap", :argument => :optional,
+          :interact => :v1_ask_url
+    input :app, :desc => "Application to remove the URL from",
+          :argument => :optional, :from_given => by_name(:app)
+    input :all, :desc => "Act on all routes", :type => :boolean
+    def v1_unmap
+      app = input[:app]
+      url = input[:url, app.urls] unless input[:all]
+
+      with_progress("Updating #{c(app.name, :name)}") do |s|
+        if input[:all]
+          app.urls = []
+        else
+          simple = url.sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+          unless app.urls.delete(simple)
+            fail "URL #{url} is not mapped to this application."
+          end
+        end
+
+        app.update!
+      end
+    end
+
+    private
+
+    def ask_url(choices)
+      ask("Which URL?", :choices => choices.sort_by(&:name), :display => proc(&:name))
+    end
+
+    def v1_ask_url(choices)
+      ask("Which URL?", :choices => choices.sort)
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+  end
+end

data/lib/vmc/cli/service/base.rb

@@ -0,0 +1,8 @@
+require "vmc/cli"
+
+module VMC
+  module Service
+    class Base < CLI
+    end
+  end
+end

data/lib/vmc/cli/service/bind.rb

@@ -0,0 +1,44 @@
+require "vmc/detect"
+
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Bind < Base
+    desc "Bind a service to an application"
+    group :services, :manage
+    input :service, :desc => "Service to bind", :argument => :optional,
+          :from_given => by_name(:service_instance, "service")
+    input :app, :desc => "Application to bind to", :argument => :optional,
+          :from_given => by_name(:app)
+    def bind_service
+      app = input[:app]
+      service = input[:service, app]
+
+      with_progress(
+          "Binding #{c(service.name, :name)} to #{c(app.name, :name)}") do |s|
+        if app.binds?(service)
+          s.skip do
+            err "App #{b(app.name)} already binds #{b(service.name)}."
+          end
+        else
+          app.bind(service)
+        end
+      end
+    end
+
+    private
+
+    def ask_service(app)
+      services = client.service_instances
+      fail "No services." if services.empty?
+
+      ask "Which service?", :choices => services - app.services,
+        :display => proc(&:name)
+    end
+
+    def ask_app
+      ask "Which application?", :choices => client.apps,
+        :display => proc(&:name)
+    end
+  end
+end

data/lib/vmc/cli/service/create.rb

@@ -0,0 +1,126 @@
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Create < Base
+    offerings_from_label = proc { |label, offerings|
+      offerings.select { |s| s.label == label }
+    }
+
+    desc "Create a service"
+    group :services, :manage
+    input :infra,    :desc => "Infrastructure to use", :from_given => by_name(:infra)
+    input :offering, :desc => "What kind of service (e.g. redis, mysql)",
+          :argument => :optional, :from_given => offerings_from_label
+    input :name, :desc => "Name for your service", :argument => :optional
+    input :plan, :desc => "Service plan",
+          :from_given => find_by_name_insensitive("plan"),
+          :default => proc { |plans|
+            plans.find { |p| p.name == "D100" } ||
+              interact
+          }
+    input :provider, :desc => "Service provider"
+    input :version, :desc => "Service version"
+    input :app, :desc => "Application to immediately bind to",
+          :alias => "--bind", :from_given => by_name(:app)
+    def create_service
+      offerings = client.services
+
+      if input[:infra]
+        offerings.reject! { |s| s.infra.to_s != input[:infra].name }
+      end
+
+      if input[:provider]
+        offerings.reject! { |s| s.provider != input[:provider] }
+      end
+
+      if input[:version]
+        offerings.reject! { |s| s.version != input[:version] }
+      elsif !v2?
+        offerings.reject!(&:deprecated?)
+      end
+
+      # filter the offerings based on a given plan value, which will be a
+      # string if the user provided it with a flag, or a ServicePlan if
+      # something invoked this command with a particular plan
+      if v2? && plan = input.direct(:plan)
+        offerings.reject! do |s|
+          if plan.is_a?(String)
+            s.service_plans.none? { |p| p.name == plan.upcase }
+          else
+            s.service_plans.include? plan
+          end
+        end
+      end
+
+      until offerings.size < 2
+        # cast to Array since it might be given as a Service with #invoke
+        offerings = Array(input[:offering, offerings.sort_by(&:label)])
+        input.forget(:offering)
+      end
+
+      if offerings.empty?
+        fail "Cannot find services matching the given criteria."
+      end
+
+      offering = offerings.first
+
+      service = client.service_instance
+
+      service.infra_name = input[:infra].name
+      service.name = input[:name, offering]
+
+      if v2?
+        service.service_plan = input[:plan, offering.service_plans]
+        service.space = client.current_space
+      else
+        service.type = offering.type
+        service.vendor = offering.label
+        service.version = offering.version
+        service.tier = "free"
+      end
+
+      with_progress("Creating service #{c(service.name, :name)}") do
+        service.create!
+      end
+
+      if app = input[:app]
+        invoke :bind_service, :service => service, :app => app
+      end
+
+      service
+    end
+
+    private
+
+    def ask_infra(choices, default, other)
+      [ask("Infrastructure?", :choices => client.infras,
+           :display => proc { |s|
+              str = "#{c(s.name, :name)} - #{s.description}"
+           },
+           :complete => proc { |s| "#{s.name} #{s.description}" })]
+    end
+
+    def ask_offering(offerings)
+      [ask("What kind?", :choices => offerings.sort_by(&:label),
+           :display => proc { |s|
+              str = "#{c(s.label, :name)} #{s.version}"
+              if s.provider != "core"
+                str << ", via #{s.provider}"
+              end
+              str
+           },
+           :complete => proc { |s| "#{s.label} #{s.version}" })]
+    end
+
+    def ask_name(offering)
+      random = sprintf("%x", rand(1000000))
+      ask "Name?", :default => "#{offering.label}-#{random}"
+    end
+
+    def ask_plan(plans)
+      ask "Which plan?", :choices => plans.sort_by(&:name),
+        :display => proc { |p| "#{p.name}: #{p.description}" },
+        :complete => proc(&:name)
+    end
+  end
+end