cloulu 0.0.0 → 0.1.1

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 :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[: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.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 = v1_service_tier(offering)
+      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_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, default_plan = nil)
+      ask "Which plan?",
+        :choices => plans.sort_by(&:name),
+        :indexed => true,
+        :display => proc { |p| "#{p.name}: #{p.description || 'No description'}" },
+        :default => default_plan,
+        :complete => proc(&:name)
+    end
+
+    def v1_service_tier(service)
+      plans = service.service_plans
+      fail "No service plans" if plans.empty?
+      if plans.length == 1
+        plan = plans[0]
+      else
+        plan = ask_plan(plans, service.default_service_plan)
+      end
+      plan.name
+    end
+
+  end
+end

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

@@ -0,0 +1,86 @@
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Delete < Base
+    desc "Delete a service"
+    group :services, :manage
+    input :service, :desc => "Service to bind", :argument => :optional,
+          :from_given => by_name(:service_instance, :service)
+    input :unbind, :desc => "Unbind from applications before deleting?",
+          :type => :boolean, :default => proc { force? || interact }
+    input :all, :desc => "Delete all services", :default => false
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def delete_service
+      if input[:all]
+        return unless input[:really, "ALL SERVICES", :bad]
+
+        client.service_instances.each do |i|
+          invoke :delete_service, :service => i, :really => true
+        end
+
+        return
+      end
+
+      service = input[:service]
+
+      return unless input[:really, service.name, :name]
+
+      bindings = []
+
+      if v2?
+        bindings = service.service_bindings
+
+        unless bindings.empty? || !input[:unbind, bindings.collect(&:app)]
+          bindings.each do |b|
+            invoke :unbind_service, :service => service, :app => b.app
+          end
+
+          bindings = []
+        end
+      end
+
+      with_progress("Deleting #{c(service.name, :name)}") do |s|
+        if bindings.empty?
+          service.delete!
+        else
+          s.skip do
+            apps = bindings.collect(&:app).collect { |a| b(a.name) }
+            err "Service is bound to #{human_list(apps)}."
+          end
+        end
+      end
+    end
+
+    private
+
+    def ask_service
+      services = client.service_instances
+      fail "No services." if services.empty?
+
+      ask "Which service?", :choices => services,
+        :display => proc(&:name)
+    end
+
+    def ask_unbind(apps)
+      names = human_list(apps.collect { |a| c(a.name, :name) })
+
+      ask("Unbind from #{names} before deleting?", :default => true)
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+
+    def human_list(xs)
+      if xs.size == 1
+        xs.first
+      elsif xs.size == 2
+        "#{xs.first} and #{xs.last}"
+      else
+        last = xs.pop
+        xs.join(", ") + ", and #{last}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Rename < Base
+    desc "Rename a service"
+    group :services, :manage, :hidden => true
+    input :service, :desc => "Service to rename", :argument => :optional,
+          :from_given => by_name(:service_instance, :service)
+    input :name, :desc => "New service name", :argument => :optional
+    def rename_service
+      service = input[:service]
+      name = input[:name]
+
+      service.name = name
+
+      with_progress("Renaming to #{c(name, :name)}") do
+        service.update!
+      end
+    end
+
+    private
+
+    def ask_service
+      services = client.service_instances
+      fail "No services." if services.empty?
+
+      ask("Rename which service?", :choices => services.sort_by(&:name),
+          :display => proc(&:name))
+    end
+
+    def ask_name
+      ask("New name")
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Service < Base
+    desc "Show service information"
+    group :services
+    input :service, :desc => "Service to show", :argument => :required,
+          :from_given => by_name(:service_instance, :service)
+    def service
+      display_service(input[:service])
+    end
+
+    private
+
+    def display_service(i)
+      if quiet?
+        line i.name
+      elsif v2?
+        plan = i.service_plan
+        service = plan.service
+
+        apps = i.service_bindings.collect { |b|
+          c(b.app.name, :name)
+        }.join(", ")
+
+        line "#{c(i.name, :name)}: #{service.label} #{service.version}"
+
+        indented do
+          line "provider: #{c(service.provider, :name)}"
+          line "bound to: #{apps}" unless apps.empty?
+          line "plan: #{c(plan.name, :name)}"
+
+          indented do
+            line "description: #{plan.description}"
+          end
+        end
+      else
+        line "#{c(i.name, :name)}: #{i.vendor} #{i.version}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Services < Base
+    desc "List your service"
+    group :services
+    input :space, :desc => "Show services in given space",
+          :from_given => by_name(:space),
+          :default => proc { client.current_space }
+    input :name, :desc => "Filter by name"
+    input :service, :desc => "Filter by service type"
+    input :plan, :desc => "Filter by service plan"
+    input :provider, :desc => "Filter by service provider"
+    input :version, :desc => "Filter by service version"
+    input :app, :desc => "Limit to application's service bindings",
+          :from_given => by_name(:app)
+    input :full, :desc => "Verbose output format", :default => false
+    def services
+      msg =
+        if space = input[:space]
+          "Getting services in #{c(space.name, :name)}"
+        else
+          "Getting services"
+        end
+
+      services =
+        with_progress(msg) do
+          client.service_instances(:depth => 2)
+        end
+
+      line unless quiet?
+
+      if services.empty? and !quiet?
+        line "No services."
+        return
+      end
+
+      services.reject! do |i|
+        !service_matches(i, input)
+      end
+
+      if input[:full]
+        spaced(services) do |s|
+          invoke :service, :service => s
+        end
+      else
+        table(
+          ["name", "service", "version", v2? && "plan", v2? && "bound apps"],
+          services.collect { |i|
+            if v2?
+              plan = i.service_plan
+              service = plan.service
+
+              label = service.label
+              version = service.version
+              apps = name_list(i.service_bindings.collect(&:app))
+            else
+              label = i.vendor
+              version = i.version
+            end
+
+            [ c(i.name, :name),
+              label,
+              version,
+              v2? && plan.name,
+              apps
+            ]
+          })
+      end
+    end
+
+    private
+
+    def service_matches(i, options)
+      if app = options[:app]
+        return false unless app.services.include? i
+      end
+
+      if name = options[:name]
+        return false unless File.fnmatch(name, i.name)
+      end
+
+      plan = i.service_plan if v2?
+
+      if service = options[:service]
+        if v2?
+          return false unless File.fnmatch(service, plan.service.label)
+        else
+          return false unless File.fnmatch(service, i.vendor)
+        end
+      end
+
+      if plan = options[:plan]
+        fail "--plan is not supported on this target" unless v2?
+        return false unless File.fnmatch(plan.upcase, plan.name.upcase)
+      end
+
+      if provider = options[:provider]
+        fail "--provider is not supported on this target" unless v2?
+        return false unless File.fnmatch(provider, plan.service.provider)
+      end
+
+      if version = options[:version]
+        if v2?
+          return false unless File.fnmatch(version, plan.service.version)
+        else
+          return false unless File.fnmatch(version, i.version)
+        end
+      end
+
+      true
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require "vmc/detect"
+
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Unbind < Base
+    desc "Unbind a service from an application"
+    group :services, :manage
+    input :service, :desc => "Service to unbind", :argument => :optional,
+          :from_given => by_name(:service_instance, :service)
+    input :app, :desc => "Application to unbind from", :argument => :optional,
+          :from_given => by_name(:app)
+    def unbind_service
+      app = input[:app]
+      service = input[:service, app]
+
+      with_progress(
+          "Unbinding #{c(service.name, :name)} from #{c(app.name, :name)}") do
+        app.unbind(service)
+      end
+    end
+
+    private
+
+    def ask_service(app)
+      services = app.services
+      fail "No bound services." if services.empty?
+
+      ask "Which service?", :choices => services,
+        :display => proc(&:name)
+    end
+
+    def ask_app
+      ask "Which application?", :choices => client.apps,
+        :display => proc(&:name)
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require "vmc/cli/v2_check_cli"
+
+module VMC
+  module Start
+    class Base < V2CheckCLI
+      # Make sure we only show the target once
+      @@displayed_target = false
+
+      def displayed_target?
+        @@displayed_target
+      end
+
+      # These commands don't require authentication.
+      def precondition
+        fail_on_v2
+      end
+
+      private
+
+      def show_context
+        return if quiet? || displayed_target?
+
+        display_target
+
+        line
+
+        @@displayed_target = true
+      end
+
+      def display_target
+        if quiet?
+          line client.target
+        else
+          line "target: #{c(client.target, :name)}"
+        end
+      end
+
+      def select_org(input, info)
+        if input.has?(:organization) || !org_valid?(info[:organization])
+          org = input[:organization]
+          if org
+            with_progress("Switching to organization #{c(org.name, :name)}") {}
+            client.current_organization = org
+          end
+          info[:organization] = org ? org.guid : nil
+          !!org
+        else
+          info[:organization] = nil
+          client.current_organization = nil
+          false
+        end
+      end
+
+      def select_space(input, info, changed_org)
+        if input.has?(:space) || !space_valid?(info[:space])
+          line if changed_org && !quiet?
+          space = input[:space, client.current_organization]
+          if space
+            with_progress("Switching to space #{c(space.name, :name)}") {}
+            client.current_space = space
+          end
+          info[:space] = space ? space.guid : nil
+        else
+          info[:space] = nil
+          client.current_space = nil
+        end
+      end
+
+      def select_org_and_space(input, info)
+        changed_org = select_org(input, info)
+        if client.current_organization
+          select_space(input, info, changed_org)
+        else
+          info[:space] = nil
+          client.current_space = nil
+        end
+      end
+
+      def org_valid?(guid, user = client.current_user)
+        return false unless guid
+        client.organization(guid).users.include? user
+      rescue CFoundry::APIError
+        false
+      end
+
+      def space_valid?(guid, user = client.current_user)
+        return false unless guid
+        client.space(guid).developers.include? user
+      rescue CFoundry::APIError
+        false
+      end
+    end
+  end
+end

data/lib/vmc/cli/start/colors.rb

@@ -0,0 +1,13 @@
+require "vmc/cli/start/base"
+
+module VMC::Start
+  class Colors < Base
+    desc "Show color configuration"
+    group :start, :hidden => true
+    def colors
+      user_colors.each do |n, c|
+        line "#{n}: #{c(c.to_s, n)}"
+      end
+    end
+  end
+end

data/lib/vmc/cli/start/info.rb

@@ -0,0 +1,126 @@
+require "vmc/cli/start/base"
+
+module VMC::Start
+  class Info < Base
+    def precondition
+      check_target
+    end
+
+    desc "Display information on the current target, user, etc."
+    group :start
+    input :runtimes, :desc => "List supported runtimes", :alias => "-r",
+          :default => false
+    input :frameworks, :desc => "List supported frameworks", :alias => "-f",
+          :default => false
+    input :services, :desc => "List supported services", :alias => "-s",
+          :default => false
+    input :all, :desc => "Show all information", :alias => "-a",
+          :default => false
+    def info
+      all = input[:all]
+
+      if all || input[:runtimes]
+        runtimes =
+            with_progress("Getting runtimes") do
+              client.runtimes
+            end
+      end
+
+      if all || input[:frameworks]
+        frameworks =
+            with_progress("Getting frameworks") do
+              client.frameworks
+            end
+      end
+
+      if all || input[:services]
+        services =
+            with_progress("Getting services") do
+              client.services
+            end
+      end
+
+      showing_any = runtimes || services || frameworks
+
+      unless !all && showing_any
+        info = client.info
+
+        line if showing_any
+        line "\x1B[1m\x1B[31m" + info[:description] + "\x1B[00m"
+        line
+        line "target: #{b(client.target)}"
+
+        indented do
+          line "version: #{info[:version]}"
+          line "support: #{info[:support]}"
+        end
+
+        if user = client.current_user
+          line
+          line "user: #{b(user.email || user.guid)}"
+        end
+      end
+
+      if runtimes
+        line unless quiet?
+
+        if runtimes.empty? && !quiet?
+          line "#{d("none")}"
+        elsif input[:quiet]
+          runtimes.each do |r|
+            line r.name
+          end
+        else
+          table(
+              %w{runtime description},
+              runtimes.sort_by(&:name).collect { |r|
+                [c(r.name, :name), r.description]
+              })
+        end
+      end
+
+      if frameworks
+        line unless quiet?
+
+        if frameworks.empty? && !quiet?
+          line "#{d("none")}"
+        elsif input[:quiet]
+          frameworks.each do |f|
+            line f.name
+          end
+        else
+          table(
+              %w{framework description},
+              frameworks.sort_by(&:name).collect { |f|
+                [c(f.name, :name), f.description]
+              })
+        end
+      end
+
+      if services
+        line unless quiet?
+
+        if services.empty? && !quiet?
+          line "#{d("none")}"
+        elsif input[:quiet]
+          services.each do |s|
+            line s.label
+          end
+        else
+          table(
+              ["service", "version", "provider", v2? && "plans", "description"],
+              services.sort_by(&:label).collect { |s|
+                next if !v2? && s.deprecated?
+
+                [c(s.label, :name),
+                 s.version,
+                 s.provider,
+                 v2? && s.service_plans.collect(&:name).join(", "),
+                 s.description
+                ]
+              })
+        end
+      end
+    end
+  end
+end