Module: Rewritten

Extended by:
Rewritten
Includes:
Helpers
Included in:
Rewritten
Defined in:
lib/rewritten.rb,
lib/rewritten/server.rb,
lib/rewritten/helpers.rb,
lib/rewritten/version.rb,
lib/rewritten/rails/url_helpers.rb

Defined Under Namespace

Modules: Helpers, Rails Classes: Server

Constant Summary collapse

VERSION = 
"0.11.0"

Instance Method Summary collapse

Methods included from Helpers

#classify, #constantize, #decode, #encode

Instance Method Details

#add_hit(path, code, content_type) ⇒ Object 



218
219
220
221
 
# File 'lib/rewritten.rb', line 218

def add_hit(path, code, content_type)
  h = {:path => path, :code => code, :content_type => content_type}
  Rewritten.redis.sadd("hits", encode(h) )
end

#add_translation(line, to) ⇒ Object

translations



128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/rewritten.rb', line 128

def add_translation(line, to)
  from, flags = line.split(/\s+/)

  flags = flags.scan(/\[(\w+)\]/).first if flags

  redis.hset("from:#{from}", :to, to)
  redis.hset("from:#{from}", :flags, flags) if flags

  redis.sadd(:froms, from) 
  redis.sadd(:tos, to) 
  score = redis.zcard("to:#{to}") || 0
  redis.zadd("to:#{to}", score, from)  
end

#add_translations(to, froms) ⇒ Object 



142
143
144
 
# File 'lib/rewritten.rb', line 142

def add_translations(to, froms)
  froms.each {|from|  add_translation(from, to)}
end

#after_fork(&block) ⇒ Object

The after_fork hook will be run in the child process and is passed the current job. Any changes you make, therefore, will only live as long as the job currently being processed.

Call with a block to set the hook. Call with no arguments to return the hook.



99
100
101
 
# File 'lib/rewritten.rb', line 99

def after_fork(&block)
  block ? (@after_fork = block) : @after_fork
end

#after_fork=(after_fork) ⇒ Object

Set the after_fork proc.



104
105
106
 
# File 'lib/rewritten.rb', line 104

def after_fork=(after_fork)
  @after_fork = after_fork
end

#all_froms ⇒ Object 



172
173
174
 
# File 'lib/rewritten.rb', line 172

def all_froms
  Array(redis.smembers(:froms))
end

#all_hits ⇒ Object 



223
224
225
 
# File 'lib/rewritten.rb', line 223

def all_hits
  Rewritten.redis.smembers("hits").map{|e| decode(e)}
end

#all_tos ⇒ Object 



176
177
178
 
# File 'lib/rewritten.rb', line 176

def all_tos
  Array(Rewritten.redis.smembers(:tos))
end

#before_first_fork(&block) ⇒ Object

The before_first_fork hook will be run in the parent process only once, before forking to run the first job. Be careful- any changes you make will be permanent for the lifespan of the worker.

Call with a block to set the hook. Call with no arguments to return the hook.



68
69
70
 
# File 'lib/rewritten.rb', line 68

def before_first_fork(&block)
  block ? (@before_first_fork = block) : @before_first_fork
end

#before_first_fork=(before_first_fork) ⇒ Object

Set a proc that will be called in the parent process before the worker forks for the first time.



74
75
76
 
# File 'lib/rewritten.rb', line 74

def before_first_fork=(before_first_fork)
  @before_first_fork = before_first_fork
end

#before_fork(&block) ⇒ Object

The before_fork hook will be run in the parent process before every job, so be careful- any changes you make will be permanent for the lifespan of the worker.

Call with a block to set the hook. Call with no arguments to return the hook.



84
85
86
 
# File 'lib/rewritten.rb', line 84

def before_fork(&block)
  block ? (@before_fork = block) : @before_fork
end

#before_fork=(before_fork) ⇒ Object

Set the before_fork proc.



89
90
91
 
# File 'lib/rewritten.rb', line 89

def before_fork=(before_fork)
  @before_fork = before_fork
end

#clear_translations ⇒ Object 



163
164
165
 
# File 'lib/rewritten.rb', line 163

def clear_translations
  Rewritten.redis.del(*Rewritten.redis.keys) unless Rewritten.redis.keys.empty?
end

#exist_translation_for?(path) ⇒ Boolean

Returns:

  • (Boolean) 


214
215
216
 
# File 'lib/rewritten.rb', line 214

def exist_translation_for?(path)
  get_current_translation(path) != path
end

#froms ⇒ Object

Returns an array of all known source URLs (that are to translated)



168
169
170
 
# File 'lib/rewritten.rb', line 168

def froms
  Array(redis.smembers(:froms))
end

#full_line(from) ⇒ Object 



203
204
205
206
207
208
209
210
211
212
 
# File 'lib/rewritten.rb', line 203

def full_line(from)
  flags = get_flag_string(from)

  if flags == ""
    from
  else
    "#{from} [#{flags}]" 
  end

end

#get_all_translations(to) ⇒ Object 



184
185
186
 
# File 'lib/rewritten.rb', line 184

def get_all_translations(to)
  Rewritten.redis.zrange("to:#{to}", 0, -1)
end

#get_current_translation(path) ⇒ Object 



188
189
190
191
192
 
# File 'lib/rewritten.rb', line 188

def get_current_translation(path)
  translation = Rewritten.z_range("to:#{path}", -1)
  return translation if translation
  return path
end

#get_flag_string(from) ⇒ Object 



194
195
196
 
# File 'lib/rewritten.rb', line 194

def get_flag_string(from)
  Rewritten.redis.hget("from:#{from}", :flags)||""
end

#has_flag?(from, c) ⇒ Boolean

Returns:

  • (Boolean) 


198
199
200
201
 
# File 'lib/rewritten.rb', line 198

def has_flag?(from, c)
  return false unless Rewritten.redis.exists("from:#{from}")
  get_flag_string(from).index(c) != nil
end

#includes?(path) ⇒ Boolean

Returns:

  • (Boolean) 


227
228
229
 
# File 'lib/rewritten.rb', line 227

def includes?(path)
  Rewritten.redis.hget("from:#{path}", :to)
end

#info ⇒ Object

Returns a hash, similar to redis-rb’s #info, of interesting stats.



276
277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/rewritten.rb', line 276

def info
  return {
    :pending   => queues.inject(0) { |m,k| m + size(k) },
    #:processed => Stat[:processed],
    #:queues    => queues.size,
    #:workers   => workers.size.to_i,
    #:working   => working.size,
    #:failed    => Stat[:failed],
    :servers   => [redis_id],
    :environment  => ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
  }
end

#inline=(inline) ⇒ Object 



120
121
122
 
# File 'lib/rewritten.rb', line 120

def inline=(inline)
  @inline = inline
end

#inline? ⇒ Boolean Also known as: inline

If ‘inline’ is true Resque will call #perform method inline without queuing it into Redis and without any Resque callbacks. The ‘inline’ is false Resque jobs will be put in queue regularly.

Returns:

  • (Boolean) 


115
116
117
 
# File 'lib/rewritten.rb', line 115

def inline?
  @inline
end

#keys ⇒ Object

Returns an array of all known Resque keys in Redis. Redis’ KEYS operation is O(N) for the keyspace, so be careful - this can be slow for big databases.



291
292
293
294
295
 
# File 'lib/rewritten.rb', line 291

def keys
  redis.keys("*").map do |key|
    key.sub("#{redis.namespace}:", '')
  end
end

#num_froms ⇒ Object

return the number of froms



232
233
234
 
# File 'lib/rewritten.rb', line 232

def num_froms
  redis.scard(:froms).to_i
end

#num_translations(to) ⇒ Object 



146
147
148
 
# File 'lib/rewritten.rb', line 146

def num_translations(to)
  Rewritten.redis.zcard("to:#{to}")
end

#per_page ⇒ Object 



297
298
299
 
# File 'lib/rewritten.rb', line 297

def per_page
  20
end

#queues ⇒ Object

Returns an array of all known Resque queues as strings.



249
250
251
 
# File 'lib/rewritten.rb', line 249

def queues
  Array(redis.smembers(:queues))
end

#redis ⇒ Object

Returns the current Redis connection. If none has been created, will create a new one.



44
45
46
47
48
 
# File 'lib/rewritten.rb', line 44

def redis
  return @redis if @redis
  self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
  self.redis
end

#redis=(server) ⇒ Object

Accepts:

1. A 'hostname:port' String
2. A 'hostname:port:db' String (to select the Redis db)
3. A 'hostname:port/namespace' String (to set the Redis namespace)
4. A Redis URL String 'redis://host:port'
5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
   or `Redis::Namespace`.



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/rewritten.rb', line 21

def redis=(server)
  case server
  when String
    if server =~ /redis\:\/\//
      redis = Redis.connect(:url => server, :thread_safe => true)
    else
      server, namespace = server.split('/', 2)
      host, port, db = server.split(':')
      redis = Redis.new(:host => host, :port => port,
        :thread_safe => true, :db => db)
    end
    namespace ||= :rewritten

    @redis = Redis::Namespace.new(namespace, :redis => redis)
  when Redis::Namespace
    @redis = server
  else
    @redis = Redis::Namespace.new(:rewritten, :redis => server)
  end
end

#redis_id ⇒ Object 



50
51
52
53
54
55
56
57
58
59
 
# File 'lib/rewritten.rb', line 50

def redis_id
  # support 1.x versions of redis-rb
  if redis.respond_to?(:server)
    redis.server
  elsif redis.respond_to?(:nodes) # distributed
    redis.nodes.map { |n| n.id }.join(', ')
  else
    redis.client.id
  end
end

#remove_all_translations(to) ⇒ Object 



157
158
159
160
161
 
# File 'lib/rewritten.rb', line 157

def remove_all_translations(to)
  get_all_translations(to).each do |from|
    Rewritten.remove_translation(from, to)
  end
end

#remove_queue(queue) ⇒ Object

Given a queue name, completely deletes the queue.



259
260
261
262
 
# File 'lib/rewritten.rb', line 259

def remove_queue(queue)
  redis.srem(:queues, queue.to_s)
  redis.del("queue:#{queue}")
end

#remove_translation(from, to) ⇒ Object 



150
151
152
153
154
155
 
# File 'lib/rewritten.rb', line 150

def remove_translation(from, to)
   Rewritten.redis.del("from:#{from}")
   Rewritten.redis.srem(:froms, from)
   Rewritten.redis.zrem("to:#{to}", from)
   Rewritten.redis.srem(:tos, to) if num_translations(to) == 0
end

#targets ⇒ Object

Returns an array of all known URL targets.



254
255
256
 
# File 'lib/rewritten.rb', line 254

def targets 
  Array(redis.smembers(:targets))
end

#to_s ⇒ Object 



108
109
110
 
# File 'lib/rewritten.rb', line 108

def to_s
  "Rewritten Client connected to #{redis_id}"
end

#translate(from) ⇒ Object 



180
181
182
 
# File 'lib/rewritten.rb', line 180

def translate(from)
  redis.hget("from:#{from}", :to)
end

#watch_queue(queue) ⇒ Object

Used internally to keep track of which queues we’ve created. Don’t call this directly.



266
267
268
 
# File 'lib/rewritten.rb', line 266

def watch_queue(queue)
  redis.sadd(:queues, queue.to_s)
end

#z_range(key, start = 0, count = 1) ⇒ Object

Does the dirty work of fetching a range of items from a Redis list and converting them into Ruby objects.



238
239
240
241
242
243
244
245
246
 
# File 'lib/rewritten.rb', line 238

def z_range(key, start = 0, count = 1)
  if count == 1
    redis.zrange(key, start, start)[0]
  else
    Array(redis.zrange(key, start, start+count-1)).map do |item|
      item
    end
  end
end