Class: DangoFrameworkModule::SharedMemoryStore

Inherits:
Object
  • Object
show all
Defined in:
lib/dango/shared/memory_store.rb

Overview

共有メモリ

Instance Method Summary collapse

Constructor Details

#initialize(config) ⇒ SharedMemoryStore

Returns a new instance of SharedMemoryStore.



11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/dango/shared/memory_store.rb', line 11

def initialize(config)
  @config = config
  @data = {}
  @mutex = {}
#      @mutex = DangoMutex.new(:shared_mutex)
  
  @transact_key = {}
  @transact_thread = {}
  @transact_commit = {}
  @transact_rollback = {}
  @transact_data = {}
end

Instance Method Details

#[](key) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/dango/shared/memory_store.rb', line 144

def [](key)
  key = key.to_s
  if !@data.has_key?(key) # 未定義キーならエラー
    return(nil)
#        raise(DangoFrameworkException, "Shared key is not exist.")
  end
  
  @mutex[key].timeout_sync(2, "[] #{key}") do
#      @mutex.timeout_sync(2, "[]") do
    @data[key].deep_dup
  end
end

#[]=(key, value) ⇒ Object 



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/dango/shared/memory_store.rb', line 157

def []=(key, value)
  key = key.to_s
  # キーはString Symbolのみ
  if key.class != String && key.class != Symbol
    raise(DangoFrameworkException, "Shared key is not String or Symbol.")
  end
  
  key = key.to_s
  
  # 未定義なら定義する
  if !@data.has_key?(key)
    @mutex[key] = DangoMutex.new("shared_mutex_#{key}")
  end
  
  # ロックしてデータを入れる
  @mutex[key].timeout_sync(2, "[]= #{key}") do
#      @mutex.timeout_sync(2, "[]=") do
    @data[key] = value.deep_dup
  end
  
  value
end

#commit(value) ⇒ Object

トランザクションのコミット処理



109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/dango/shared/memory_store.rb', line 109

def commit(value) # トランザクションのコミット処理
  if ! @transact_key.has_key?(Thread.current)
    raise(DangoFrameworkTransactionException, "this thread has not transaction #{Thread.current}") 
  end
  key = @transact_key[Thread.current]
  
  if @transact_thread[key] != Thread.current
    raise(DangoFrameworkTransactionException, "not in transaction #{key}") 
  end
  
  @transact_commit[key] = true
  @transact_data[key] = value
  throw(:memory_store_finish_transaction)
end

#has_key?(key) ⇒ Boolean

キーがあるかどうかを返す

Returns:

  • (Boolean) 


139
140
141
142
 
# File 'lib/dango/shared/memory_store.rb', line 139

def has_key?(key) # キーがあるかどうかを返す
  key = key.to_s
  @data.has_key?(key)
end

#keys ⇒ Object 



24
25
26
 
# File 'lib/dango/shared/memory_store.rb', line 24

def keys
  @data.keys
end

#rollback ⇒ Object

トランザクションのロールバック処理



124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/dango/shared/memory_store.rb', line 124

def rollback() # トランザクションのロールバック処理
  if ! @transact_key.has_key?(Thread.current)
    raise(DangoFrameworkTransactionException, "this thread has not transaction #{Thread.current}") 
  end
  key = @transact_key[Thread.current]
  
  if @transact_thread[key] != Thread.current
    raise(DangoFrameworkTransactionException, "not in transaction #{key}") 
  end
  
  @transact_rollback[key] = true
  throw(:memory_store_finish_transaction)
end

#to_hash ⇒ Object

ハッシュ形式で取得



29
30
31
32
33
34
35
 
# File 'lib/dango/shared/memory_store.rb', line 29

def to_hash
  hash = {}
  @data.each do |k, v|
    hash[k.to_s] = v.deep_dup
  end
  hash
end

#transaction(key) ⇒ Object

トランザクション処理ブロックを作る（key単位のロック） このブロックの中でcommitかrollbackか例外発生を行わなければならない



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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/dango/shared/memory_store.rb', line 63

def transaction(key) 
  key = key.to_s
  if !@data.has_key?(key) # 未定義キーならエラー
    raise(DangoFrameworkException, "Shared key is not exist.")
  end
  
  @mutex[key].timeout_sync(2, "transaction #{key}") do
#      @mutex.timeout_sync(2, "transaction") do
    @transact_key[Thread.current] = key # 違うスレッドからcommitできないように
    
    raise("nested transaction #{key}") if @transact_thread.has_key?(key)
    @transact_thread[key] = Thread.current
    @transact_commit[key] = false
    @transact_rollback[key] = false
    @transact_data[key] = nil
    
    begin
      catch(:memory_store_finish_transaction) do
        yield(@data[key].deep_dup)
      end
    rescue Exception # 例外発生の場合はrollbackとみなして、直前のエラーを再発生
      @transact_rollback[key] = true
      raise
    ensure
      @transact_thread.delete(key)
      
      if @transact_commit[key] # commitされた場合 データ書き込み
        @data[key] = @transact_data[key].deep_dup
        
      elsif @transact_rollback[key] # rollbackがあった場合 何もしない
        
      else  # commitもrollbackもしていなければ
        raise(DangoFrameworkTransactionException, "not found commit and rollback in transaction")
      end
      
      @transact_commit.delete(key)
      @transact_rollback.delete(key)
      @transact_data.delete(key)
      
      @transact_key.delete(Thread.current)
    end
  end
  
  self
end