hula 0.7.1

data/lib/hula/cloud_foundry.rb

@@ -0,0 +1,308 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'tmpdir'
+require 'json'
+require 'open3'
+require 'tempfile'
+
+require 'hula/command_runner'
+require 'hula/cloud_foundry/service_broker'
+
+module Hula
+  class CloudFoundry
+    attr_reader :current_organization, :current_space, :domain, :api_url
+
+    def initialize(args)
+      @domain = args.fetch(:domain)
+      @api_url = args.fetch(:api_url)
+      @logger = args.fetch(:logger, default_logger)
+      @command_runner = args.fetch(:command_runner, default_command_runner)
+
+      target_and_login = args.fetch(:target_and_login, true)
+      if target_and_login
+        target(api_url)
+        login(args.fetch(:username), args.fetch(:password))
+      end
+    end
+
+    def url_for_app(app_name)
+      "https://#{app_name}.#{domain}"
+    end
+
+    def target(cloud_controller_url)
+      cf("api #{cloud_controller_url} --skip-ssl-validation")
+    end
+
+    def app_vcap_services(app_name)
+      app_environment(app_name)["VCAP_SERVICES"]
+    end
+
+    def login(username, password, allow_failure = true)
+      cf("auth #{username} #{password}", allow_failure: allow_failure)
+    end
+
+    def service_brokers
+      output = cf('service-brokers')
+
+      if output.include?('No service brokers found')
+        []
+      else
+        output.split("\n").drop(3).map do |row|
+          name, url = row.split(/\s+/)
+          ServiceBroker.new(name: name, url: url)
+        end
+      end
+    end
+
+    def create_and_target_org(name)
+      create_org(name)
+      sleep 1
+      target_org(name)
+    end
+
+    def create_org(name)
+      cf("create-org #{name}")
+    end
+
+    def target_org(name)
+      cf("target -o #{name}")
+      @current_organization = name
+    end
+
+    def create_and_target_space(name)
+      create_space(name)
+      target_space(name)
+    end
+
+    def create_space(name)
+      cf("create-space #{name}")
+    end
+
+    def target_space(name)
+      cf("target -s #{name}")
+      @current_space = name
+    end
+
+    def space_exists?(name)
+      spaces = cf('spaces').lines[3..-1]
+      spaces.map(&:strip).include?(name)
+    end
+
+    def org_exists?(name)
+      orgs = cf('orgs').lines[3..-1]
+      orgs.map(&:strip).include?(name)
+    end
+
+    def setup_permissive_security_group(org, space)
+      rules = [{
+        'destination' => '0.0.0.0-255.255.255.255',
+        'protocol' => 'all'
+      }]
+
+      rule_file = Tempfile.new('default_security_group.json')
+      rule_file.write(rules.to_json)
+      rule_file.close
+
+      cf("create-security-group prof-test #{rule_file.path}")
+      cf("bind-security-group prof-test #{org} #{space}")
+      cf('bind-staging-security-group prof-test')
+      cf('bind-running-security-group prof-test')
+
+      rule_file.unlink
+    end
+
+    def delete_space(name, options = {})
+      allow_failure = options.fetch(:allow_failure, true)
+      cf("delete-space #{name} -f", allow_failure: allow_failure)
+    end
+
+    def delete_org(name, options = {})
+      allow_failure = options.fetch(:allow_failure, true)
+      cf("delete-org #{name} -f", allow_failure: allow_failure)
+    end
+
+    alias_method :reset!, :delete_org
+
+    def add_public_service_broker(service_name, _service_label, url, username, password)
+      cf("create-service-broker #{service_name} #{username} #{password} #{url}")
+
+      service_plans = JSON.parse(cf('curl /v2/service_plans -X GET'))
+      guids = service_plans['resources'].map do |resource|
+        resource['metadata']['guid']
+      end
+
+      guids.each do |guid|
+        cf(%(curl /v2/service_plans/#{guid} -X PUT -d '{"public":true}'))
+      end
+    end
+
+    def remove_service_broker(service_name, options = {})
+      allow_failure = options.fetch(:allow_failure, true)
+      cf("delete-service-broker #{service_name} -f", allow_failure: allow_failure)
+    end
+
+    def assert_broker_is_in_marketplace(type)
+      output = marketplace
+      unless output.include?(type)
+        fail "Broker #{type} not found in marketplace"
+      end
+    end
+
+    def marketplace
+      cf('marketplace')
+    end
+
+    def create_service_instance(type, name, plan)
+      cf("create-service #{type} #{plan} #{name}")
+    end
+
+    def delete_service_instance_and_unbind(name, options = {})
+      allow_failure = options.fetch(:allow_failure, true)
+      cf("delete-service -f #{name}", allow_failure: allow_failure)
+    end
+
+    def assert_instance_is_in_services_list(service_name)
+      output = cf('services')
+      unless output.include?(service_name)
+        fail "Instance #{service_name} not found in services list"
+      end
+    end
+
+    def push_app_and_start(app_path, name)
+      push_app(app_path, name)
+      start_app(name)
+    end
+
+    def push_app(app_path, name)
+      cf("push #{name} -p #{app_path} -n #{name} -d #{domain} --no-start")
+    end
+
+    def enable_diego_for_app(name)
+      cf("enable-diego #{name}")
+    end
+
+    def delete_app(name, options = {})
+      allow_failure = options.fetch(:allow_failure, true)
+      cf("delete #{name} -f", allow_failure: allow_failure)
+    end
+
+    def bind_app_to_service(app_name, service_name)
+      cf("bind-service #{app_name} #{service_name}")
+    end
+
+    def unbind_app_from_service(app_name, service_name)
+      cf("unbind-service #{app_name} #{service_name}")
+    end
+
+    def list_service_keys(service_instance_name)
+      cf("service-keys #{service_instance_name}")
+    end
+
+    def create_service_key(service_instance_name, key_name)
+      cf("create-service-key #{service_instance_name} #{key_name}")
+    end
+
+    def delete_service_key(service_instance_name, key_name)
+      cf("delete-service-key #{service_instance_name} #{key_name} -f")
+    end
+
+    def service_key(service_instance_name, key_name)
+      cf("service-key #{service_instance_name} #{key_name}")
+    end
+
+    def restart_app(name)
+      stop_app(name)
+      start_app(name)
+    end
+
+    def start_app(name)
+      cf("start #{name}")
+    rescue => start_exception
+      begin
+        cf("logs --recent #{name}")
+      ensure
+        raise start_exception
+      end
+    end
+
+    def stop_app(name)
+      cf("stop #{name}")
+    end
+
+    def app_env(app_name)
+      cf("env #{app_name}")
+    end
+
+    def create_user(username, password)
+      cf("create-user #{username} #{password}")
+    end
+
+    def delete_user(username)
+      cf("delete-user -f #{username}")
+    end
+
+    def user_exists?(username, org)
+      output = cf("org-users #{org}")
+      output.lines.select { |l| l.start_with? '  ' }.map(&:strip).uniq.include?(username)
+    end
+
+    def set_org_role(username, org, role)
+      cf("set-org-role #{username} #{org} #{role}")
+    end
+
+    def version
+      cf('-v')
+    end
+
+    private
+
+    attr_reader :logger, :command_runner
+
+    def app_environment(app_name)
+      env_output = cf("env #{app_name}")
+      response = env_output[/^\{.*}$/m].split(/^\n/)
+      response = response.map { |json| JSON.parse(json) }
+      response.inject({}) { |result, current| result.merge(current) }
+    end
+
+    def default_logger
+      @default_logger ||= begin
+        STDOUT.sync = true
+        require 'logger'
+        Logger.new(STDOUT)
+      end
+    end
+
+    def default_command_runner
+      @default_command_runner ||= CommandRunner.new(environment: env)
+    end
+
+    def cf(command, options = {})
+      allow_failure = options.fetch(:allow_failure, false)
+      cf_command = "cf #{command}"
+
+      logger.info(cf_command)
+
+      command_runner.run(cf_command, allow_failure: allow_failure)
+    end
+
+    def env
+      @env ||= ENV.to_hash.merge(
+        'PATH'    => clean_path,
+        'CF_HOME' => Dir.mktmpdir('cf-home')
+      )
+    end
+
+    def clean_path
+      '/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin/:sbin'
+    end
+  end
+end

data/lib/hula/command_runner.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'open3'
+
+module Hula
+  class CommandFailedError < StandardError; end
+
+  class CommandRunner
+    def initialize(environment: ENV)
+      @environment = environment
+    end
+
+    def run(command, allow_failure: false)
+      stdout_and_stderr, status = Open3.capture2e(environment, command)
+
+      if !allow_failure && !status.success?
+        message = "Command failed! - #{command}\n\n#{stdout_and_stderr}\n\nexit status: #{status.exitstatus}"
+        fail CommandFailedError, message
+      end
+
+      stdout_and_stderr
+    rescue => e
+      raise CommandFailedError, e
+    end
+
+    private
+
+    attr_reader :environment
+  end
+end

data/lib/hula/helpers/socket_tools.rb

@@ -0,0 +1,44 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'hula/helpers/timeout_tools'
+
+require 'socket'
+
+module Hula
+  module Helpers
+    module SocketTools
+      module_function def wait_for_port(host:, port:, timeout_seconds: 20)
+        error = "Failed to connect to #{host}:#{port} within #{timeout_seconds} seconds"
+        TimeoutTools.wait_for(error: error, timeout_seconds: timeout_seconds) do
+          port_open?(host: host, port: port)
+        end
+      end
+
+      module_function def port_open?(host:, port:)
+        socket = TCPSocket.new(host, port)
+        socket.close unless socket.nil?
+        true
+      rescue Errno::ECONNREFUSED
+        false
+      end
+
+      module_function def free_port
+        socket = Socket.new(:INET, :STREAM, 0)
+        socket.bind(Addrinfo.tcp('127.0.0.1', 0))
+        socket.local_address.ip_port
+      ensure
+        socket.close
+      end
+    end
+  end
+end
+
+

data/lib/hula/helpers/timeout_tools.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'timeout'
+
+module Hula
+  module Helpers
+    module TimeoutTools
+      module_function def wait_for(error: nil, timeout_seconds:, &condition_block)
+        Timeout::timeout(timeout_seconds) do
+          until condition_block.call do
+            sleep 0.1
+          end
+        end
+      rescue Timeout::Error => e
+        error ? raise(error) : raise(e)
+      end
+    end
+  end
+end

data/lib/hula/http_proxy_upstream_socks.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'hula/helpers/socket_tools'
+
+module Hula
+  class HttpProxyUpstreamSocks
+    include Helpers::SocketTools
+
+    def initialize(
+      polipo_bin: 'polipo',
+      socks_proxy:,
+      http_host: 'localhost',
+      http_port: free_port
+    )
+      @socks_proxy_host = socks_proxy.socks_host
+      @socks_proxy_port = socks_proxy.socks_port
+      @http_host = http_host
+      @http_port = http_port
+      @polipo_bin = polipo_bin
+
+      check_polipo_bin!
+    end
+
+    attr_reader :http_host, :http_port
+
+    def start
+      @process ||= start_polipo_process
+    end
+
+    def stop
+      return unless @process
+
+      Process.kill('TERM', @process) rescue Errno::ESRCH
+      Process.wait(@process)         rescue Errno::ECHILD
+      @process = nil
+    end
+
+    private
+
+    attr_reader :socks_proxy_host, :socks_proxy_port, :polipo_bin
+
+
+    def start_polipo_process
+      pid = Process.spawn(polipo_command)
+      at_exit { stop }
+      wait_for_port(host: http_host, port: http_port)
+      Process.detach(pid)
+      pid
+    end
+
+    def polipo_command
+      "#{polipo_bin} diskCacheRoot='' \
+        proxyPort=#{http_port} \
+        socksParentProxy=#{socks_proxy_host}:#{socks_proxy_port} \
+        socksProxyType=socks4a"
+    end
+
+    def check_polipo_bin!
+      unless system("which #{polipo_bin} > /dev/null 2>&1")
+        raise "Could not run polipo (#{polipo_bin}). Please install, or put in PATH"
+      end
+    end
+  end
+end

data/lib/hula/service_broker/api.rb

@@ -0,0 +1,123 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'forwardable'
+require 'hula/service_broker/catalog'
+require 'hula/service_broker/instance_binding'
+require 'hula/service_broker/http_json_client'
+require 'hula/service_broker/service_instance'
+
+require 'securerandom'
+
+module Hula
+  module ServiceBroker
+    class Api
+      extend Forwardable
+      def_delegators :catalog, :service_plan
+
+      def initialize(url:, username:, password:, http_client: HttpJsonClient.new)
+        @http_client = http_client
+
+        @url = URI(url)
+        @username = username
+        @password = password
+      end
+
+      attr_reader :url
+
+      def catalog
+        json = http_client.get(url_for('/v2/catalog'), auth: { username: username, password: password })
+        Catalog.new(json)
+      end
+
+      def provision_instance(plan, service_instance_id: SecureRandom.uuid)
+        http_provision_instance(
+          service_id: plan.service_id,
+          plan_id: plan.id,
+          service_instance_id: service_instance_id
+        )
+
+        ServiceInstance.new(id: service_instance_id)
+      end
+
+      def deprovision_instance(service_instance)
+        http_deprovision_service(service_instance_id: service_instance.id)
+      end
+
+      def bind_instance(service_instance, binding_id: SecureRandom.uuid)
+        result = http_bind_instance(
+          service_instance_id: service_instance.id,
+          binding_id: binding_id
+        )
+
+        InstanceBinding.new(
+          id: binding_id,
+          credentials: result.fetch(:credentials),
+          service_instance: service_instance
+        )
+      end
+
+      def unbind_instance(instance_binding)
+        http_unbind_instance(
+          service_instance_id: instance_binding.service_instance.id,
+          binding_id: instance_binding.id
+        )
+      end
+
+      def debug
+        http_client.get(url_for('/debug'), auth: { username: username, password: password })
+      end
+
+      private
+
+      def http_provision_instance(service_instance_id:, service_id:, plan_id:)
+        http_client.put(
+          url_for("/v2/service_instances/#{service_instance_id}"),
+          body: {
+            service_id: service_id,
+            plan_id: plan_id,
+          },
+          auth: { username: username, password: password }
+        )
+      end
+
+      def http_deprovision_service(service_instance_id:)
+        http_client.delete(
+          url_for("/v2/service_instances/#{service_instance_id}"),
+          auth: {
+            username: username,
+            password: password
+          }
+        )
+      end
+
+      def http_bind_instance(service_instance_id:, binding_id:)
+        http_client.put(
+          url_for("/v2/service_instances/#{service_instance_id}/service_bindings/#{binding_id}"),
+          body: {},
+          auth: { username: username, password: password }
+        )
+      end
+
+      def http_unbind_instance(service_instance_id:, binding_id:)
+        http_client.delete(
+          url_for("/v2/service_instances/#{service_instance_id}/service_bindings/#{binding_id}"),
+          auth: { username: username, password: password }
+        )
+      end
+
+      def url_for(path)
+        url.dup.tap { |uri| uri.path += path }
+      end
+
+      attr_reader :http_client, :username, :password
+    end
+  end
+end

data/lib/hula/service_broker/catalog.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2014-2015 Pivotal Software, Inc.
+# All rights reserved.
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+# USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'hula/service_broker/errors'
+require 'hula/service_broker/service'
+
+module Hula
+  module ServiceBroker
+
+    class Catalog
+      attr_reader :services
+
+      def initialize(args = {})
+        @services = args.fetch(:services).map { |s| Service.new(s) }
+      end
+
+      def ==(other)
+        is_a?(other.class) &&
+          services == other.services
+      end
+
+      def service(service_name)
+        services.find { |s| s.name == service_name } or
+          fail(ServiceNotFoundError, [
+            %{Unknown service with name: #{service_name.inspect}},
+            "  Known service names: #{services.map(&:name).inspect}"
+            ].join("\n")
+          )
+      end
+
+      def service_plan(service_name, plan_name)
+        service(service_name).plan(plan_name)
+      end
+    end
+  end
+end