vmc 0.4.2 → 0.4.3

data/lib/vmc/cli/space.rb

@@ -1,284 +0,0 @@
-require "vmc/cli"
-
-module VMC
-  class Space < CLI
-    def precondition
-      check_target
-      check_logged_in
-
-      fail "This command is v2-only." unless v2?
-    end
-
-    def self.by_name(what, obj = what)
-      proc { |name, *_|
-        client.send(:"#{obj}_by_name", name) ||
-          fail("Unknown #{what} '#{name}'")
-      }
-    end
-
-    def self.space_by_name
-      proc { |name, org, *_|
-        org.space_by_name(name) ||
-          fail("Unknown space '#{name}'")
-      }
-    end
-
-    desc "Show space information"
-    group :spaces
-    input :organization, :aliases => ["--org", "-o"],
-      :from_given => by_name("organization"),
-      :default => proc { client.current_organization },
-      :desc => "Space's organization"
-    input :space, :argument => :optional,
-      :from_given => space_by_name,
-      :default => proc { client.current_space },
-      :desc => "Space to show"
-    input :full, :type => :boolean,
-      :desc => "Show full information for apps, service instances, etc."
-    def space
-      org = input[:organization]
-      space = input[:space, org]
-
-      unless space
-        return if quiet?
-        fail "No current space."
-      end
-
-      if quiet?
-        puts space.name
-        return
-      end
-
-      line "#{c(space.name, :name)}:"
-
-      indented do
-        line "organization: #{c(space.organization.name, :name)}"
-
-        if input[:full]
-          line
-          line "apps:"
-
-          spaced(space.apps(:depth => 2)) do |a|
-            indented do
-              invoke :app, :app => a
-            end
-          end
-        else
-          line "apps: #{name_list(space.apps)}"
-        end
-
-        if input[:full]
-          line
-          line "services:"
-          spaced(space.service_instances(:depth => 2)) do |i|
-            indented do
-              invoke :service, :instance => i
-            end
-          end
-        else
-          line "services: #{name_list(space.service_instances)}"
-        end
-
-        line "domains: #{name_list(space.domains)}"
-      end
-    end
-
-
-    desc "List spaces in an organization"
-    group :spaces
-    input :organization, :argument => :optional, :aliases => ["--org", "-o"],
-      :from_given => by_name("organization"),
-      :default => proc { client.current_organization },
-      :desc => "Organization to list spaces from"
-    input :name, :desc => "Filter by name"
-    input :one_line, :alias => "-l", :type => :boolean, :default => false,
-      :desc => "Single-line tabular format"
-    input :full, :type => :boolean, :default => false,
-      :desc => "Show full information for apps, service instances, etc."
-    def spaces
-      org = input[:organization]
-      spaces =
-        with_progress("Getting spaces in #{c(org.name, :name)}") do
-          org.spaces
-        end
-
-      line unless quiet?
-
-      spaces.reject! do |s|
-        !space_matches(s, input)
-      end
-
-      if input[:one_line]
-        table(
-          %w{name apps services},
-          spaces.collect { |s|
-            [ c(s.name, :name),
-              name_list(s.apps),
-              name_list(s.service_instances)
-            ]
-          })
-      else
-        spaced(spaces) do |s|
-          invoke :space, :space => s, :full => input[:full]
-        end
-      end
-    end
-
-
-    desc "Create a space in an organization"
-    group :spaces
-    input(:name, :argument => :optional, :desc => "Space name") {
-      ask("Name")
-    }
-    input :organization, :argument => :optional, :aliases => ["--org", "-o"],
-      :from_given => by_name("organization"),
-      :default => proc { client.current_organization },
-      :desc => "Parent organization"
-    input :target, :alias => "-t", :type => :boolean,
-      :desc => "Switch to the space after creation"
-    input :manager, :type => :boolean, :default => true,
-      :desc => "Add current user as manager"
-    input :developer, :type => :boolean, :default => true,
-      :desc => "Add current user as developer"
-    input :auditor, :type => :boolean, :default => false,
-      :desc => "Add current user as auditor"
-    def create_space
-      space = client.space
-      space.organization = input[:organization]
-      space.name = input[:name]
-
-      with_progress("Creating space #{c(space.name, :name)}") do
-        space.create!
-      end
-
-      if input[:manager]
-        with_progress("Adding you as a manager") do
-          space.add_manager client.current_user
-        end
-      end
-
-      if input[:developer]
-        with_progress("Adding you as a developer") do
-          space.add_developer client.current_user
-        end
-      end
-
-      if input[:auditor]
-        with_progress("Adding you as an auditor") do
-          space.add_auditor client.current_user
-        end
-      end
-
-      if input[:target]
-        invoke :target, :organization => space.organization,
-          :space => space
-      end
-    end
-
-
-    desc "Switch to a space, creating it if it doesn't exist"
-    group :spaces, :hidden => true
-    input :name, :argument => true, :desc => "Space name"
-    def take_space
-      if space = client.space_by_name(input[:name])
-        invoke :target, :space => space
-      else
-        invoke :create_space, :name => input[:name], :target => true
-      end
-    end
-
-
-    desc "Delete a space and its contents"
-    group :spaces
-    input(:spaces, :argument => :splat,
-          :from_given => space_by_name,
-          :desc => "Space to delete") { |org|
-      spaces = org.spaces
-      fail "No spaces." if spaces.empty?
-
-      [ask("Which space in #{c(org.name, :name)}?", :choices => spaces,
-           :display => proc(&:name))]
-    }
-    input :organization, :aliases => ["--org", "-o"],
-      :from_given => by_name("organization"),
-      :default => proc { client.current_organization },
-      :desc => "Space's organization"
-    input(:really, :type => :boolean, :forget => true,
-          :default => proc { force? || interact }) { |space|
-      ask("Really delete #{c(space.name, :name)}?", :default => false)
-    }
-    input(:recursive, :alias => "-r", :type => :boolean, :forget => true) {
-      ask "Delete #{c("EVERYTHING", :bad)}?", :default => false
-    }
-    input :warn, :type => :boolean, :default => true,
-      :desc => "Show warning if it was the last space"
-    def delete_space
-      org = input[:organization]
-      spaces = input[:spaces, org]
-
-      deleted_current = false
-
-      spaces.each do |space|
-        next unless input[:really, space]
-
-        next unless clear_space(space)
-
-        deleted_current ||= space == client.current_space
-
-        with_progress("Deleting space #{c(space.name, :name)}") do
-          space.delete!
-        end
-      end
-
-      org.invalidate!
-
-      if org.spaces.empty?
-        return unless input[:warn]
-
-        line
-        line c("There are no longer any spaces in #{b(org.name)}.", :warning)
-        line "You may want to create one with #{c("create-space", :good)}."
-      elsif deleted_current
-        invalidate_client
-        invoke :target, :organization => client.current_organization
-      end
-    end
-
-    private
-
-    def space_matches(s, options)
-      if name = options[:name]
-        return false if s.name !~ /#{name}/
-      end
-
-      true
-    end
-
-    def clear_space(space)
-      apps = space.apps
-      instances = space.service_instances
-
-      return true if apps.empty? && instances.empty?
-
-      unless force?
-        line "This space is not empty!"
-        line
-        line "apps: #{name_list(apps)}"
-        line "service instances: #{name_list(instances)}"
-        line
-
-        return unless input[:recursive]
-      end
-
-      apps.each do |a|
-        invoke :delete, :app => a, :really => true
-      end
-
-      instances.each do |i|
-        invoke :delete_service, :instance => i, :really => true
-      end
-
-      true
-    end
-  end
-end

data/lib/vmc/cli/start.rb

@@ -1,432 +0,0 @@
-require "vmc/cli"
-
-module VMC
-  class Start < CLI
-    # 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; end
-
-
-    def self.find_by_name(what)
-      proc { |name, choices|
-        choices.find { |c| c.name == name } ||
-          fail("Unknown #{what} '#{name}'")
-      }
-    end
-
-
-    desc "Display information on the current target, user, etc."
-    group :start
-    input :runtimes, :type => :boolean,
-      :desc => "List supported runtimes"
-    input :frameworks, :type => :boolean,
-      :desc => "List supported frameworks"
-    input :services, :type => :boolean,
-      :desc => "List supported services"
-    input :all, :type => :boolean, :alias => "-a",
-      :desc => "Show all information"
-    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
-
-      info = client.info
-
-      showing_any = runtimes || services || frameworks
-
-      unless !all && showing_any
-        line if showing_any
-        line info[:description]
-        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
-
-    desc "Set or display the target cloud, organization, and space"
-    group :start
-    input :url, :argument => :optional, :desc => "Target URL to switch to"
-    input(:organization, :aliases => ["--org", "-o"],
-          :from_given => find_by_name("organization"),
-          :desc => "Organization") { |orgs|
-      ask("Organization", :choices => orgs, :display => proc(&:name))
-    }
-    input(:space, :alias => "-s",
-          :from_given => find_by_name("space"),
-          :desc => "Space") { |spaces|
-      ask("Space", :choices => spaces, :display => proc(&:name))
-    }
-    def target
-      if !input.given?(:url) && !input.given?(:organization) && !input.given?(:space)
-        display_target
-        display_org_and_space unless quiet?
-        return
-      end
-
-      if input.given?(:url)
-        target = sane_target_url(input[:url])
-        with_progress("Setting target to #{c(target, :name)}") do
-          client(target).info # check that it's valid before setting
-          set_target(target)
-        end
-      end
-
-      return unless v2? && client.logged_in?
-
-      if input.given?(:organization) || input.given?(:space)
-        info = target_info
-
-        select_org_and_space(input, info)
-
-        save_target_info(info)
-      end
-
-      return if quiet?
-
-      invalidate_client
-
-      line
-      display_target
-      display_org_and_space
-    end
-
-
-    desc "List known targets."
-    group :start, :hidden => true
-    def targets
-      targets_info.each do |target, _|
-        line target
-        # TODO: print org/space
-      end
-    end
-
-
-    desc "Authenticate with the target"
-    group :start
-    input :username, :alias => "--email", :argument => :optional,
-      :desc => "Account email"
-    input :password, :desc => "Account password"
-    input(:organization, :aliases => ["--org", "-o"],
-          :from_given => find_by_name("organization"),
-          :desc => "Organization") { |orgs|
-      ask("Organization", :choices => orgs, :display => proc(&:name))
-    }
-    input(:space, :alias => "-s",
-          :from_given => find_by_name("space"),
-          :desc => "Space") { |spaces|
-      ask("Space", :choices => spaces, :display => proc(&:name))
-    }
-    def login
-      show_context
-
-      credentials =
-        { :username => input[:username],
-          :password => input[:password]
-        }
-
-      prompts = client.login_prompts
-
-      # ask username first
-      if prompts.key? :username
-        type, label = prompts.delete :username
-        credentials[:username] ||= ask_prompt(type, label)
-      end
-
-      info = target_info
-
-      authenticated = false
-      failed = false
-      remaining_attempts = 3
-      until authenticated || remaining_attempts <= 0
-        remaining_attempts -= 1
-        unless force?
-          ask_prompts(credentials, prompts)
-        end
-
-        with_progress("Authenticating") do |s|
-          begin
-            info[:token] = client.login(credentials)
-            authenticated = true
-          rescue CFoundry::Denied
-            return if force?
-
-            s.fail do
-              failed = true
-              credentials.delete(:password)
-            end
-          end
-        end
-      end
-
-      save_target_info(info)
-      invalidate_client
-
-      if v2?
-        line if input.interactive?(:organization) || input.interactive?(:space)
-        select_org_and_space(input, info)
-        save_target_info(info)
-      end
-    ensure
-      exit_status 1 if not authenticated
-    end
-
-
-    desc "Log out from the target"
-    group :start
-    def logout
-      with_progress("Logging out") do
-        remove_target_info
-      end
-    end
-
-
-    desc "Create a user and log in"
-    group :start, :hidden => true
-    input(:email, :argument => true, :desc => "Desired email") {
-      ask("Email")
-    }
-    input(:password, :desc => "Desired password") {
-      ask("Password", :echo => "*", :forget => true)
-    }
-    input(:verify, :desc => "Repeat password") {
-      ask("Confirm Password", :echo => "*", :forget => true)
-    }
-    input :login, :type => :boolean, :default => true,
-      :desc => "Automatically log in?"
-    def register
-      show_context
-
-      email = input[:email]
-      password = input[:password]
-
-      if !force? && password != input[:verify]
-        fail "Passwords do not match."
-      end
-
-      with_progress("Creating user") do
-        client.register(email, password)
-      end
-
-      if input[:login]
-        invoke :login, :username => email, :password => password
-      end
-    end
-
-
-    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
-
-    private
-
-    def ask_prompt(type, label)
-      if type == "password"
-        options = { :echo => "*", :forget => true }
-      else
-        options = {}
-      end
-
-      ask(label, options)
-    end
-
-    def ask_prompts(credentials, prompts)
-      prompts.each do |name, meta|
-        type, label = meta
-        credentials[name] ||= ask_prompt(type, label)
-      end
-    end
-
-    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 display_org_and_space
-      return unless v2?
-
-      if org = client.current_organization
-        line "organization: #{c(org.name, :name)}"
-      end
-
-      if space = client.current_space
-        line "space: #{c(space.name, :name)}"
-      end
-    rescue CFoundry::APIError
-    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
-
-    def select_org_and_space(input, info)
-      changed_org = false
-
-      if input.given?(:organization) || !org_valid?(info[:organization])
-        orgs = client.organizations
-        fail "No organizations!" if orgs.empty?
-
-        if orgs.size == 1 && !input.given?(:organization)
-          org = orgs.first
-        else
-          org = input[:organization, orgs.sort_by(&:name)]
-        end
-
-        with_progress("Switching to organization #{c(org.name, :name)}") do
-          info[:organization] = org.guid
-          changed_org = true
-        end
-      else
-        org = client.current_organization
-      end
-
-      # switching org means switching space
-      if changed_org || input.given?(:space) || !space_valid?(info[:space])
-        spaces = org.spaces
-
-        if spaces.empty?
-          if changed_org
-            line c("There are no spaces in #{b(org.name)}.", :warning)
-            line "You may want to create one with #{c("create-space", :good)}."
-            return
-          else
-            fail "No spaces!"
-          end
-        end
-
-        if spaces.size == 1 && !input.given?(:space)
-          space = spaces.first
-        else
-          line if changed_org && input.interactive?(:organization)
-          space = input[:space, spaces.sort_by(&:name)]
-        end
-
-        with_progress("Switching to space #{c(space.name, :name)}") do
-          info[:space] = space.guid
-        end
-      end
-    end
-  end
-end