em-service-now 0.3

data/em-service-now.gemspec

@@ -0,0 +1,28 @@
+require 'date'
+Gem::Specification.new do |spec|
+  
+  spec.name = %q{em-service-now}
+  spec.version = '0.3'
+  spec.date = DateTime.now.strftime( "%Y-%m-%d" )
+  spec.authors = ["Richard","","",""]
+  spec.email = %q{ops@clue.co.za}
+  spec.summary = %q{Tools for interfacing with service-now.com}
+  spec.homepage = %q{https://github.com/cluetechnologies/em-service-now}
+  spec.description = %q{}
+  spec.add_runtime_dependency 'eventmachine', '~> 1'
+  spec.add_runtime_dependency 'em-http-request', '~> 1'
+  spec.add_runtime_dependency 'json'
+  spec.add_runtime_dependency 'yaml'
+  spec.files = [
+    
+    'em-service-now.gemspec',
+    'lib/em-service-now.rb',
+    'lib/version.rb',
+    'spec/spec_helper.rb',
+    'spec/spec_config.yml.tmpl',
+    'spec/functional_spec.rb',
+    'spec/em-service-now_spec.rb'  
+     
+  ]
+  
+end

data/lib/em-service-now.rb

@@ -0,0 +1,573 @@
+require 'eventmachine'
+require 'em-http-request'
+require 'json'
+require 'uri'
+require 'yaml'
+
+class ServiceNowException < Exception
+  
+end
+
+class ConfigException < Exception
+  
+end unless defined?( ConfigException )
+
+module ServiceNow
+    
+  def service_now_init( config, logger = nil )
+    
+    @config = {} 
+    @config = config unless config.nil?
+    
+    @logger = logger
+    
+    @connect_timeout = 60
+    @connect_timeout = @config[:connect_timeout] unless @config[:connect_timeout].nil?
+    
+    @timeout = 120
+    @timeout = @config[:timeout] unless @config[:timeout].nil?
+    
+    @username = @config[:username]
+    @password = @config[:password]
+    @url = @config[:url]
+    
+    @service_now_running = false
+    
+    
+    raise ::ConfigException.new(
+    
+      "#{self.class} requires :url: and :username: and :password: configured."
+    
+    ) if (
+
+      @username.nil? or @username == '' or
+      @password.nil? or @password == '' or
+      @url.nil? or @url == ''
+      
+    )
+    
+    #
+    # Assumes already running inside an EM reactor
+    # If not, call em_service_now
+    # 
+    @inline = true
+    
+    get_cookies
+        
+  end
+  
+
+  
+  def em_service_now_query( query, &block )
+    
+    @inline = false
+
+    EM::run do
+      
+      #
+      # Pass the block straight through.
+      #
+      service_now_query( query, &block )
+      
+    end
+    
+  end
+  
+  def on_error( url, http, &block )
+    
+    EM::stop unless @inline
+    
+    error = "transport or http error #{http.error}"
+    
+    @logger.error "#{self.class} ERROR:#{error}" unless @logger.nil?
+    
+    yield nil, error if block
+    
+    @service_now_running = false
+    
+  end
+  
+  
+  def on_success( url, http, &block )
+    
+    store_cookies( http )
+
+    EM::stop unless @inline
+    
+    unless http.response_header.status == 200
+      
+      error = "Response #{http.response_header.status} from #{url}"
+      
+      @logger.error "#{self.class} ERROR:#{error}" unless @logger.nil?
+
+    end
+    
+    if error != nil or http.response == ""
+      
+      error = "Empty JSON response from #{url}"
+      
+      @logger.error "#{self.class} ERROR:#{error}" unless @logger.nil?
+
+    end
+    
+    if /do\?CSV\&/.match( url ) 
+      
+      parse_csv( http, &block )
+      
+      @service_now_running = false
+      
+      return
+      
+    end
+    
+    unless error != nil or records = JSON.parse( http.response )
+
+      error = "Malformed JSON response from #{url}"
+      
+      @logger.error "#{self.class} ERROR:#{error}" unless @logger.nil?
+
+    end
+    
+    if error.nil? and records.has_key?('error') 
+      
+      #
+      # SNOW returns a 200 'successs' and puts the error in the JSON
+      # 
+      error = "#{records['error']}from #{url}"
+      
+      @logger.error "#{self.class} ERROR:#{error}" unless @logger.nil?
+      
+    end
+    
+    if error.nil? and records.has_key?('records')
+      
+      records['records'].each do |record|
+        
+        #
+        # Have records, yield them each
+        #
+        yield record, nil if block
+        
+      end
+      
+    else
+      
+      yield nil, error if block
+      
+    end
+    
+    @service_now_running = false
+    
+  end
+  
+  def em_service_now( type, query, records_array = nil, &block )
+
+    @inline = false
+
+    EM::run do
+
+      service_now( type, query, records_array, &block )
+      
+    end
+    
+  end
+  
+  
+  def service_now( type, query, records_array = nil, &block )
+    
+    @service_now_running = true
+    
+    url = nil
+    
+    table = query['table']
+    
+    case type
+      
+    when :getRecords, :getKeys, :getCSV
+      
+      return service_now_query( type, query, &block )
+      
+    when :insert
+
+      url = "#{@url}/#{table}.do?JSON&sysparm_action=insertMultiple"
+      body = {
+
+        'records' => records_array
+
+      }
+      
+    when :update
+      
+      url = "#{@url}/#{table}.do?JSON" 
+      url="#{url}&sysparm_action=update"
+      url = append_query( url, query )
+      body = records_array[0]
+      
+    else
+      
+      raise ServiceNowException.new(
+        
+        "no such query type '#{type}'"
+      
+      )
+      
+    end
+    
+    json_body = JSON.dump(body) 
+    
+    @logger.debug "ServiceNow URL:#{url}" unless @logger.nil?
+    
+    http = EventMachine::HttpRequest.new( url ).post(
+      
+        generate_POST_request( json_body )
+      
+    )
+    
+    http.errback do
+      
+      on_error( url, http, &block )
+      
+    end
+    
+    http.callback do
+      
+      if http.response_header.status == 401
+        
+        #
+        # Authentication failed 
+        #
+        login_and_retry( url, json_body, &block )
+                
+      else
+      
+        on_success( url, http, &block )
+      
+      end
+      
+    end
+    
+  end
+  
+  private
+  
+  def get_cookies
+    
+    dir = Dir.getwd
+    file = 'service_now.cookie'
+    
+    #
+    # Assemble cookie file location
+    #
+    
+    begin
+      
+      unless DAEMON_ROOT.nil?
+        
+        dir = "#{DAEMON_ROOT}/log"
+        
+        unless File.directory?( "#{DAEMON_ROOT}/log" )
+          
+          dir = DAEMON_ROOT
+          
+        end
+        
+      end
+      
+      unless DAEMON_NAME.nil?
+        
+        file = "service_now.#{DAEMON_NAME}.cookie"
+        
+      end
+      
+    rescue; end
+    
+    @cookiefile = "#{dir}/#{file}"
+
+    #
+    # Load the cookies from file
+    #
+    if File.file?( @cookiefile )
+      
+      begin
+        
+        @cookies = YAML.load_file( @cookiefile )
+      
+      rescue; end
+      
+    end
+    
+  end
+  
+  def store_cookies( http )
+    
+    #
+    # Only store cookies if JSESSIONID is in [0]'th cookie
+    # 
+    # ie. At the creation of the SNOWside session. All subsequently 
+    #     received cookie arrays do not contain the JSESSIONID in 
+    #     reply, so it would be overwritten in the cookie file, 
+    #
+    #     Effectively making the session cookie only work once.
+    #
+    
+    return unless /^JSESSIONID/.match( http.response_header["SET_COOKIE"][0] )
+    
+    begin
+
+      File.open( @cookiefile, 'w' ) do |f|
+        
+        YAML::dump( http.response_header["SET_COOKIE"], f )
+        
+      end
+      
+    rescue
+      
+    end
+    
+  end
+  
+  def parse_csv( http, &block )
+    
+    require 'csv'
+    
+    headings = nil
+    
+    begin
+      
+      CSV.parse( http.response ).each do |row|
+      
+        if headings.nil? then
+         
+          headings = row
+          next
+          
+        else
+          
+          record = Hash[*headings.zip( row ).flatten]
+          
+          yield record, nil if block
+          
+        end
+        
+      end
+      
+    rescue Exception => e
+      
+      yield nil, e.to_s if block
+      
+    end
+    
+  end
+  
+  def append_csv_query( url, query )
+    
+    url = "#{url}&" unless query['where'].nil?
+    
+    query['where'].each do |field, value|
+      
+      if /^\=/.match( value )
+        url = "#{url}#{field}#{value[1..-1]}^"
+
+      else
+        
+        url = "#{url}#{field}=#{value}^"
+        
+      end
+    
+    end unless query['where'].nil?
+    
+    url.gsub!( /\^$/, '' )
+    url = URI.escape( url )
+    url = url.gsub( %r[,], '%2C' )
+    
+    return url
+    
+  end
+  
+  def append_query( url, query )
+    
+    url = "#{url}&sysparm_query=" unless query['where'].nil?
+    
+    query['where'].each do |field, value|
+      
+      if /^\=/.match( value )
+        
+        url = "#{url}#{field}#{value[1..-1]}^"
+        
+      else
+        
+        url = "#{url}#{field}=#{value}^"
+        
+      end
+      
+    end unless query['where'].nil?
+    
+    url.gsub!( /\^$/, '' )
+    url = URI.escape( url )
+    url = url.gsub( %r[,], '%2C' )
+    
+    return url
+    
+  end
+  
+  def generate_GET_request
+    
+    return \
+      :connect_timeout => @connect_timeout,
+      :timeout => @timeout,
+      :head => { 
+        
+        'cookie' => @cookies,
+        'Content-Type' => 'application/json'
+        
+      } unless @cookies.nil?
+      
+     return \
+       :connect_timeout => @connect_timeout,
+       :timeout => @timeout,
+       :head => { 
+     
+         'Authorization' => [ @username, @password ],
+         'Content-Type' => 'application/json'
+     
+       }
+    
+  end
+  
+  def generate_POST_request( body )
+    
+    return \
+      :connect_timeout => @connect_timeout,
+      :timeout => @timeout,
+      :head => { 
+        
+        'cookie' => @cookies,
+        'Content-Type' => 'application/json'
+        
+      },
+      :body => body \
+    unless @cookies.nil?
+      
+    return \
+      :connect_timeout => @connect_timeout,
+      :timeout => @timeout,
+      :head => { 
+      
+        'Authorization' => [ @username, @password ],
+        'Content-Type' => 'application/json'
+      
+       },
+       :body => body
+    
+  end
+  
+  def service_now_query( type, query, &block )
+    
+    result = []
+    error = nil
+    
+    table = query['table']
+    
+    if query['where'].nil? and type == :select
+    
+      @logger.warn( "WARNING! No 'where' clause! - Use :selectKeys on large dataset, SNOW might return only a subset of the result" )
+      
+    end
+     
+    case type
+      
+    when :getKeys
+      
+      url = "#{@url}/#{table}.do?JSON&sysparm_action=getKeys"
+      url = append_query( url, query )
+      
+    when :getRecords
+      
+      url = "#{@url}/#{table}.do?JSON&sysparm_action=getRecords"
+      url = append_query( url, query )
+      
+    when :getCSV
+      
+      url = "#{@url}/#{table}.do?CSV"
+      url = append_csv_query( url, query )
+
+    end
+    
+    @logger.debug "ServiceNow URL:#{url}" unless @logger.nil?
+    
+    http = EventMachine::HttpRequest.new( url ).get(
+      
+        generate_GET_request
+      
+    )
+    
+    http.errback do
+      
+      on_error( url, http, &block )
+      
+    end
+    
+    http.callback do
+      
+      if http.response_header.status == 401
+        
+        #
+        # Authentication failed 
+        #
+        login_and_retry( url, &block )
+                
+      else
+      
+        on_success( url, http, &block )
+      
+      end
+      
+    end
+    
+  end
+  
+  def login_and_retry( url, body = nil, &block )
+    
+    @logger.warn "#{self.class} creating new session"
+    
+    #
+    # Nil cookies will cause an authentication
+    # and the new cookies will be saved to file
+    # on the reply.
+    #
+    
+    @cookies = nil
+    
+    if body.nil?
+      
+      http = EventMachine::HttpRequest.new( url ).get(
+      
+          generate_GET_request
+      
+      )
+      
+    else
+      
+      http = EventMachine::HttpRequest.new( url ).post(
+      
+          generate_POST_request( body )
+      
+      )
+      
+    end
+    
+    http.errback do
+      
+      on_error( url, http, &block )
+      
+    end
+    
+    http.callback do
+      
+      on_success( url, http, &block )
+      
+    end
+    
+  end
+  
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+module ServiceNow
+  
+  Version = VERSION = '0.3'
+  
+end

data/spec/em-service-now_spec.rb

@@ -0,0 +1,366 @@
+require 'spec_helper'
+
+describe ServiceNow do
+  
+  before :all do
+    
+    LOG.off
+    
+    @cookies = 'NONE'
+  
+    @get_companies = {
+      
+      'table' => 'core_company',
+      'where' => {
+      
+        'status' => 'Operational'
+        
+      }
+      
+    }
+    
+  end
+  
+  subject {
+    
+    Object.extend( ServiceNow )
+    
+  }
+  
+  it 'requires configuration' do
+    
+    config_copy = Hash.new
+    config_copy[:username] = CONFIG['config'][:username]
+    config_copy[:password] = CONFIG['config'][:password]
+    
+    expect {
+      
+      subject.service_now_init( config_copy, LOG )
+    
+    }.to raise_error(
+    
+      ConfigException,
+      
+      /requires :url: and :username: and :password: configured/
+    
+    )
+    
+  end
+  
+  it 'errors on transport errors' do
+    
+    config_copy = Hash.new
+    config_copy[:username] = CONFIG['config'][:username]
+    config_copy[:password] = CONFIG['config'][:password]
+    config_copy[:url] = 'https://no.such.thing' 
+     
+    result = nil
+    
+    subject.service_now_init( config_copy, LOG )
+    
+    subject.em_service_now( :getKeys, @get_companies ) do |record, status|
+      
+      result = status.inspect
+      
+    end
+    
+    result.should match /transport or http error/
+    
+  end
+
+  context 'can query/insert/update' do
+    
+    before :each do
+      
+      subject.service_now_init( CONFIG['config'], LOG )
+      
+      @url = CONFIG['config'][:url]
+      
+      subject.instance_variable_set( :@cookies, @cookies )
+      
+      @http_request = mock( 'EventMachine::HttpRequest' )
+      
+      @http_request.should_receive( 
+     
+        :errback
+      
+      )
+      
+      @http_request.should_receive( 
+      
+        :callback
+      
+      )
+      
+    end
+    
+    it 'supports getKeys' do
+      
+      query = {
+        
+        'table'  => 'table',
+        'where' => {
+          
+          'column1' => 'value1',
+          'column2' => 'value2'
+          
+        }
+        
+      }
+      
+      @http_request.should_receive(
+      
+        :get
+      
+      ).with({
+      
+          :connect_timeout => 60,
+          :timeout => 120,
+          :head => { 
+            
+            "Content-Type" => "application/json",
+            "cookie" => @cookies
+            
+          },
+      
+      }).and_return(
+      
+        @http_request
+      
+      )
+      
+      EventMachine::HttpRequest.should_receive(
+      
+        :new
+      
+      ).with(
+      
+        "#{@url}/table.do?JSON&sysparm_action=getKeys&sysparm_query=column1=value1%5Ecolumn2=value2"
+      
+      ).and_return(
+      
+        @http_request
+      
+      )
+      
+      subject.service_now( :getKeys, query )
+      
+    end
+    
+    it 'supports special query things' do
+      
+      query = {
+        
+        'table' => 'table',
+        'where' => {
+          
+          'field' => '=NOT IN1,2'
+          
+        }
+        
+      }
+      
+      @http_request.should_receive(
+      
+        :get
+      
+      ).with({
+      
+          :connect_timeout => 60,
+          :timeout => 120,
+          :head => { 
+            
+            "Content-Type" => "application/json",
+            "cookie" => @cookies
+            
+          },
+      
+      }).and_return(
+      
+        @http_request
+      
+      )
+      
+      EventMachine::HttpRequest.should_receive(
+      
+        :new
+      
+      ).with(
+      
+        "#{@url}/table.do?JSON&sysparm_action=getKeys&sysparm_query=fieldNOT%20IN1%2C2"
+      
+      ).and_return(
+      
+        @http_request
+      
+      )
+      
+      subject.service_now( :getKeys, query )
+      
+    end
+    
+    it 'can insert a record' do
+      
+      query = {
+        
+        'table' => 'table'
+        
+      }
+      
+      records_array = [{
+        
+        'column1' => 'value1',
+        'column2' => 'value2'
+        
+      }]
+      
+      body = '{"records":[{"column1":"value1","column2":"value2"}]}'
+      
+      @http_request.should_receive(
+      
+        :post
+      
+      ).with({
+      
+          :connect_timeout => 60,
+          :timeout => 120, 
+          :head => { 
+            
+            "Content-Type" => "application/json",
+            "cookie" => @cookies
+            
+          },
+          :body => body
+      
+      }).and_return(
+      
+        @http_request
+      
+      )
+      
+      EventMachine::HttpRequest.should_receive(
+      
+        :new
+      
+      ).with(
+      
+        "#{@url}/table.do?JSON&sysparm_action=insertMultiple"
+      
+      ).and_return(
+      
+        @http_request
+      
+      )
+      
+      subject.service_now( :insert, query, records_array )
+      
+    end
+    
+    it 'can update a record' do
+      
+      query = {
+        
+        'table' => 'core_company',
+        'where' => {
+          
+          'sys_id' => '_____SYS___ID____'
+          
+        }
+        
+      }
+      
+      record_array = [{
+        
+        'u_column_one' => 'one',
+        'u_column_two' => 'two'
+        
+      }]
+      
+      body = '{"u_column_one":"one","u_column_two":"two"}'
+      
+      @http_request.should_receive(
+      
+        :post
+      
+      ).with({
+      
+          :connect_timeout => 60,
+          :timeout => 120, 
+          :head => { 
+            
+            "Content-Type" => "application/json",
+            "cookie" => @cookies
+            
+          },
+          :body => body
+      
+      }).and_return(
+      
+        @http_request
+      
+      )
+      
+      EventMachine::HttpRequest.should_receive(
+      
+        :new
+      
+      ).with(
+      
+        "#{@url}/core_company.do?JSON&sysparm_action=update&sysparm_query=sys_id=_____SYS___ID____"
+      
+      ).and_return(
+      
+        @http_request
+      
+      )
+      
+      subject.service_now( :update, query, record_array )
+      
+    end
+    
+    it 'supports STARTSWITH' do
+      
+      subject.service_now_init( CONFIG['config'], LOG )
+      
+      result = []
+      
+      EventMachine::HttpRequest.should_receive(
+      
+        :new
+      
+      ).with(
+      
+        "#{@url}/core_company.do?JSON&sysparm_action=getKeys&sysparm_query=nameSTARTSWITHClue"
+      
+      ).and_return(
+      
+        @http_request
+      
+      )
+      
+      @http_request.should_receive( 
+      
+        :get 
+        
+      ).and_return(
+      
+        @http_request
+      
+      )
+      
+      subject.service_now( :getKeys, {
+        
+        'table' => 'core_company',
+        'where' => {
+          
+          'name' => '=STARTSWITHClue'
+          
+        }
+        
+      } )
+      
+    end
+  
+  end
+  
+end

data/spec/functional_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe ServiceNow do
+  
+  subject {
+    
+    LOG.on
+    subj = Object.extend( ServiceNow )
+    subj.service_now_init( CONFIG['config'], LOG )
+    subj
+    
+  }
+  
+  pending 'can get by CSV interface' do
+    
+    query = CONFIG['queries']['get_specific_report']
+    
+    result = []
+    subject.em_service_now( :getCSV, query ) do |record, error|
+      
+      
+      result << record unless record.nil?
+      
+    end
+    
+    result.length.should > 1
+    
+  end
+  
+  pending 'can get by JSON interface' do
+    
+    company = nil
+    
+    query = CONFIG['queries']['get_specific_company']
+    expectation = CONFIG['queries']['get_specific_company_expectation']
+    
+    subject.em_service_now( :getRecords, query ) do |record, status|
+    
+      company = record
+    
+    end
+    
+    company['name'].should == expectation
+    
+  end
+  
+  pending 'errors on invalid table name' do
+
+    result = nil
+    
+    subject.em_service_now( :getKeys, {
+      
+      'table' => 'nosuchtable',
+      'where' => {
+        'u_no_such_column' => 'MIA'
+      }
+      
+    } ) do |record, error|
+      
+      result = error
+      
+    end
+    
+    result.should match /Empty JSON response from/
+    
+  end
+  
+  pending 'can create an incident' do
+
+    query = {
+      
+      'table' => 'incident'
+      
+    }
+    
+    records = [
+      
+      CONFIG['incident']['create']
+      
+    ]
+    
+    subject.em_service_now( :insert, query, records )
+    
+  end
+  
+  pending 'can update incidents by company, short_description and status' do
+    
+    update_column = CONFIG['incident']['update']['column']
+    update_value = CONFIG['incident']['update']['value']
+    
+    query = {
+      
+      'table' => 'incident',
+      
+      'where' => { 
+                              
+        'company' => CONFIG['incident']['create']['company'],
+        'state'   => '=NOT IN6,7',
+        'short_description' => CONFIG['incident']['create']['short_description']
+        
+      }
+      
+    }
+    
+    records = [{
+      
+      update_column => update_value
+      
+    }]
+    
+    result = nil
+    
+    subject.em_service_now( :update, query, records ) do |record, error|
+      
+      result = record
+      
+    end
+    
+    result[ update_column ].should == update_value
+    
+  end
+  
+  
+  pending 'can close incidents by company, short_description and status' do
+    
+    query = {
+      
+      'table' => 'incident',
+      
+      'where' => { 
+                              
+        'company' => CONFIG['incident']['create']['company'],
+        'state'   => '=NOT IN6,7',
+        'short_description' => CONFIG['incident']['create']['short_description']
+        
+      }
+      
+    }
+    
+    records = [{
+       
+       'u_next_step' => 'Set to Resolved'
+        
+    }]
+    
+    subject.em_service_now( :update, query, records ) do |record, error|
+    
+      raise error.inspect unless error.nil?
+      
+    end
+    
+  end
+  
+end

data/spec/spec_config.yml.tmpl

@@ -0,0 +1,40 @@
+config:
+
+    :username: username@domain.com
+    :password: password
+    :url: https://yourDEVinstance.service-now.com
+
+queries:
+
+    get_specific_report:
+        #
+        # fetches a configured snow report
+        #
+        table: sys_report_template
+        #
+        # Should refer to configured report's sys_id
+        #
+        where:
+            jvar_report_id: 5896e8a30c16a00087c61678d080f220
+    
+    get_specific_company_expectation: COMPANY NAME
+    get_specific_company:
+        table: core_company
+        where:
+            name: COMPANY NAME
+
+
+incident:
+    
+    create:
+        company: 5fac1edc0a0a3c1e00ccdb50799bcec1
+        assignment_group: d625dccec0a8016700a222a0f7900d06
+        category: Lab
+        subcategory: Software
+        short_description: puppet error name
+        description: Description Text
+    
+    update:
+        column: u_event_count
+        value: '40'
+        

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require 'em-service-now'
+
+SPEC_CONFIG_FILE = "#{File.dirname( __FILE__ )}/spec_config.yml"
+
+CONFIG = YAML.load_file( 
+
+  SPEC_CONFIG_FILE
+  
+) if File.file?( SPEC_CONFIG_FILE )
+CONFIG = {} unless defined?( CONFIG )
+
+class FakeLogger
+  
+  def initialize( parameter = :noisey )
+    @parameter = parameter
+  end
+  
+  def on
+    @parameter = :noisey
+  end
+  
+  def off
+    @parameter = :silent
+  end
+  
+  def method_missing( symbol, *args, &block )
+    puts "LOG.#{symbol}: #{args}" unless @parameter == :silent
+  end
+  
+  #
+  # rspec won't match unless for these unless they'r defined
+  #
+  def info( msg )
+    puts "LOG.info: [#{msg}]" unless @parameter == :silent
+  end
+  
+  def warn( msg )
+    puts "LOG.warn: [#{msg}]" unless @parameter == :silent
+  end
+  
+end
+
+LOG = FakeLogger.new

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: em-service-now
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  version: "0.3"
+platform: ruby
+authors: 
+- Richard
+- ""
+- ""
+- ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        version: "1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        version: "1"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yaml
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: ""
+email: ops@clue.co.za
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- em-service-now.gemspec
+- lib/em-service-now.rb
+- lib/version.rb
+- spec/spec_helper.rb
+- spec/spec_config.yml.tmpl
+- spec/functional_spec.rb
+- spec/em-service-now_spec.rb
+homepage: https://github.com/cluetechnologies/em-service-now
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Tools for interfacing with service-now.com
+test_files: []
+