fhir_client 1.6.3 → 1.6.7

data/.travis.yml

@@ -1,6 +1,11 @@
 language: ruby
 rvm:
   - "2.0.0"
+  - "2.1.10"
+  - "2.2.5"
+  - "2.3.1"
+before_install:
+  - gem install bundler
 services: mongodb
 script: bundle exec rake test
 notifications:
@@ -8,3 +13,6 @@ notifications:
     recipients:
       - healthcare-ci@googlegroups.com
     on_failure: change
+addons:
+    code_climate:
+        repo_token: ac1640edaefa720557e56bfaba4e09808559d7d61812f96d58ea4aa5f4669738

data/Gemfile

@@ -1,9 +1,9 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
+ruby RUBY_VERSION
 gemspec
 
 group :test do
-  gem 'simplecov', :require => false
-  gem 'minitest', "~> 4.0"
-  gem 'turn', :require => false
-  gem 'awesome_print', :require => 'ap'
+  gem 'codeclimate-test-reporter', require: nil
+  gem 'rubocop', '~> 0.43.0', require: false
+  gem 'awesome_print', require: 'ap'
 end

data/Rakefile

@@ -1,25 +1,26 @@
-require 'rake'
+require 'bundler/gem_tasks'
 require 'rake/testtask'
-require 'fileutils'
-require 'pry'
+require 'rubocop/rake_task'
 
-require_relative 'lib/fhir_client'
-
-# Pull in any rake task defined in lib/tasks
-Dir['lib/tasks/**/*.rake'].sort.each do |ext|
+Dir['lib/fhir_client/tasks/**/*.rake'].sort.each do |ext|
   load ext
 end
 
-desc "Run basic tests"
-Rake::TestTask.new(:test_unit) do |t|
-  t.libs << "test"
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
   t.test_files = FileList['test/**/*_test.rb']
   t.verbose = true
   t.warning = false
 end
 
-task :test => [:test_unit] do
-  system("open coverage/index.html")
+desc 'Run rubocop'
+task :rubocop do
+  RuboCop::RakeTask.new
+end
+
+task test: [:rubocop] do
+  system('open coverage/index.html')
 end
 
-task :default => [:test]
+task default: [:test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'fhir_client'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start
+
+# require 'irb'
+# IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fhir_client.gemspec

@@ -1,25 +1,38 @@
-# -*- encoding: utf-8 -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fhir_client/version'
 
-Gem::Specification.new do |s|
-  s.name = "fhir_client"
-  s.summary = "A Gem for handling FHIR client requests in ruby"
-  s.description = "A Gem for handling FHIR client requests in ruby"
-  s.email = "aquina@mitre.org"
-  s.homepage = "https://github.com/hl7-fhir/fhir-svn"
-  s.authors = ["Andre Quina", "Jason Walonoski", "Janoo Fernandes"]
-  s.version = '1.6.3'
+Gem::Specification.new do |spec|
+  spec.name          = 'fhir_client'
+  spec.version       = FHIR::Client::VERSION
+  spec.authors       = ['Andre Quina', 'Jason Walonoski', 'Janoo Fernandes']
+  spec.email         = ['aquina@mitre.org']
 
-  s.files = s.files = `git ls-files`.split("\n")
+  spec.summary       = %q{A Gem for handling FHIR client requests in ruby}
+  spec.description   = %q{A Gem for handling FHIR client requests in ruby}
+  spec.homepage      = 'https://github.com/fhir-crucible/fhir_client'
 
-  s.add_dependency 'fhir_models', '>= 1.6.1'
-  s.add_dependency 'tilt', '>= 1.1'
-  s.add_dependency 'rest-client', '~> 1.8'
-  s.add_dependency 'oauth2', '~> 1.1'
-  s.add_dependency 'activesupport', '>= 3'
-  s.add_dependency 'addressable', '>= 2.3'
-  s.add_dependency 'rack', '~> 1.5'
-  s.add_dependency 'nokogiri'
-  s.add_development_dependency 'pry'
-  s.add_development_dependency 'minitest'
-  s.add_development_dependency 'test-unit'
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '>= 3'
+  spec.add_dependency 'addressable', '>= 2.3'
+  spec.add_dependency 'fhir_models', '>= 1.6.6'
+  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'oauth2', '~> 1.1'
+  spec.add_dependency 'rack', '>= 1.5'
+  spec.add_dependency 'rest-client', '~> 1.8'
+  spec.add_dependency 'tilt', '>= 1.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency 'simplecov'
 end

data/lib/fhir_client.rb

@@ -1,26 +1,21 @@
-# Top level include file that brings in all the necessary code
-require 'bundler/setup'
-require 'yaml'
-require 'nokogiri'
 require 'fhir_models'
-require 'rest_client'
-require 'addressable/uri'
-require 'oauth2'
-require 'active_support'
 require 'active_support/all'
 
-root = File.expand_path '..', File.dirname(File.absolute_path(__FILE__))
-Dir.glob(File.join(root, 'lib','sections','**','*.rb')).each do |file|
+root = File.expand_path '.', File.dirname(File.absolute_path(__FILE__))
+Dir.glob(File.join(root, 'fhir_client', 'sections', '**', '*.rb')).each do |file|
   require file
 end
-Dir.glob(File.join(root, 'lib','ext','**','*.rb')).each do |file|
+Dir.glob(File.join(root, 'fhir_client', 'ext', '**', '*.rb')).each do |file|
   require file
 end
 
-require_relative File.join('.','client_interface.rb')
-require_relative File.join('.','resource_address.rb')
-require_relative File.join('.','resource_format.rb')
-require_relative File.join('.','patch_format.rb')
-require_relative File.join('.','model','client_reply.rb')
-require_relative File.join('.','model','tag.rb')
-require_relative File.join('.','client_exception.rb')
+require_relative 'fhir_client/client'
+require_relative 'fhir_client/resource_address'
+require_relative 'fhir_client/resource_format'
+require_relative 'fhir_client/patch_format'
+require_relative 'fhir_client/client_exception'
+require_relative 'fhir_client/version'
+
+Dir.glob(File.join(root, 'fhir_client', 'model', '**', '*.rb')).each do |file|
+  require file
+end

data/lib/fhir_client/client.rb

@@ -0,0 +1,533 @@
+require 'rest_client'
+require 'nokogiri'
+require 'addressable/uri'
+require 'oauth2'
+
+module FHIR
+  class Client
+    include FHIR::Sections::History
+    include FHIR::Sections::Crud
+    include FHIR::Sections::Validate
+    include FHIR::Sections::Tags
+    include FHIR::Sections::Feed
+    include FHIR::Sections::Search
+    include FHIR::Sections::Operations
+    include FHIR::Sections::Transactions
+
+    attr_accessor :reply
+    attr_accessor :use_format_param
+    attr_accessor :use_basic_auth
+    attr_accessor :use_oauth2_auth
+    attr_accessor :security_headers
+    attr_accessor :client
+
+    attr_accessor :default_format
+
+    attr_accessor :cached_conformance
+
+    # Call method to initialize FHIR client. This method must be invoked
+    # with a valid base server URL prior to using the client.
+    #
+    # @param base_service_url Base service URL for FHIR Service.
+    # @param default_format Default Format Mime type
+    # @return
+    #
+    def initialize(base_service_url, default_format: FHIR::Formats::ResourceFormat::RESOURCE_XML)
+      @base_service_url = base_service_url
+      FHIR.logger.info "Initializing client with #{@base_service_url}"
+      @use_format_param = false
+      @default_format = default_format
+      set_no_auth
+    end
+
+    def default_json
+      @default_format = FHIR::Formats::ResourceFormat::RESOURCE_JSON
+    end
+
+    def default_xml
+      @default_format = FHIR::Formats::ResourceFormat::RESOURCE_XML
+    end
+
+    # Set the client to use no authentication mechanisms
+    def set_no_auth
+      FHIR.logger.info 'Configuring the client to use no authentication.'
+      @use_oauth2_auth = false
+      @use_basic_auth = false
+      @security_headers = {}
+      @client = RestClient
+    end
+
+    # Set the client to use HTTP Basic Authentication
+    def set_basic_auth(client, secret)
+      FHIR.logger.info 'Configuring the client to use HTTP Basic authentication.'
+      token = Base64.encode64("#{client}:#{secret}")
+      value = "Basic #{token}"
+      @security_headers = { 'Authorization' => value }
+      @use_oauth2_auth = false
+      @use_basic_auth = true
+      @client = RestClient
+    end
+
+    # Set the client to use Bearer Token Authentication
+    def set_bearer_token(token)
+      FHIR.logger.info 'Configuring the client to use Bearer Token authentication.'
+      value = "Bearer #{token}"
+      @security_headers = { 'Authorization' => value }
+      @use_oauth2_auth = false
+      @use_basic_auth = true
+      @client = RestClient
+    end
+
+    # Set the client to use OpenID Connect OAuth2 Authentication
+    # client -- client id
+    # secret -- client secret
+    # authorize_path -- absolute path of authorization endpoint
+    # token_path -- absolute path of token endpoint
+    def set_oauth2_auth(client, secret, authorize_path, token_path)
+      FHIR.logger.info 'Configuring the client to use OpenID Connect OAuth2 authentication.'
+      @use_oauth2_auth = true
+      @use_basic_auth = false
+      @security_headers = {}
+      options = {
+        site: @base_service_url,
+        authorize_url: authorize_path,
+        token_url: token_path,
+        raise_errors: true
+      }
+      client = OAuth2::Client.new(client, secret, options)
+      @client = client.client_credentials.get_token
+    end
+
+    # Get the OAuth2 server and endpoints from the conformance statement
+    # (the server should not require OAuth2 or other special security to access
+    # the conformance statement).
+    # <rest>
+    #   <mode value="server"/>
+    #   <documentation value="All the functionality defined in FHIR"/>
+    #   <security>
+    #   <extension url="http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris">
+    #     <extension url="register">
+    #       <valueUri value="https://authorize-dstu2.smarthealthit.org/register"/>
+    #     </extension>
+    #     <extension url="authorize">
+    #       <valueUri value="https://authorize-dstu2.smarthealthit.org/authorize"/>
+    #     </extension>
+    #     <extension url="token">
+    #       <valueUri value="https://authorize-dstu2.smarthealthit.org/token"/>
+    #     </extension>
+    #   </extension>
+    #   <service>
+    #     <coding>
+    #       <system value="http://hl7.org/fhir/vs/restful-security-service"/>
+    #       <code value="OAuth2"/>
+    #     </coding>
+    #     <text value="OAuth version 2 (see oauth.net)."/>
+    #   </service>
+    #   <description value="SMART on FHIR uses OAuth2 for authorization"/>
+    # </security>
+    def get_oauth2_metadata_from_conformance
+      options = {
+        authorize_url: nil,
+        token_url: nil
+      }
+      oauth_extension = 'http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris'
+      authorize_extension = 'authorize'
+      token_extension = 'token'
+      begin
+        conformance = conformance_statement
+        conformance.rest.each do |rest|
+          rest.security.service.each do |service|
+            service.coding.each do |coding|
+              next unless coding.code == 'SMART-on-FHIR'
+              rest.security.extension.where(url: oauth_extension).first.extension.each do |ext|
+                case ext.url
+                when authorize_extension
+                  options[:authorize_url] = ext.value.value
+                when "#{oauth_extension}\##{authorize_extension}"
+                  options[:authorize_url] = ext.value.value
+                when token_extension
+                  options[:token_url] = ext.value.value
+                when "#{oauth_extension}\##{token_extension}"
+                  options[:token_url] = ext.value.value
+                end
+              end
+            end
+          end
+        end
+      rescue
+        FHIR.logger.error 'Failed to locate SMART-on-FHIR OAuth2 Security Extensions.'
+      end
+      options.delete_if { |_k, v| v.nil? }
+      options.clear if options.keys.size != 2
+      options
+    end
+
+    # Method returns a conformance statement for the system queried.
+    # @return
+    def conformance_statement(format = FHIR::Formats::ResourceFormat::RESOURCE_XML)
+      if @cached_conformance.nil? || format != @default_format
+        try_conformance_formats(format)
+      end
+      @cached_conformance
+    end
+
+    def try_conformance_formats(default_format)
+      formats = [FHIR::Formats::ResourceFormat::RESOURCE_XML,
+                 FHIR::Formats::ResourceFormat::RESOURCE_JSON,
+                 FHIR::Formats::ResourceFormat::RESOURCE_XML_DSTU2,
+                 FHIR::Formats::ResourceFormat::RESOURCE_JSON_DSTU2,
+                 'application/xml',
+                 'application/json']
+      formats.insert(0, default_format)
+
+      @cached_conformance = nil
+      @default_format = nil
+
+      formats.each do |frmt|
+        reply = get 'metadata', fhir_headers(format: frmt)
+        next unless reply.code == 200
+        @cached_conformance = parse_reply(FHIR::Conformance, frmt, reply)
+        @default_format = frmt
+        break
+      end
+      @default_format = default_format if @default_format.nil?
+      @default_format
+    end
+
+    def resource_url(options)
+      FHIR::ResourceAddress.new.resource_url(options, @use_format_param)
+    end
+
+    def full_resource_url(options)
+      @base_service_url + resource_url(options)
+    end
+
+    def fhir_headers(options = {})
+      FHIR::ResourceAddress.new.fhir_headers(options, @use_format_param)
+    end
+
+    def parse_reply(klass, format, response)
+      FHIR.logger.info "Parsing response with {klass: #{klass}, format: #{format}, code: #{response.code}}."
+      return nil unless [200, 201].include? response.code
+      res = nil
+      begin
+        res = FHIR.from_contents(response.body)
+        res.client = self unless res.nil?
+        FHIR.logger.warn "Expected #{klass} but got #{res.class}" if res.class != klass
+      rescue => e
+        FHIR.logger.error "Failed to parse #{format} as resource #{klass}: #{e.message} %n #{e.backtrace.join("\n")} #{response}"
+        nil
+      end
+      res
+    end
+
+    def strip_base(path)
+      path.gsub(@base_service_url, '')
+    end
+
+    def reissue_request(request)
+      if [:get, :delete, :head].include?(request['method'])
+        method(request['method']).call(request['url'], request['headers'])
+      elsif [:post, :put].include?(request['method'])
+        resource = FHIR.from_contents(request['payload']) unless request['payload'].nil?
+        method(request['method']).call(request['url'], resource, request['headers'])
+      end
+    end
+
+    private
+
+    def base_path(path)
+      if path.start_with?('/')
+        if @base_service_url.end_with?('/')
+          @base_service_url.chop
+        else
+          @base_service_url
+        end
+      else
+        @base_service_url + '/'
+      end
+    end
+
+    # Extract the request payload in the specified format, defaults to XML
+    def request_payload(resource, headers)
+      if headers
+        format_specified = headers[:format] || headers['format']
+        if format_specified.downcase.include?('xml')
+          resource.to_xml
+        elsif format_specified.downcase.include?('json')
+          resource.to_json
+        else
+          resource.to_xml
+        end
+      else
+        resource.to_xml
+      end
+    end
+
+    def request_patch_payload(patchset, format)
+      if format == FHIR::Formats::PatchFormat::PATCH_JSON
+        patchset.each do |patch|
+          # remove the resource name from the patch path, since the JSON representation doesn't have that
+          patch[:path] = patch[:path].slice(patch[:path].index('/')..-1)
+        end
+        patchset.to_json
+      elsif format == FHIR::Formats::PatchFormat::PATCH_XML
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          patchset.each do |patch|
+            xml.diff do
+              # TODO: support other kinds besides just replace
+              xml.replace(patch[:value], sel: patch[:path] + '/@value') if patch[:op] == 'replace'
+            end
+          end
+        end
+        builder.to_xml
+      end
+    end
+
+    def clean_headers(headers)
+      headers.delete_if { |k, v| (k.nil? || v.nil?) }
+      headers.each_with_object({}) { |(k, v), h| h[k.to_s] = v.to_s; h }
+    end
+
+    def scrubbed_response_headers(result)
+      result.each_key do |k|
+        v = result[k]
+        result[k] = v[0] if v.is_a? Array
+      end
+    end
+
+    def get(path, headers)
+      url = Addressable::URI.parse(build_url(path)).to_s
+      FHIR.logger.info "GETTING: #{url}"
+      headers = clean_headers(headers)
+      if @use_oauth2_auth
+        # @client.refresh!
+        begin
+          response = @client.get(url, headers: headers)
+        rescue => e
+          response = e.response if e.response
+        end
+        req = {
+          method: :get,
+          url: url,
+          path: url.gsub(@base_service_url, ''),
+          headers: headers,
+          payload: nil
+        }
+        res = {
+          code: response.status.to_s,
+          headers: response.headers,
+          body: response.body
+        }
+        FHIR.logger.info "GET - Request: #{req}, Response: #{response.body.force_encoding('UTF-8')}"
+        @reply = FHIR::ClientReply.new(req, res)
+      else
+        headers.merge!(@security_headers) if @use_basic_auth
+        begin
+          response = @client.get(url, headers)
+        rescue => e
+          response = e.response if e.response
+        end
+
+        FHIR.logger.info "GET - Request: #{response.request.to_json}, Response: #{response.body.force_encoding('UTF-8')}"
+        response.request.args[:path] = response.request.args[:url].gsub(@base_service_url, '')
+        headers = response.headers.each_with_object({}) { |(k, v), h| h[k.to_s.tr('_', '-')] = v.to_s; h }
+        res = {
+          code: response.code,
+          headers: scrubbed_response_headers(headers),
+          body: response.body
+        }
+
+        @reply = FHIR::ClientReply.new(response.request.args, res)
+      end
+    end
+
+    def post(path, resource, headers)
+      url = URI(build_url(path)).to_s
+      FHIR.logger.info "POSTING: #{url}"
+      headers = clean_headers(headers)
+      payload = request_payload(resource, headers) if resource
+      if @use_oauth2_auth
+        # @client.refresh!
+        begin
+          response = @client.post(url, headers: headers, body: payload)
+        rescue => e
+          response = e.response if e.response
+        end
+        req = {
+          method: :post,
+          url: url,
+          path: url.gsub(@base_service_url, ''),
+          headers: headers,
+          payload: payload
+        }
+        res = {
+          code: response.status.to_s,
+          headers: response.headers,
+          body: response.body
+        }
+        FHIR.logger.info "POST - Request: #{req}, Response: #{response.body.force_encoding('UTF-8')}"
+        @reply = FHIR::ClientReply.new(req, res)
+      else
+        headers.merge!(@security_headers) if @use_basic_auth
+        @client.post(url, payload, headers) do |resp, request, result|
+          FHIR.logger.info "POST - Request: #{request.to_json}, Response: #{resp.force_encoding('UTF-8')}"
+          request.args[:path] = url.gsub(@base_service_url, '')
+          res = {
+            code: result.code,
+            headers: scrubbed_response_headers(result.each_key {}),
+            body: resp
+          }
+          @reply = FHIR::ClientReply.new(request.args, res)
+        end
+      end
+    end
+
+    def put(path, resource, headers)
+      url = URI(build_url(path)).to_s
+      FHIR.logger.info "PUTTING: #{url}"
+      headers = clean_headers(headers)
+      payload = request_payload(resource, headers) if resource
+      if @use_oauth2_auth
+        # @client.refresh!
+        begin
+          response = @client.put(url, headers: headers, body: payload)
+        rescue => e
+          response = e.response if e.response
+        end
+        req = {
+          method: :put,
+          url: url,
+          path: url.gsub(@base_service_url, ''),
+          headers: headers,
+          payload: payload
+        }
+        res = {
+          code: response.status.to_s,
+          headers: response.headers,
+          body: response.body
+        }
+        FHIR.logger.info "PUT - Request: #{req}, Response: #{response.body.force_encoding('UTF-8')}"
+        @reply = FHIR::ClientReply.new(req, res)
+      else
+        headers.merge!(@security_headers) if @use_basic_auth
+        @client.put(url, payload, headers) do |resp, request, result|
+          FHIR.logger.info "PUT - Request: #{request.to_json}, Response: #{resp.force_encoding('UTF-8')}"
+          request.args[:path] = url.gsub(@base_service_url, '')
+          res = {
+            code: result.code,
+            headers: scrubbed_response_headers(result.each_key {}),
+            body: resp
+          }
+          @reply = FHIR::ClientReply.new(request.args, res)
+        end
+      end
+    end
+
+    def patch(path, patchset, headers)
+      url = URI(build_url(path)).to_s
+      FHIR.logger.info "PATCHING: #{url}"
+      headers = clean_headers(headers)
+      payload = request_patch_payload(patchset, headers['format'])
+      if @use_oauth2_auth
+        # @client.refresh!
+        begin
+          response = @client.patch(url, headers: headers, body: payload)
+        rescue => e
+          response = e.response if e.response
+        end
+        req = {
+          method: :patch,
+          url: url,
+          path: url.gsub(@base_service_url, ''),
+          headers: headers,
+          payload: payload
+        }
+        res = {
+          code: response.status.to_s,
+          headers: response.headers,
+          body: response.body
+        }
+        FHIR.logger.info "PATCH - Request: #{req}, Response: #{response.body.force_encoding('UTF-8')}"
+        @reply = FHIR::ClientReply.new(req, res)
+      else
+        headers.merge!(@security_headers) if @use_basic_auth
+        # url = 'http://requestb.in/o8juy3o8'
+        @client.patch(url, payload, headers) do |resp, request, result|
+          FHIR.logger.info "PATCH - Request: #{request.to_json}, Response: #{resp.force_encoding('UTF-8')}"
+          request.args[:path] = url.gsub(@base_service_url, '')
+          res = {
+            code: result.code,
+            headers: scrubbed_response_headers(result.each_key {}),
+            body: resp
+          }
+          @reply = FHIR::ClientReply.new(request.args, res)
+        end
+      end
+    end
+
+    def delete(path, headers)
+      url = URI(build_url(path)).to_s
+      FHIR.logger.info "DELETING: #{url}"
+      headers = clean_headers(headers)
+      if @use_oauth2_auth
+        # @client.refresh!
+        begin
+          response = @client.delete(url, headers: headers)
+        rescue => e
+          response = e.response if e.response
+        end
+        req = {
+          method: :delete,
+          url: url,
+          path: url.gsub(@base_service_url, ''),
+          headers: headers,
+          payload: nil
+        }
+        res = {
+          code: response.status.to_s,
+          headers: response.headers,
+          body: response.body
+        }
+        FHIR.logger.info "DELETE - Request: #{req}, Response: #{response.body.force_encoding('UTF-8')}"
+        @reply = FHIR::ClientReply.new(req, res)
+      else
+        headers.merge!(@security_headers) if @use_basic_auth
+        @client.delete(url, headers) do |resp, request, result|
+          FHIR.logger.info "DELETE - Request: #{request.to_json}, Response: #{resp.force_encoding('UTF-8')}"
+          request.args[:path] = url.gsub(@base_service_url, '')
+          res = {
+            code: result.code,
+            headers: scrubbed_response_headers(result.each_key {}),
+            body: resp
+          }
+          @reply = FHIR::ClientReply.new(request.args, res)
+        end
+      end
+    end
+
+    def head(path, headers)
+      headers.merge!(@security_headers) unless @security_headers.blank?
+      url = URI(build_url(path)).to_s
+      FHIR.logger.info "HEADING: #{url}"
+      RestClient.head(url, headers) do |response, request, result|
+        FHIR.logger.info "HEAD - Request: #{request.to_json}, Response: #{response.force_encoding('UTF-8')}"
+        request.args[:path] = url.gsub(@base_service_url, '')
+        res = {
+          code: result.code,
+          headers: scrubbed_response_headers(result.each_key {}),
+          body: response
+        }
+        @reply = FHIR::ClientReply.new(request.args, res)
+      end
+    end
+
+    def build_url(path)
+      if path =~ /^\w+:\/\//
+        path
+      else
+        "#{base_path(path)}#{path}"
+      end
+    end
+  end
+end