cf_light_api 2.6.0 → 3.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f127e7dd8c7c4b60f024d4e7bb68b5486b600087
-  data.tar.gz: 1aad85e99f737e39c93bb9fea8819661e6698f51
+  metadata.gz: 3d374bcb2bda0fd2db6302a99752f4ffe46438ad
+  data.tar.gz: 02301b70a44ba3d2376828040f407f8c46597a0f
 SHA512:
-  metadata.gz: 1b2aa1e7f16ccd9fe899941ab36765b2f705bb949d83e7176f83007069007781d5b910c8cfec3e2e6dbc20ae777b5c7b446bf6c89a6bce830ad63d65e521d50f
-  data.tar.gz: 2993f6ffcaa1f04c05020f4aa4c79b9d922cdd1935e91caded16d7ab86a92e7bd93f4b7056696dde74600c6eb948925bd7417bdb7b0097c9a915bbfc9b66c476
+  metadata.gz: 5535e198e1e5531135cb259529079a91c1c5f91aeafa93a4ef65b8a8f7fbbbf4da142d4a0c755d6fdcda221841666d1425561f64d2b230c89ba60542e9ce97f2
+  data.tar.gz: 79e6852453c97727dba30d4877aa2503757e95b467a94ad7bc2562324aec5e29519119d02c522704898acac4620cdc199c84d5211361016fa7e5d842f5d353ad

data/bin/cf_light_api

@@ -15,6 +15,7 @@ if ENV['NEW_RELIC_APP_NAME'] or ENV['NEW_RELIC_LICENSE_KEY']
 end
 
 require_relative '../lib/cf_light_api/redis.rb'
+require_relative '../lib/cf_light_api/cf_response_error.rb'
 require_relative '../lib/cf_light_api/worker.rb'
 
 require 'sinatra'

data/lib/cf_light_api/cf_response_error.rb

@@ -0,0 +1,2 @@
+class CFResponseError < StandardError
+end

data/lib/cf_light_api/worker.rb

@@ -18,6 +18,13 @@ class CFLightAPIWorker
 
   def initialize
     @logger = Logger.new(STDOUT)
+
+    if ENV['DEBUG']
+      @logger.level = Logger::DEBUG
+    else
+      @logger.level = Logger::INFO
+    end
+
     @logger.formatter = proc do |severity, datetime, progname, msg|
        "#{datetime} [cf_light_api:worker]: #{msg}\n"
     end
@@ -34,7 +41,7 @@ class CFLightAPIWorker
     if ENV['GRAPHITE_HOST'] or ENV['GRAPHITE_PORT']
       ['GRAPHITE_HOST', 'GRAPHITE_PORT', 'CF_ENV_NAME'].each do |env|
         unless ENV[env]
-          @logger.info "Error: please set the '#{env}' environment variable to enable exporting to Graphite."
+          @logger.info "Error: please also set the '#{env}' environment variable to enable exporting to Graphite."
           exit 1
         end
       end
@@ -61,30 +68,43 @@ class CFLightAPIWorker
     @scheduler.every update_interval, :first_in => '5s', :overlap => false, :timeout => update_timeout do
       update_cf_data
     end
-
-  end
-
-  def formatted_instance_stats_for_app app
-    instances = cf_rest("/v2/apps/#{app['metadata']['guid']}/stats")[0]
-    raise "Unable to retrieve app instance stats: '#{instances['error_code']}'" if instances['error_code']
-    instances.map{|key,value|value}
   end
 
   def cf_rest(path, method='GET')
-    @logger.info "Making #{method} request for #{path}..."
+    @logger.debug "Making #{method} request for #{path}..."
 
     resources = []
-    options = {:accept => :json}
-    response = @cf_client.base.rest_client.request(method, path, options)[1][:body]
+    options   = {:accept => :json}
+    response  = @cf_client.base.rest_client.request(method, path, options)[1][:body]
 
     begin
       response = JSON.parse(response)
+      if response['error_code']
+        raise CFResponseError.new("Code #{response['code']}, #{response['error_code']} - #{response['description']}")
+      end
+
     rescue Rufus::Scheduler::TimeoutError => e
       raise e
+    rescue JSON::ParserError => e
+      @logger.error "Error parsing JSON response from #{method} #{path}: #{e.message}"
+      @logger.trace e.backtrace
+      @logger.trace response
+      raise e
+    rescue CFoundry => e
+      @logger.error "CFoundry error making #{method} #{path}: #{e.message}"
+      @logger.trace e.backtrace
+      @logger.trace response
+      raise e
+    rescue CFResponseError => e
+      @logger.error "CF API returned a response with an error document for #{method} #{path}: #{e.message}"
+      @logger.trace e.backtrace
+      @logger.trace response
+      raise e
     rescue StandardError => e
-      @logger.info "Error parsing JSON response from #{method} request for #{path}: #{e.message}"
-      @logger.error e.backtrace
-      raise "Invalid JSON response from CF for #{method} #{path}"
+      @logger.error "General error making #{method} #{path}: #{e.message}"
+      @logger.trace e.backtrace
+      @logger.trace response
+      raise e
     end
 
     # Some endpoints return a 'resources' array, others are flat, depending on the path.
@@ -111,33 +131,36 @@ class CFLightAPIWorker
 
     instance_stats.each_with_index do |instance_data, index|
       graphite_base_key = "cf_apps.#{ENV['CF_ENV_NAME']}.#{org}.#{space}.#{sanitised_app_name}.#{index}"
-      @logger.info "  Exporting app instance \##{index} usage statistics to Graphite, path '#{graphite_base_key}'"
+      @logger.debug "  Exporting app instance \##{index} usage statistics to Graphite, path '#{graphite_base_key}'"
 
       # Quota data
       ['mem_quota', 'disk_quota'].each do |key|
-        @graphite.metrics "#{graphite_base_key}.#{key}" => instance_data['stats'][key]
+        @logger.trace "#{graphite_base_key}.#{key} => #{instance_data['stats'][key]}"
+        # @graphite.metrics "#{graphite_base_key}.#{key}" => instance_data['stats'][key]
       end
 
       # Usage data
       ['mem', 'disk', 'cpu'].each do |key|
-        @graphite.metrics "#{graphite_base_key}.#{key}" => instance_data['stats']['usage'][key]
+        @logger.trace "#{graphite_base_key}.#{key} => #{instance_data['stats']['usage'][key]}"
+        # @graphite.metrics "#{graphite_base_key}.#{key}" => instance_data['stats']['usage'][key]
       end
     end
   end
 
   def send_org_quota_data_to_graphite(org_name, quota)
     graphite_base_key = "cf_orgs.#{ENV['CF_ENV_NAME']}.#{org_name}"
-    @logger.info "  Exporting org quota statistics to Graphite, path '#{graphite_base_key}'"
+    @logger.debug "  Exporting org quota statistics to Graphite, path '#{graphite_base_key}'"
 
     quota.keys.each do |key|
-      @graphite.metrics "#{graphite_base_key}.quota.#{key}" => quota[key]
+      @logger.trace "#{graphite_base_key}.quota.#{key} => #{quota[key]}"
+      # @graphite.metrics "#{graphite_base_key}.quota.#{key}" => quota[key]
     end
   end
 
   def send_cf_light_api_update_time_to_graphite seconds
     graphite_key = "cf_light_api.#{ENV['CF_ENV_NAME']}.update_duration"
-    @logger.info "Exporting CF Light API update time to Graphite, path '#{graphite_key}'=>'#{seconds.round}'"
-    @graphite.metrics "#{graphite_key}" => seconds.round
+    @logger.info "Exporting CF Light API update time to Graphite, path #{graphite_key} => #{seconds.round}"
+    # @graphite.metrics "#{graphite_key}" => seconds.round
   end
 
   def put_in_redis(key, data)
@@ -151,28 +174,62 @@ class CFLightAPIWorker
     format("%02d hrs, %02d mins, %02d secs", hours, minutes, seconds)
   end
 
+  def update_domains
+    @domains = cf_rest('/v2/domains?results-per-page=100')
+  end
+
+  def find_domain_for_route route
+    return @domains.find{|a_domain| a_domain['metadata']['guid'] == route['entity']['domain_guid']}
+  end
+
   def format_routes_for_app app
-    routes = cf_rest app['entity']['routes_url']
+    # The app object passed in here should contain a "routes" attribute, fetched as part of the original request to CF (with inline-relation gathering enabled)
+    # and it will look something like this:
+    # "routes"=>
+    # [{"metadata"=>{"guid"=>"afea5690-fb93-451a-9610-2d524d36e35f", "url"=>"/v2/routes/afea5690-fb93-451a-9610-2d524d36e35f", "created_at"=>"2015-03-11T12:20:22Z", "updated_at"=>"2015-03-11T12:20:22Z"},
+    #   "entity"=>
+    #    {"host"=>"hostname_here",
+    #     "path"=>"",
+    #     "domain_guid"=>"f13e6864-537e-41bb-b46c-f3810dbf7c84",
+    #     "space_guid"=>"c0af44b8-8b51-4db5-927e-ccad2e6dab54",
+    #     "service_instance_guid"=>nil,
+    #     "port"=>nil,
+    #     "domain_url"=>"/v2/shared_domains/f13e6864-537e-41bb-b46c-f3810dbf7c84",
+    #     "space_url"=>"/v2/spaces/c0af44b8-8b51-4db5-927e-ccad2e6dab54",
+    #     "apps_url"=>"/v2/routes/afea5690-fb93-451a-9610-2d524d36e35f/apps",
+    #     "route_mappings_url"=>"/v2/routes/afea5690-fb93-451a-9610-2d524d36e35f/route_mappings"}},
+    # If we don't receive that child attribute, (perhaps the app was being staged or didn't have any routes yet) we make another request to CF to try
+    # and fetch them before giving up and just returning an empty array.
+
+    routes = []
+    if app['entity']['routes'] == nil
+      # We have no routes data inlined with the app entity, so let's try to retrieve them directly from CF
+      routes = cf_rest(app['entity']['routes_url'])
+    else
+      # Routes were already retrieved as an inline-relation, so just use those...
+      routes = app['entity']['routes']
+    end
+
     routes.collect do |route|
       host   = route['entity']['host']
       path   = route['entity']['path']
 
-      domain = ''
-      begin
-        domain = @domains.find{|a_domain| a_domain['metadata']['guid'] == route['entity']['domain_guid']}
-        domain = domain['entity']['name']
-      rescue Rufus::Scheduler::TimeoutError => e
-        raise e
-      rescue StandardError => e
-        raise "Unable to determine domain for route #{route['metadata']['url']}"
+      domain = find_domain_for_route(route)
+      if domain == nil
+        # The domain doesn't exist, this could be due to a race condition, so let's update the list and try again
+        update_domains()
+        domain = find_domain_for_route(route)
+        if domain == nil
+          # If we can't determine the domain associated with this route, raise an error as we can't guarantee the state is correct here,
+          # it shouldn't be possible to get a route back from CF with a domain GUID that doesn't exist, as that route would be invalid.
+          raise "Unable to find domain #{route['entity']['domain_guid']} for route #{route['metadata']['guid']}."
+        end
       end
-
-      "#{host}.#{domain}#{path}"
+      "#{host}.#{domain['entity']['name']}#{path}"
     end
   end
 
   def filtered_environment_variables env_vars
-
     if ENVIRONMENT_VARIABLES_WHITELIST.any?
       return ENVIRONMENT_VARIABLES_WHITELIST.inject({}) do |filtered, key|
         filtered[key] = env_vars[key] if env_vars[key]
@@ -182,7 +239,49 @@ class CFLightAPIWorker
     else
       return env_vars
     end
+  end
+
+  def format_orgs orgs
+    return orgs.map do |org|
+      quota = @quotas.find{|a_quota| a_quota['metadata']['guid'] == org['entity']['quota_definition_guid']}
 
+      quota = {
+        :total_services => quota['entity']['total_services'],
+        :total_routes   => quota['entity']['total_routes'],
+        :memory_limit   => quota['entity']['memory_limit'] * 1024 * 1024
+      }
+
+      send_org_quota_data_to_graphite(org['entity']['name'], quota) if @graphite
+
+      {
+        :guid => org['metadata']['guid'],
+        :name  => org['entity']['name'],
+        :quota => quota
+      }
+    end
+  end
+
+  def get_v1_base_data app
+    # Format the app data in the expected format for the /v1/apps endpoint, to remain compatible.
+
+    # Find the org for this app, using the org GUID from the space. Relationship: Apps belong to spaces, and spaces belong to orgs.
+    space = @spaces.find{|a_space| a_space['metadata']['guid'] == app['entity']['space_guid']}
+    org = @orgs.find{|an_org| an_org['metadata']['guid'] == space['entity']['organization_guid']}
+
+    {
+      :buildpack     => app['entity']['buildpack'],
+      :data_from     => Time.now.to_i,
+      :diego         => app['entity']['diego'],
+      :docker        => app['entity']['docker_image'] ? true : false,
+      :docker_image  => app['entity']['docker_image'],
+      :guid          => app['metadata']['guid'],
+      :last_uploaded => app['metadata']['updated_at'] ? DateTime.parse(app['metadata']['updated_at']).strftime('%Y-%m-%d %T %z') : nil,
+      :name          => app['entity']['name'],
+      :org           => org['entity']['name'],
+      :space         => space['entity']['name'],
+      :stack         => app['entity']['stack']['entity']['name'],
+      :state         => app['entity']['state']
+    }
   end
 
   def update_cf_data
@@ -193,115 +292,113 @@ class CFLightAPIWorker
       @lock_manager.lock("#{ENV['REDIS_KEY_PREFIX']}:lock", 5*60*1000) do |lock|
         if lock
           start_time = Time.now
-
           @logger.info "Updating data..."
-
           @cf_client = get_client() # Ensure we have a fresh auth token...
 
-          @apps    = cf_rest('/v2/apps?results-per-page=100')
-          @orgs    = cf_rest('/v2/organizations?results-per-page=100')
-          @quotas  = cf_rest('/v2/quota_definitions?results-per-page=100')
+          @cf_info  = cf_rest('/v2/info').first
+
+          @apps = cf_rest('/v2/apps?results-per-page=100&inline-relations-depth=1&include-relations=routes,stack')
           @spaces  = cf_rest('/v2/spaces?results-per-page=100')
-          @stacks  = cf_rest('/v2/stacks?results-per-page=100')
-          @domains = cf_rest('/v2/domains?results-per-page=100')
-          cf_info  = cf_rest('/v2/info').first
-
-          formatted_orgs = @orgs.map do |org|
-            quota = @quotas.find{|a_quota| a_quota['metadata']['guid'] == org['entity']['quota_definition_guid']}
-
-            quota = {
-              :total_services => quota['entity']['total_services'],
-              :total_routes   => quota['entity']['total_routes'],
-              :memory_limit   => quota['entity']['memory_limit'] * 1024 * 1024
-            }
-
-            send_org_quota_data_to_graphite(org['entity']['name'], quota) if @graphite
-
-            {
-              :guid => org['metadata']['guid'],
-              :name  => org['entity']['name'],
-              :quota => quota
-            }
-          end
 
-          formatted_apps = Parallel.map(@apps, :in_threads => @update_threads) do |app|
-            # TODO: This is a bit repetative, could maybe improve?
-            space  = @spaces.find{|a_space| a_space['metadata']['guid'] == app['entity']['space_guid']}
-            org    = @orgs.find{|an_org|     an_org['metadata']['guid'] == space['entity']['organization_guid']}
-            stack  = @stacks.find{|a_stack| a_stack['metadata']['guid'] == app['entity']['stack_guid']}
-
-            running = (app['entity']['state'] == "STARTED")
-
-            base_data = {
-              :buildpack     => app['entity']['buildpack'],
-              :data_from     => Time.now.to_i,
-              :diego         => app['entity']['diego'],
-              :docker        => app['entity']['docker_image'] ? true : false,
-              :docker_image  => app['entity']['docker_image'],
-              :guid          => app['metadata']['guid'],
-              :last_uploaded => app['metadata']['updated_at'] ? DateTime.parse(app['metadata']['updated_at']).strftime('%Y-%m-%d %T %z') : nil,
-              :name          => app['entity']['name'],
-              :org           => org['entity']['name'],
-              :space         => space['entity']['name'],
-              :stack         => stack['entity']['name'],
-              :state         => app['entity']['state']
-            }
-
-            if ENV['EXPOSE_ENVIRONMENT_VARIABLES'] == 'true' then
-              base_data[:environment_variables] = filtered_environment_variables( app['entity']['environment_json'] )
-            end
+          update_domains() # Sets @domain by hitting the CF API
 
-            # Add additional data, such as instance usage statistics - but this is only possible if the instances are running.
-            additional_data = {}
+          # Orgs
+          @orgs          = cf_rest('/v2/organizations?results-per-page=100')
+          @quotas        = cf_rest('/v2/quota_definitions?results-per-page=100')
+          formatted_orgs = format_orgs @orgs
 
+          v1_data = []
+          v2_data = []
+
+          Parallel.each(@apps, :in_threads => @update_threads) do |app|
             begin
-              instance_stats = []
-              if running
-                instance_stats = formatted_instance_stats_for_app(app)
-                running_instances = instance_stats.select{|instance| instance['stats']['uris'] if instance['state'] == 'RUNNING'}
-                raise "There are no running instances of this app." if running_instances.empty?
-
-                if @graphite
-                  send_instance_usage_data_to_graphite(instance_stats, org['entity']['name'], space['entity']['name'], app['entity']['name'])
-                end
+              # Formats the base data compatible with the v1 endpoint
+              v1_document = get_v1_base_data(app)
+
+              # New format base data for the v2 endpoint
+              v2_document                          = app['entity'].dup
+              v2_document['environment_json']      = {} # The environment JSON will have been duplicated from the app entity, so we need to blank it here, as it will be re-populated later if EXPOSE_ENVIRONMENT_VARIABLES is true.
+              v2_document['created_at']            = app['metadata']['created_at']
+              v2_document['updated_at']            = app['metadata']['updated_at']
+              v2_document['guid']                  = app['metadata']['guid']
+              v2_document['instances']             = []
+              v2_document['routes']                = []
+              v2_document['meta']                  = { 'error' => false }
+
+              # Add space, stack and org names as a top level string attribute for ease of use:
+              v2_document['stack'] = app['entity']['stack']['entity']['name']
+
+              # Get the org name from the app's space - relationship: an app belongs to a space, and a space belongs to an org.
+              space = @spaces.find{|a_space| a_space['metadata']['guid'] == app['entity']['space_guid']}
+              org = @orgs.find{|an_org| an_org['metadata']['guid'] == space['entity']['organization_guid']}
+
+              v2_document['space'] = space['entity']['name']
+              v1_document['org'] = org['entity']['name']
+              v2_document['org'] = org['entity']['name']
+
+              # Gather and filter environment variable JSON if the feature is enabled:
+              if ENV['EXPOSE_ENVIRONMENT_VARIABLES'] == 'true' then
+                env_vars = filtered_environment_variables( app['entity']['environment_json'] )
+                v1_document['environment_variables'] = env_vars
+                v2_document['environment_json']      = env_vars
               end
 
               routes = format_routes_for_app(app)
+              v1_document['routes'] = routes
+              v2_document['routes'] = routes
+
+              response = cf_rest("/v2/apps/#{app['metadata']['guid']}/stats")
+              instances = response.first.map{|key,value|value}
+              v1_document['instances'] = instances
+              v2_document['instances'] = instances
+
+              running = false
+              if instances.any?
+                if instances.select{|instance| instance['state'] == 'RUNNING'}.any?
+                  running = true
+                end
+              end
+              v1_document['running'] = running
+              v2_document['running'] = running
 
-              additional_data = {
-               :running   => running,
-               :instances => instance_stats,
-               :routes    => routes,
-               :error     => nil
-              }
+              if @graphite
+                send_instance_usage_data_to_graphite(instances, org['entity']['name'], app['entity']['space']['entity']['name'], app['entity']['name'])
+              end
 
             rescue Rufus::Scheduler::TimeoutError => e
               raise e
-            rescue StandardError => e
-              # Most exceptions here will be caused by the app or one of the instances being in a non-standard state,
-              # for example, trying to query an app which was present when the worker began updating, but was stopped
-              # before we reached this section, so we just catch all exceptions, log the reason and move on.
-              @logger.info "  #{org['entity']['name']} #{space['entity']['name']}: '#{app['entity']['name']}' error: #{e.message}"
-              @logger.error e.backtrace
-              additional_data = {
-                :running   => 'error',
-                :instances => [],
-                :routes    => [],
-                :error     => e.message
-              }
+            rescue CFoundry, CFResponseError, StandardError => e
+              v1_document['running']           = "error"
+              v1_document['error']             = "#{e.message}"
+
+              v2_document['meta']              = {}
+              v2_document['meta']['error']     = true
+              v2_document['meta']['type']      = e.class
+              v2_document['meta']['message']   = e.message
+              v2_document['meta']['backtrace'] = e.backtrace
             end
 
-            base_data.merge additional_data
+            v1_data << v1_document
+            v2_data << v2_document
+          end
+
+          # Sanity check - do we have the expected quantity of data? This shouldn't happen as the `parallel` gem should handle
+          # sharing and modifying variables for us when using threads.
+          if @apps.count != v1_data.count or @apps.count != v2_data.count
+            raise "V1 and V2 app counts don't match after processing!"
           end
 
-          put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:info", cf_info
+          put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:info", @cf_info
           put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:orgs", formatted_orgs
-          put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:apps", formatted_apps
+          put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:apps", v1_data
+          put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:apps:v2", v2_data
+
           put_in_redis "#{ENV['REDIS_KEY_PREFIX']}:last_updated", {:last_updated => Time.now}
 
           elapsed_seconds = Time.now.to_f - start_time.to_f
-          @logger.info "Update completed in #{format_duration(elapsed_seconds)}..."
+
           send_cf_light_api_update_time_to_graphite(elapsed_seconds) if @graphite
+          @logger.info "Update completed in #{format_duration(elapsed_seconds)}..."
 
           @lock_manager.unlock(lock)
           @cf_client.logout
@@ -310,9 +407,13 @@ class CFLightAPIWorker
         end
       end
     rescue Rufus::Scheduler::TimeoutError
+      Parallel::Kill
+      @cf_client.logout
       @logger.info 'Data update took too long and was aborted, waiting for the lock to expire before trying again...'
       send_cf_light_api_update_time_to_graphite(0) if @graphite
-      @cf_client.logout
+    rescue StandardError => e
+      @logger.info "Unable to complete update due to #{e.class}: #{e.message}"
+      @logger.error e.backtrace
     end
   end
 

data/lib/sinatra/cf_light_api.rb

@@ -21,6 +21,17 @@ module Sinatra
         return all_apps.to_json
       end
 
+      app.get '/v2/apps/?:org?' do
+        content_type :json
+        all_apps = JSON.parse(REDIS.get("#{ENV['REDIS_KEY_PREFIX']}:apps:v2"))
+
+        if params[:org]
+          return all_apps.select{|an_app| an_app['org'] == params[:org]}.to_json
+        end
+
+        return all_apps.to_json
+      end
+
       app.get '/v1/orgs/?:guid?' do
         content_type :json
         all_orgs = JSON.parse(REDIS.get("#{ENV['REDIS_KEY_PREFIX']}:orgs"))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cf_light_api
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 3.0.0.pre1
 platform: ruby
 authors:
 - Springer Platform Engineering
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-04 00:00:00.000000000 Z
+date: 2018-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cfoundry
@@ -130,6 +130,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- "./lib/cf_light_api/cf_response_error.rb"
 - "./lib/cf_light_api/redis.rb"
 - "./lib/cf_light_api/worker.rb"
 - "./lib/sinatra/cf_light_api.rb"
@@ -149,9 +150,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1