vcap_common 2.0.11 → 3.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTdhMGU2ZWM5ZGJkZGFmODY3NjE0NzUzMWY4NTRiNjMyM2I2OTEzMw==
+  data.tar.gz: !binary |-
+    MGJlYjExMzJiMjEyYjRmMGMwZTczYTU3YzA2NmI0MGY0NTI2NGM4MA==
+SHA512:
+  metadata.gz: !binary |-
+    Mjc0MmI5NzczZmYyOGE1YTY0ZTI4MTJjYjdjN2EwOWJlMTFjMzc5NDczNGU0
+    MDc4ZTRiMWEzYTZjMjFiMzhhZGY1OTJkZTIxZDlhN2VkMjRhZDA4NDNkZDEz
+    OGU4ZGFkNmI3NjNjNjcyMWE4MzdmMTQ0MjBlYjNjZTFjZjRiODQ=
+  data.tar.gz: !binary |-
+    YWUxZmU5OTMxNjE3MWI4MWQ5MTkxZTBkMDJmOGI5NTlmYTRkNjVhNjUyZGVi
+    NDAyM2U2MjRlZWIxOTEwMDQ3OTRhNjhmNzhjYjBjNDA0NjAyNzIyZDk1NmEz
+    OTk0Yjg2NDdkYmUzMGRiZjliNjU3MGRmMDdlNmFhOTM2YjU5NDI=

data/bin/fetch_gems

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+require 'fileutils'
+require 'logger'
+
+# Provides functionality similar to `bundle package`, but without needing
+# to install any gems.
+
+unless ARGV.length == 3
+  puts "Usage: fetch_gems [/path/to/Gemfile] [/path/to/Gemfile.lock] [/path/to/store]"
+  exit 1
+end
+
+gemfile_path, lockfile_path, gem_store_dir = ARGV.map {|path| File.expand_path(path) }
+
+ENV['BUNDLE_GEMFILE'] = gemfile_path
+
+lockfile_contents = File.read(lockfile_path)
+parser = Bundler::LockfileParser.new(lockfile_contents)
+
+logger = Logger.new(STDOUT)
+
+if parser.specs.empty?
+  logger.info("No gems found")
+  exit 0
+end
+
+FileUtils.mkdir_p(gem_store_dir)
+
+to_fetch = []
+parser.specs.each do |spec|
+  gem_basename = "#{spec.name}-#{spec.version}.gem"
+  dst_path = File.join(gem_store_dir, gem_basename)
+  if spec.source.kind_of?(Bundler::Source::Path) && (spec.source.path.to_s == '.')
+    logger.info("Skipping '#{gem_basename}', Gemfile.lock appears to belong to it")
+  elsif File.exist?(dst_path)
+    logger.info("Skipping '#{gem_basename}', found in '#{gem_store_dir}'")
+  else
+    logger.info("Need to download '#{gem_basename}'")
+    to_fetch << gem_basename
+  end
+end
+
+unless to_fetch.empty?
+  urls = to_fetch.map do |gem_basename|
+    "http://production.s3.rubygems.org/gems/#{gem_basename}"
+  end.join(' ')
+
+  cmd = "wget --quiet --retry-connrefused --connect-timeout=5"
+  cmd += " --no-check-certificate --directory-prefix #{gem_store_dir} #{urls}"
+
+  logger.info("Fetching #{to_fetch.join(', ')} from rubygems")
+  logger.info("Executing '#{cmd}'")
+
+  unless system(cmd)
+    logger.error("#{cmd} failed with status #{$?}!")
+    exit $?.exitstatus
+  end
+end
+
+logger.info("Done")

data/bin/transform_git_source

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# vim: fileencoding=utf-8
+# vim: ts=2 sw=2 sts=2 et
+
+require 'rubygems'
+require 'bundler'
+require 'fileutils'
+require 'logger'
+
+# Rewrite git sources in Gemfile and lock files to paths
+#
+# Usage: transform_git_source path/to/dir_w_Gemfile path/to/git/checkout
+
+def `(cmd)
+  @logger.debug "executing #{cmd}"
+  result = super
+  raise RuntimeError, "error while attempting to execute #{cmd}" unless $?.exitstatus == 0
+  result
+end
+
+def checkout(spec, path)
+  unless path.join('.git').exist?
+    path.parent.mkpath
+    path.rmtree if path.exist?
+    %x(git clone --no-checkout #{spec.source.uri} #{path})
+  end
+  Dir.chdir(path) do
+    %x(git fetch --quiet --tags #{spec.source.uri})
+    # This is gross, but why do they keep this private?
+    revision = spec.source.send(:revision)
+    %x(git reset --hard #{revision})
+  end
+end
+
+# Derived from Bundler::Definition#to_lock
+# Copyright Bundler contributors
+# Portions copyright (c) 2010 André Arko
+# Portions copyright (c) 2009 Engine Yard
+def to_lock(specs, platforms, dependencies)
+  out = ""
+
+  specs.map {|s| s.source}.sort_by { |s| s.class.to_s }.uniq.each do |source|
+    # Add the source header
+    out << source.to_lock
+    # Find all specs for this source
+    specs.
+      select  { |s| s.source == source }.
+      # This needs to be sorted by full name so that
+      # gems with the same name, but different platform
+      # are ordered consistantly
+      sort_by { |s| s.full_name }.
+      each do |spec|
+        next if spec.name == 'bundler'
+        out << spec.to_lock
+    end
+    out << "\n"
+  end
+
+  out << "PLATFORMS\n"
+
+  platforms.map { |p| p.to_s }.sort.each do |p|
+    out << "  #{p}\n"
+  end
+
+  out << "\n"
+  out << "DEPENDENCIES\n"
+
+  handled = []
+  dependencies.
+    sort_by { |d| d.to_s }.
+    each do |dep|
+      next if handled.include?(dep.name)
+      out << dep.to_lock
+      handled << dep.name
+  end
+
+  out
+end
+
+def rewrite_lockfile(lockfile, checkout_base)
+  parser = Bundler::LockfileParser.new(lockfile.read)
+
+  candidates = parser.specs.select { |s| Bundler::Source::Git === s.source }
+  if candidates.empty?
+    @logger.info 'Nothing to see here, move along'
+    return
+  end
+
+  gemsrc = parser.sources.find { |s| Bundler::Source::Rubygems === s } ||
+    Bundler::Source::Rubygems.from_lock('remote' => 'http://rubygems.org')
+  lockfile.parent.join('vendor', 'cache').mkpath
+  candidates.each do |spec|
+    # TODO: shall i sanitize spec.name?
+    checkout_dir = checkout_base.join(spec.name)
+    checkout(spec, checkout_dir)
+    # TODO error handling
+    gem_dir = Pathname.glob("#{checkout_dir}/**/#{spec.name}.gemspec")[0].parent
+    Dir.chdir(gem_dir) do |dir|
+      %x(gem build #{spec.name}.gemspec)
+      gempath = gem_dir.join("#{spec.name}-#{spec.version}.gem")
+      FileUtils.link([gempath.to_s], lockfile.parent.join('vendor', 'cache').to_s, :verbose => true)
+    end
+    spec.source = gemsrc
+    # make the dependency have "no specified source"
+    parser.dependencies.find { |d| d.name == spec.name }.source = nil
+  end
+
+  lockfile.open('w') do |f|
+    f.puts to_lock(parser.specs, parser.platforms, parser.dependencies)
+  end
+end
+
+# We don't attempt to be a full ruby parser, only rewrite Gemfiles we wrote
+def rewrite_gemfile(gemfile, checkout_base)
+  out = ''
+  probe = Object.new
+  class << probe
+    attr_reader :name, :version, :options, :path
+    def gem(name, *args)
+      @name = name
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+      @version = args
+      unless @options.include?(:git)
+        raise ArgumentError, ':git option expected, none found'
+      end
+    end
+  end
+
+  gemfile.each_line do |line|
+    case line
+    when /^\s*gem.*:git/
+      if line =~ /#.*:git/ && line !~ /^[^#]+:git/
+        out << line
+        next
+      end
+      probe.instance_eval(line)
+      out << "gem #{probe.name.inspect}"
+      out << ", #{probe.version.map(&:inspect).join(', ')}" unless probe.version.empty?
+      out << "\n"
+    else
+      out << line
+    end
+  end
+  gemfile.open('w') { |f| f.write(out) }
+end
+
+if __FILE__ == $0
+  unless ARGV.length == 2
+    puts <<-USAGE
+Incorrect number of arguments! Usage:
+    #{File.basename(__FILE__)} path/to/dir_with_Gemfile path/to/place/git/checkouts
+    USAGE
+    exit 1
+  end
+
+  @logger = Logger.new(STDERR)
+  project_dir, checkout_base = ARGV.map { |x| Pathname.new(x).expand_path }
+  ENV['BUNDLE_GEMFILE'] = project_dir.join('Gemfile').to_s
+  rewrite_lockfile(project_dir.join('Gemfile.lock'), checkout_base)
+  rewrite_gemfile(project_dir.join('Gemfile'), checkout_base)
+end

data/lib/cf/version.rb

@@ -0,0 +1,3 @@
+module Cf
+  VERSION = "3.0.0".freeze
+end

data/lib/json_message.rb

@@ -167,9 +167,7 @@ class JsonMessage
     name = name.to_sym
     field = self.class.fields[name]
 
-    unless field
-      raise ValidationError.new( { name => "Unknown field: #{name}" } )
-    end
+    return unless field
 
     field.validate(value)
     @msg[name] = value
@@ -185,7 +183,7 @@ class JsonMessage
     unless @msg.has_key?(name)
       field = self.class.fields[name]
       if field
-        @msg[name] = field.default if field.default
+        @msg[name] = field.default unless field.default.nil?
       end
     end
   end

data/lib/services/api/clients/service_gateway_client.rb

@@ -15,13 +15,6 @@ end
 
 module VCAP::Services::Api
   class ServiceGatewayClient
-    METHODS_MAP = {
-      :get => Net::HTTP::Get,
-      :post=> Net::HTTP::Post,
-      :put => Net::HTTP::Put,
-      :delete => Net::HTTP::Delete,
-    }
-
     # Public: Indicate gateway client encounter an unexpected error,
     # such as can't connect to gateway or can't decode response.
     #
@@ -41,7 +34,16 @@ module VCAP::Services::Api
       end
 
       def to_s
-        "Reponse status:#{status},error:[#{error.extract}]"
+        "#{self.class.name}: #{error.description}"
+      end
+
+      def to_h
+        {
+          'error' => error.extract(stringify_keys: true).merge(
+            'backtrace' => backtrace,
+            'types' => self.class.ancestors.map(&:name) - Exception.ancestors.map(&:name)
+          )
+        }
       end
     end
 
@@ -57,127 +59,140 @@ module VCAP::Services::Api
       end
     end
 
-    attr_reader :host, :port, :token
-    attr_reader :requester
-    def initialize(url, token, timeout, opts={})
-      @url = url
-      @timeout = timeout
-      @token = token
-      @hdrs  = {
-        'Content-Type' => 'application/json',
-        GATEWAY_TOKEN_HEADER => @token
-      }
-      # contract: @requester.responds_to? :request(url, token, timeout, [msg])
-      # contract @requester.request(url, token, timeout, [msg]) => [code, body]
-      @requester = opts[:requester] || AsyncHttpRequest
+    attr_reader :http_client
+
+    def initialize(url, token, timeout, request_id)
+      @http_client = HttpClient.new(url, token, timeout, request_id)
     end
 
     def provision(args)
       msg = GatewayProvisionRequest.new(args)
-      resp = perform_request(:post, '/gateway/v1/configurations', msg)
+      resp = http_client.perform_request(:post, '/gateway/v1/configurations', msg)
       GatewayHandleResponse.decode(resp)
     end
 
     def unprovision(args)
-      resp = perform_request(:delete, "/gateway/v1/configurations/#{args[:service_id]}")
+      http_client.perform_request(:delete, "/gateway/v1/configurations/#{args[:service_id]}")
       EMPTY_REQUEST
     end
 
+    def bind(args)
+      msg = GatewayBindRequest.new(args)
+      resp = http_client.perform_request(:post, "/gateway/v1/configurations/#{msg.service_id}/handles", msg)
+      GatewayHandleResponse.decode(resp)
+    end
+
+    def unbind(args)
+      msg = GatewayUnbindRequest.new(args)
+      http_client.perform_request(:delete, "/gateway/v1/configurations/#{msg.service_id}/handles/#{msg.handle_id}", msg)
+      EMPTY_REQUEST
+    end
+
+    #------------------
+    # Snapshotting has never been enabled in production - we can probably remove these
+    #------------------
+
+    def job_info(args)
+      resp = http_client.perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/jobs/#{args[:job_id]}")
+      Job.decode(resp)
+    end
+
     def create_snapshot(args)
-      resp = perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
+      resp = http_client.perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
       Job.decode(resp)
     end
 
     def enum_snapshots(args)
-      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
+      resp = http_client.perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
       SnapshotList.decode(resp)
     end
 
     def snapshot_details(args)
-      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+      resp = http_client.perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
       Snapshot.decode(resp)
     end
 
     def update_snapshot_name(args)
-      perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}/name", args[:msg])
+      http_client.perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}/name", args[:msg])
       EMPTY_REQUEST
     end
 
     def rollback_snapshot(args)
-      resp = perform_request(:put, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+      resp = http_client.perform_request(:put, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
       Job.decode(resp)
     end
 
     def delete_snapshot(args)
-      resp = perform_request(:delete, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+      resp = http_client.perform_request(:delete, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
       Job.decode(resp)
     end
 
     def create_serialized_url(args)
-      resp = perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url/snapshots/#{args[:snapshot_id]}")
+      resp = http_client.perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url/snapshots/#{args[:snapshot_id]}")
       Job.decode(resp)
     end
 
     def serialized_url(args)
-      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url/snapshots/#{args[:snapshot_id]}")
+      resp = http_client.perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url/snapshots/#{args[:snapshot_id]}")
       SerializedURL.decode(resp)
     end
 
     def import_from_url(args)
-      resp = perform_request(:put, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url", args[:msg])
+      resp = http_client.perform_request(:put, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url", args[:msg])
       Job.decode(resp)
     end
 
-    def job_info(args)
-      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/jobs/#{args[:job_id]}")
-      Job.decode(resp)
-    end
+    class HttpClient
+      METHODS_MAP = {
+        get: Net::HTTP::Get,
+        post: Net::HTTP::Post,
+        put: Net::HTTP::Put,
+        delete: Net::HTTP::Delete,
+      }
 
-    def bind(args)
-      msg = GatewayBindRequest.new(args)
-      resp = perform_request(:post, "/gateway/v1/configurations/#{msg.service_id}/handles", msg)
-      GatewayHandleResponse.decode(resp)
-    end
+      attr_reader :uri, :timeout, :token, :headers
+
+      def initialize(uri, token, timeout, request_id)
+        @uri = URI.parse(uri)
+        @timeout = timeout
+        @token = token
+        @headers  = {
+          'Content-Type' => 'application/json',
+          GATEWAY_TOKEN_HEADER => token,
+          "X-VCAP-Request-ID" => request_id.to_s
+        }
+      end
 
-    def unbind(args)
-      msg = GatewayUnbindRequest.new(args)
-      perform_request(:delete, "/gateway/v1/configurations/#{msg.service_id}/handles/#{msg.handle_id}", msg)
-      EMPTY_REQUEST
-    end
+      def perform_request(http_method, path, msg = EMPTY_REQUEST)
+        klass = METHODS_MAP[http_method]
+        request = klass.new(path, headers)
+        request.body = msg.encode
 
-    protected
+        opts = {}
+        if uri.scheme == "https"
+          opts[:use_ssl] = true
+        end
+        
+        response = Net::HTTP.start(uri.host, uri.port, opts) do |http|
+          http.request(request)
+        end
+
+        code = response.code.to_i
+        body = response.body
+
+        return body if code == 200
 
-    def perform_request(http_method, path, msg=VCAP::Services::Api::EMPTY_REQUEST)
-      result = nil
-      uri = URI.parse(@url)
-      if EM.reactor_running?
-        url = URI.parse(uri.to_s + path)
-        code, body = requester.request(url, @token, http_method, @timeout, msg)
-      else
-        klass = METHODS_MAP[http_method]
-        req = klass.new(path, initheader=@hdrs)
-        req.body = msg.encode
-        resp = Net::HTTP.new(uri.host, uri.port).start {|http| http.request(req)}
-        code = resp.code.to_i
-        body = resp.body
-      end
-      case code
-      when 200
-        body
-      when 404
-        err = ServiceErrorResponse.decode(body)
-        raise NotFoundResponse.new(err)
-      when 503
-        err = ServiceErrorResponse.decode(body)
-        raise GatewayInternalResponse.new(err)
-      else
         begin
-          # try to decode the response
           err = ServiceErrorResponse.decode(body)
-        rescue => e
-          raise UnexpectedResponse, "Can't decode gateway response. status code:#{code}, response body:#{body}"
+        rescue JsonMessage::Error
+          raise UnexpectedResponse, "Can't decode gateway response. status code: #{code}, response body: #{body}"
+        end
+
+        case code
+        when 404 then raise NotFoundResponse.new(err)
+        when 503 then raise GatewayInternalResponse.new(err)
+        else raise ErrorResponse.new(code, err)
         end
-        raise ErrorResponse.new(code, err)
       end
     end
   end

data/lib/services/api/messages.rb

@@ -82,9 +82,9 @@ module VCAP
       # NB: Unprovision takes all args in the url
       #
       class CloudControllerProvisionRequest < JsonMessage
-        required :label, SERVICE_LABEL_REGEX
-        required :name,  String
-        required :plan,  String
+        required :label,   SERVICE_LABEL_REGEX
+        required :name,    String
+        required :plan,    String
         required :version, String
 
         optional :plan_option
@@ -92,10 +92,10 @@ module VCAP
       end
 
       class GatewayProvisionRequest < JsonMessage
-        required :unique_id, String
-        required :name,      String
-        required :email,     String
+        required :unique_id,         String
+        required :name,              String
 
+        optional :email,             String
         optional :provider,          String
         optional :label,             String
         optional :plan,              String
@@ -107,10 +107,12 @@ module VCAP
 
       # Provision and bind response use the same format
       class GatewayHandleResponse < JsonMessage
-        required :service_id, String
+        required :service_id,       String
         required :configuration
         required :credentials
-        optional :dashboard_url, String
+
+        optional :dashboard_url,    String
+        optional :syslog_drain_url, String
       end
 
       #
@@ -127,6 +129,8 @@ module VCAP
         required :label,         String
         required :email,         String
         required :binding_options
+
+        optional :app_id,        String
       end
 
       class GatewayUnbindRequest < JsonMessage
@@ -152,10 +156,10 @@ module VCAP
       end
 
       class Snapshot < JsonMessage
-        required :snapshot_id,  String
-        required :date,  String
-        required :size,  Integer
-        required :name,  String
+        required :snapshot_id, String
+        required :date,        String
+        required :size,        Integer
+        required :name,        String
       end
 
       class SnapshotList < JsonMessage
@@ -167,10 +171,10 @@ module VCAP
       end
 
       class SnapshotV2 < JsonMessage
-        required :snapshot_id, String
-        required :name,  String
-        required :state, String
-        required :size,  Integer
+        required :snapshot_id,   String
+        required :name,          String
+        required :state,         String
+        required :size,          Integer
 
         optional :created_time,  String
         optional :restored_time, String
@@ -185,12 +189,12 @@ module VCAP
       end
 
       class Job < JsonMessage
-        required :job_id,  String
-        required :status,  String
-        required :start_time, String
-        optional :description, String
+        required :job_id,        String
+        required :status,        String
+        required :start_time,    String
+        optional :description,   String
         optional :complete_time, String
-        optional :result, Object
+        optional :result,        Object
       end
 
       class SerializedURL < JsonMessage
@@ -198,12 +202,13 @@ module VCAP
       end
 
       class SerializedData < JsonMessage
-        required :data,  String
+        required :data, String
       end
 
       class ServiceErrorResponse < JsonMessage
-        required :code, Integer
+        required :code,        Integer
         required :description, String
+        optional :error,       Hash
       end
     end
   end

data/lib/vcap/common.rb

@@ -1,11 +1,13 @@
 # Copyright (c) 2009-2011 VMware, Inc.
 require 'fileutils'
 require 'socket'
+require 'uuidtools'
 
 # VMware's Cloud Application Platform
 
 module VCAP
 
+  WINDOWS = RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
   A_ROOT_SERVER = '198.41.0.4'
 
   def self.local_ip(route = A_ROOT_SERVER)
@@ -17,16 +19,18 @@ module VCAP
   end
 
   def self.secure_uuid
-    result = File.open('/dev/urandom') { |x| x.read(16).unpack('H*')[0] }
+    result = UUIDTools::UUID.random_create.to_s.delete('-')
   end
 
   def self.grab_ephemeral_port
     socket = TCPServer.new('0.0.0.0', 0)
     socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-    Socket.do_not_reverse_lookup = true
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
     port = socket.addr[1]
     socket.close
     return port
+  ensure
+    Socket.do_not_reverse_lookup = orig
   end
 
   def self.uptime_string(delta)
@@ -40,6 +44,13 @@ module VCAP
     "#{days}d:#{hours}h:#{minutes}m:#{num_seconds}s"
   end
 
+  def self.uptime_string_to_seconds(string)
+    parts = string.split(":", 4).map { |i| i.to_i}
+    raise ArgumentError.new("Invalid format") unless parts.size == 4
+    days, hours, mins, secs = parts
+    secs + (mins * 60) + (hours * 3600) + (days * 24 * 3600)
+  end
+
   def self.num_cores
     if RUBY_PLATFORM =~ /linux/
       return `cat /proc/cpuinfo | grep processor | wc -l`.to_i
@@ -47,6 +58,8 @@ module VCAP
       `hwprefs cpu_count`.strip.to_i
     elsif RUBY_PLATFORM =~ /freebsd|netbsd/
       `sysctl hw.ncpu`.strip.to_i
+    elsif WINDOWS
+      (ENV['NUMBER_OF_PROCESSORS'] || 1).to_i
     else
       return 1 # unknown..
     end
@@ -92,7 +105,11 @@ module VCAP
 
   def self.process_running?(pid)
     return false unless pid && (pid > 0)
-    output = %x[ps -o rss= -p #{pid}]
+    if WINDOWS
+      output = %x[tasklist /nh /fo csv /fi "pid eq #{pid}"]
+    else
+      output = %x[ps -o rss= -p #{pid}]
+    end
     return true if ($? == 0 && !output.empty?)
     # fail otherwise..
     return false