Class: Async::HTTP::Cache::General

Inherits:
Protocol::HTTP::Middleware
  • Object
show all
Defined in:
lib/async/http/cache/general.rb

Constant Summary collapse

CACHE_CONTROL = 
'cache-control'
CONTENT_TYPE = 
'content-type'
AUTHORIZATION = 
'authorization'

'cookie'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app, store: Store.default) ⇒ General

Returns a new instance of General.



39
40
41
42
43
44
45
 
# File 'lib/async/http/cache/general.rb', line 39

def initialize(app, store: Store.default)
  super(app)
  
  @count = 0
  
  @store = store
end

Instance Attribute Details

#count ⇒ Object (readonly)

Returns the value of attribute count.



47
48
49
 
# File 'lib/async/http/cache/general.rb', line 47

def count
  @count
end

#store ⇒ Object (readonly)

Returns the value of attribute store.



48
49
50
 
# File 'lib/async/http/cache/general.rb', line 48

def store
  @store
end

Instance Method Details

#cacheable?(request) ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/async/http/cache/general.rb', line 62

def cacheable?(request)
  # We don't support caching requests which have a body:
  if request.body
    return false
  end
  
  # We can't cache upgraded requests:
  if request.protocol
    return false
  end
  
  # We only support caching GET and HEAD requests:
  unless request.method == 'GET' || request.method == 'HEAD'
    return false
  end
  
  if request.headers[AUTHORIZATION]
    return false
  end
  
  if request.headers[COOKIE]
    return false
  end
  
  # Otherwise, we can cache it:
  return true
end

#call(request) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/async/http/cache/general.rb', line 109

def call(request)
  key = self.key(request)
  
  cache_control = request.headers[CACHE_CONTROL]
  
  unless cache_control&.no_cache?
    if response = @store.lookup(key, request)
      Async.logger.debug(self) {"Cache hit for #{key}..."}
      @count += 1
      
      # Return the cached response:
      return response
    end
  end
  
  unless cache_control&.no_store?
    if cacheable?(request)
      return wrap(key, request, super)
    end
  end
  
  return super
end

#close ⇒ Object 



50
51
52
53
54
 
# File 'lib/async/http/cache/general.rb', line 50

def close
  @store.close
ensure
  super
end

#key(request) ⇒ Object 



56
57
58
59
60
 
# File 'lib/async/http/cache/general.rb', line 56

def key(request)
  @store.normalize(request)
  
  [request.authority, request.method, request.path]
end

#wrap(key, request, response) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/async/http/cache/general.rb', line 90

def wrap(key, request, response)
  if response.status != 200
    return response
  end
  
  if request.head? and body = response.body
    unless body.empty?
      Async.logger.warn(self) {"HEAD request resulted in non-empty body!"}
      
      return response
    end
  end
  
  return Body.wrap(response) do |response, body|
    Async.logger.debug(self) {"Updating cache for #{key}..."}
    @store.insert(key, request, Response.new(response, body))
  end
end