jdc 0.2.1 → 0.2.2.pre

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

@@ -0,0 +1,159 @@
+require "jdc/cli/service/base"
+=begin
+module JDC::Service
+  USER_PROVIDED_OFFERING = "user-provided" # I'd rather move this to JFoundry
+
+  class UPDummy
+    def label
+      "user-provided"
+    end
+
+    attr_reader :version, :provider
+  end
+
+  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 {
+        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] }
+      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 plan = input.direct(:plan)
+        offerings.reject! do |s|
+          if plan.is_a?(String)
+            s.service_plans.none? { |p| p.name.casecmp(plan) == 0 }
+          else
+            !s.service_plans.include? plan
+          end
+        end
+      end
+      finalize
+
+      offerings << UPDummy.new
+
+      selected_offerings = offerings.any? ? Array(input[:offering, offerings.sort_by(&:label)]) : []
+      finalize
+
+      if selected_offerings.empty?
+        fail "Cannot find services matching the given criteria."
+      end
+
+      offering = selected_offerings.first
+
+      if offering.label == JDC::Service::USER_PROVIDED_OFFERING
+        service_instance = client.user_provided_service_instance
+        service_instance.name = input[:name, offering]
+        finalize
+
+        # at this point there's no way input[:credentials] can work interactively...
+        service_instance.credentials = input[:credentials, nil] || ask_credentials
+      else
+        service_instance = client.managed_service_instance
+        service_instance.name = input[:name, offering]
+        finalize
+
+        plan = input[:plan, offering.service_plans]
+        finalize
+        service_instance.service_plan = if plan.is_a?(String)
+                                          offering.service_plans.find { |p| p.name.casecmp(plan) == 0 }
+                                        else
+                                          plan
+                                        end
+      end
+
+      service_instance.space = client.current_space
+
+      with_progress("Creating service #{c(service_instance.name, :name)}") do
+        service_instance.create!
+      end
+
+      app = input[:app]
+      finalize
+
+      if app
+        invoke :bind_service, :service => service_instance, :app => app
+      end
+      service_instance
+    end
+
+    private
+
+    def ask_credentials
+      credentials = {}
+
+      while keys = ask("What credential parameters should applications use to connect to this service instance?\n(e.g. hostname, port, password)").split(/\s*,\s*/).map(&:strip)
+        if bad_key = keys.detect { |key| key !~ /^[-\w]+$/ }
+          line("'#{bad_key}' is not a valid key")
+        else
+          break
+        end
+      end
+      finalize
+      keys.each do |key|
+        value = ask(key)
+        finalize
+        credentials[key] = value
+      end
+
+      credentials
+    end
+
+    def ask_offering(offerings)
+      [ask("What kind?", :choices => offerings.sort_by(&:label),
+        :display => proc do |s|
+          str = "#{c(s.label, :name)} #{s.version}"
+          if s.provider != "core"
+            str << ", via #{s.provider}"
+          end
+          str
+        end,
+        :complete => proc { |s| "#{s.label} #{s.version}" })]
+    end
+
+    def ask_name(offering)
+      default = nil
+      unless offering == JDC::Service::USER_PROVIDED_OFFERING
+        random = sprintf("%x", rand(1000000))
+        default = "#{offering.label}-#{random}"
+      end
+
+      ask "Name?", :default => default
+    end
+
+    def ask_plan(plans)
+      ask "Which plan?",
+        :choices => plans.sort_by(&:name),
+        :indexed => true,
+        :display => proc { |p| "#{p.name}: #{p.description || 'No description'}" },
+        :complete => proc(&:name)
+    end
+  end
+end
+=end

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

@@ -0,0 +1,83 @@
+require "jdc/cli/service/base"
+=begin
+module JDC::Service
+  class Delete < Base
+    desc "Delete a service"
+    group :services, :manage
+    input :service, :desc => "Service to delete", :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 = 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
+
+      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
+=end

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

@@ -0,0 +1,36 @@
+require "jdc/cli/service/base"
+=begin
+module JDC::Service
+  class Rename < Base
+    desc "Rename a service"
+    group :services, :manage
+    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
+=end

data/lib/jdc/cli/service/service.rb

@@ -0,0 +1,42 @@
+require "jdc/cli/service/base"
+
+=begin
+module JDC::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
+      else
+        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
+      end
+    end
+  end
+end
+=end

data/lib/jdc/cli/service/service_instance_helper.rb

@@ -0,0 +1,99 @@
+class ServiceInstanceHelper
+  def self.new(instance)
+    "#{instance.class.name.demodulize}Helper".constantize.new(instance)
+  end
+end
+
+class UserProvidedServiceInstanceHelper
+  def initialize(instance)
+    @instance = instance
+  end
+
+  def service_label
+    "user-provided"
+  end
+
+  def service_provider
+    "n/a"
+  end
+
+  def version
+    "n/a"
+  end
+
+  def plan_name
+    "n/a"
+  end
+
+  def matches(opts = {})
+    label = opts[:service]
+    if label
+      return label == service_label
+    end
+
+    true
+  end
+
+  def name
+    @instance.name
+  end
+
+  def service_bindings
+    @instance.service_bindings
+  end
+end
+
+class ManagedServiceInstanceHelper
+  def initialize(service_instance)
+    @instance = service_instance
+  end
+
+  def service_label
+    @instance.service_plan.service.label
+  end
+
+  def service_provider
+    @instance.service_plan.service.provider
+  end
+
+  def version
+    @instance.service_plan.service.version
+  end
+
+  def plan_name
+    @instance.service_plan.name
+  end
+
+  def service_bindings
+    @instance.service_bindings
+  end
+
+  def name
+    @instance.name
+  end
+
+  def matches(opts = {})
+    service = opts[:service]
+    plan = opts[:plan]
+    provider = opts[:provider]
+    version = opts[:version]
+
+    if service
+      return false unless File.fnmatch(service, service_label)
+    end
+
+    if plan
+      return false unless File.fnmatch(plan.upcase, plan_name.upcase)
+    end
+
+    if provider
+      return false unless File.fnmatch(provider, service_provider)
+    end
+
+    if version
+      return false unless File.fnmatch(version, self.version)
+    end
+
+    true
+  end
+end

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

@@ -0,0 +1,111 @@
+require "jdc/cli/service/base"
+
+=begin
+module JDC::Service
+  class Services < Base
+    desc "List your services"
+    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
+    input :marketplace, :desc => "List supported services", :default => false, :alias => "-m"
+
+    def services
+      return show_marketplace if input[:marketplace]
+
+      set_services
+      return show_full if input[:full]
+      return show_services_table
+    end
+
+    private
+
+    def set_services
+      @services =
+        with_progress(services_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
+    end
+
+    def show_marketplace
+      services = with_progress("Getting services") { client.services }
+
+      line unless quiet?
+
+      table(
+        ["service", "version", "provider", "plans", "description"],
+        services.sort_by(&:label).collect { |s|
+          [c(s.label, :name),
+            s.version,
+            s.provider,
+            s.service_plans.collect(&:name).join(", "),
+            s.description
+          ]
+        })
+    end
+
+    def show_full
+      spaced(@services) do |s|
+        invoke :service, :service => s
+      end
+    end
+
+    def show_services_table
+      table(
+        ["name", "service", "provider", "version", "plan", "bound apps"],
+        @services.collect { |instance|
+          presenter = ServiceInstanceHelper.new(instance)
+          apps     = name_list(presenter.service_bindings.collect(&:app))
+
+          label = presenter.service_label
+          provider = presenter.service_provider
+          version = presenter.version
+          plan_name = presenter.plan_name
+
+          [ c(presenter.name, :name), label, provider, version, plan_name, apps]
+        })
+
+    end
+
+    def services_msg
+      if space = input[:space]
+        "Getting services in #{c(space.name, :name)}"
+      else
+        "Getting services"
+      end
+    end
+
+    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
+
+      helper = ServiceInstanceHelper.new(i)
+      return helper.matches(options)
+    end
+  end
+end
+=end