1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import re
23 import logging
24
25 from django.utils.encoding import smart_unicode, force_unicode
26
27 from omero import client_wrapper
28 from omero_version import omero_version
29
30 logger = logging.getLogger(__name__)
33 - def __new__(cls, name, bases, attr):
34 attr['_registry'] = {}
35 attr['_frozen'] = False
36 return type.__new__(cls, name, bases, attr)
37
39 return iter(cls._registry.values())
40
42 __metaclass__ = IterRegistry
43 _next_id = 1
44
45 - def __init__(self, host, port, server=None):
54
55 - def __new__(cls, host, port, server=None):
56 for key in cls._registry:
57 val = cls._registry[key]
58 if val.host == host and val.port == port:
59 return cls._registry[key]
60
61 if cls._frozen:
62 raise TypeError('No more instances allowed')
63 else:
64 return object.__new__(cls)
65
66 @classmethod
68 if cls._registry.has_key(pk):
69 return cls._registry[pk]
70 return None
71
72 @classmethod
75
76 @classmethod
78 cls._registry = {}
79 cls._frozen = False
80 cls._next_id = 1
81
83
85 """
86 Json for printin settings.py: [["localhost", 4064, "omero"]]'
87 """
88 return """["%s", %s, "%s"]""" % (self.host, self.port, self.server)
89
91 return force_unicode(self).encode('utf-8')
92
95
96 @classmethod
98 r = None
99 try:
100 pk = int(pk)
101 except:
102 pass
103 else:
104 if cls._registry.has_key(pk):
105 r = cls._registry[pk]
106 return r
107
108 @classmethod
109 - def find(cls, host=None, port=None, server=None):
110 rv = []
111 for s in cls._registry.values():
112 if (host is not None and host != s.host) or \
113 (port is not None and port != s.port) or \
114 (server is not None and server != s.server):
115 continue
116 rv.append(s)
117 return rv
118
120 """
121 Object which encompasses all of the logic related to a Blitz connection
122 and its status with respect to OMERO.web.
123 """
124
125 SERVER_VERSION_RE = re.compile("^.*?[-]?(\\d+[.]\\d+([.]\\d+)?)[-]?.*?$")
126
127 - def __init__(self, server_id, is_secure):
128 self.server_id = server_id
129 self.is_secure = is_secure
130 self.is_public = False
131 self.omero_session_key = None
132 self.user_id = None
133
139
145
158
159
172
174 connection = None
175 guest = 'guest'
176 try:
177 connection = self.create_gateway(useragent, guest, guest)
178 if connection.connect():
179 logger.debug('Successfully created a guest connection.')
180 else:
181 logger.warn('Cannot create a guest connection.')
182 except:
183 logger.error('Cannot create a guest connection.', exc_info=True)
184 return connection
185
187 try:
188 connection = self.create_gateway(useragent)
189 if connection.connect(sUuid=self.omero_session_key):
190 logger.debug('Successfully joined connection: %s' % \
191 self.omero_session_key)
192 connection.setUserId(self.user_id)
193 self.prepare_gateway(connection)
194 return connection
195 except:
196 logger.debug('Cannot create a new connection.', exc_info=True)
197 return None
198
200 connection = self.create_guest_connection(useragent)
201 if connection is None:
202 return False
203 try:
204 connection.getServerVersion()
205 return True
206 except:
207 logger.error('Cannot request server version.', exc_info=True)
208 return False
209
211 connection = self.create_guest_connection(useragent)
212 if connection is None:
213 return False
214 try:
215 server_version = connection.getServerVersion()
216 server_version = self.SERVER_VERSION_RE.match(server_version)
217 server_version = server_version.group(1).split('.')
218
219 client_version = self.SERVER_VERSION_RE.match(omero_version)
220 client_version = client_version.group(1).split('.')
221 logger.info("Client version: '%s'; Server version: '%s'" % \
222 (client_version, server_version))
223 return server_version == client_version
224 except:
225 logger.error('Cannot compare server to client version.',
226 exc_info=True)
227 return False
228