1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
import p2p
class ModelListener:
def __init__(self):
pass
def model_changed(self, key, value):
pass
class Model:
def __init__(self):
creator = Owner.getInstance()
self._uri = "urn:model:" + creator.get_id() + ":" + random()
self._values = {}
self.__listeners = []
def get_value(self, key):
return self._values[key]
def set_value(self, key, value):
self._values[key] = value
notify_changed(key, value)
def add_listener(self, listener):
self.__listeners.add(listener)
def notify_changed(self, key, value):
for listener in self.__listeners:
listener.model_changed(key, value)
def serialize(model):
return [ self._uri, self._values ]
serialize = staticmethod(serialize)
def deserialize(data):
[uri, values] = data
# FIXME How damn I do this right in python?
model = Model()
model._uri = uri
model._values = values
return model
deserialize = staticmethod(deserialize)
class ModelChangeSet:
def __init__(self):
self._values = {}
def add(self, key, value):
self._values[key] = value
class ClientModelListener(ModelListener):
def __init__(self, client, model):
self._model = model
def model_changed(self, key, value):
client.add_change(self._model, key, value)
class ModelStore:
instance = None
def __init__(self):
self._models = {}
self._group = p2p.Group.get_instance()
input_pipe = p2p.InputPipe(self._group, "model-store")
input_pipe.listen(self._model_request)
def get_instance():
if not ModelStore.instance:
ModelStore.instance = ModelStore()
return ModelStore.instance
get_instance = staticmethod(get_instance)
def add_model(self, model):
self._models[model.get_id(), model]
def _model_request(self, buddy, msg):
parts = msg.split(':')
model_id = self._group.get_buddy(parts[3])
model = self._models[model_id]
return model.serialize()
class ModelContext:
def __init__(self):
self._store = ModelStore.get_instance()
self._changes = {}
def _add_model(self, model):
self._store.add_model(model)
change_set = ModelChangeSet()
self.__changes[model_id, change_set]
listener = ClientModelListener(self)
model.add_listener(listener)
def fetch(self, model_uri):
parts = model_uri.split(':')
buddy = Group.get_instance().get_buddy(parts[2])
output_pipe = p2p.OutputPipe(group, buddy, "model-store")
model = output_pipe.send(model_uri)
self._add_model(model)
def commit(self):
pass
def add_change(self, model, key, value):
change_set = self.__changes[model.get_id()]
change_set.add(key, value)
|
