1
2
3 import sys
4 sys.path.append('.')
5
6 import omero.gateway
7 import omero.model
8 from omero.rtypes import *
9 import os
10 import subprocess
11 import re
12 import time
13 import urllib2
14
15 from types import StringTypes
16 from path import path
17
18 BASEPATH = os.path.dirname(os.path.abspath(__file__))
19 TESTIMG_URL = 'http://users.openmicroscopy.org.uk/~cneves-x/'
20 DEFAULT_GROUP_PERMS = 'rwr---'
21
22 if not omero.gateway.BlitzGateway.ICE_CONFIG:
23 try:
24 import settings
25 iceconfig = os.environ.get('ICE_CONFIG', None)
26 if iceconfig is None:
27 iceconfig = os.path.join(settings.OMERO_HOME, 'etc', 'ice.config')
28 omero.gateway.BlitzGateway.ICE_CONFIG = iceconfig
29 except ImportError:
30 pass
31 except AttributeError:
32 pass
48
52
55
56 -def login (alias, pw=None, groupname=None):
57 if isinstance(alias, UserEntry):
58 return alias.login(groupname=groupname)
59 elif pw is None:
60 return USERS[alias].login(groupname=groupname)
61 else:
62 return UserEntry(alias, pw).login(groupname=groupname)
63
66
67 -class UserEntry (object):
68 - def __init__ (self, name, passwd, firstname='', middlename='', lastname='', email='',
69 groupname=None, groupperms=None, groupowner=False, admin=False):
70 """
71 If no groupperms are passed, then check_group_perms will do nothing.
72 The default perms for newly created groups is defined in _getOrCreateGroup
73 """
74 self.name = name
75 self.passwd = passwd
76 self.firstname = firstname
77 self.middlename = middlename
78 self.lastname = lastname
79 self.email = email
80 self.admin = admin
81 self.groupname = groupname
82 self.groupperms = groupperms
83 self.groupowner = groupowner
84
85 - def fullname (self):
86 return '%s %s' % (self.firstname, self.lastname)
87
88 - def login (self, groupname=None):
89 if groupname == None:
90 groupname = self.groupname
91 client = omero.gateway.BlitzGateway(self.name, self.passwd, group=groupname, try_super=self.admin)
92 if not client.connect():
93 print "Can not connect"
94 return None
95
96 a = client.getAdminService()
97 if groupname is not None:
98 if client.getEventContext().groupName != groupname:
99 try:
100 g = a.lookupGroup(groupname)
101 client.setGroupForSession(g.getId().val)
102 except:
103 pass
104
105
106 self.groupname = a.getEventContext().groupName
107 if self.groupname != "system":
108 UserEntry.check_group_perms(client, self.groupname, self.groupperms)
109
110 return client
111
112 @staticmethod
113 - def check_group_perms(client, group, groupperms):
114 """
115 If expected permissions have been set, then this will
116 enforce equality. If groupperms are None, then
117 nothing will be checked.
118 """
119 if groupperms is not None:
120 if isinstance(group, StringTypes):
121 a = client.getAdminService()
122 g = a.lookupGroup(group)
123 else:
124 g = group
125 p = g.getDetails().getPermissions()
126 if str(p) != groupperms:
127 raise BadGroupPermissionsException( \
128 "%s group has wrong permissions! Expected: %s Found: %s" % \
129 (g.getName(), groupperms, p))
130
131
132 @staticmethod
133 - def assert_group_perms(client, group, groupperms):
134 """
135 If expected permissions have been set, then this will
136 change group permissions to those requested if not
137 already equal. If groupperms are None, then
138 nothing will be checked.
139 """
140 a = client.getAdminService()
141 try:
142 if isinstance(group, StringTypes):
143 g = a.lookupGroup(group)
144 else:
145 g = group
146 UserEntry.check_group_perms(client, g, groupperms)
147 except BadGroupPermissionsException:
148 client._waitOnCmd(client.chmodGroup(g.id.val, groupperms))
149
150 @staticmethod
151 - def _getOrCreateGroup (client, groupname, groupperms=None):
152
153
154 if groupperms is None:
155 groupperms = DEFAULT_GROUP_PERMS
156
157 a = client.getAdminService()
158 try:
159 g = a.lookupGroup(groupname)
160 except:
161 g = omero.model.ExperimenterGroupI()
162 g.setName(omero.gateway.omero_type(groupname))
163 p = omero.model.PermissionsI(groupperms)
164 g.details.setPermissions(p)
165 a.createGroup(g)
166 g = a.lookupGroup(groupname)
167 UserEntry.check_group_perms(client, groupname, groupperms)
168 return g
169
170 - def create (self, client, password):
171 a = client.getAdminService()
172 try:
173 a.lookupExperimenter(self.name)
174
175 return False
176 except:
177
178 pass
179 if self.groupname is None:
180 self.groupname = self.name + '_group'
181 g = UserEntry._getOrCreateGroup(client, self.groupname, self.groupperms)
182 u = omero.model.ExperimenterI()
183 u.setOmeName(omero.gateway.omero_type(self.name))
184 u.setFirstName(omero.gateway.omero_type(self.firstname))
185 u.setMiddleName(omero.gateway.omero_type(self.middlename))
186 u.setLastName(omero.gateway.omero_type(self.lastname))
187 u.setEmail(omero.gateway.omero_type(self.email))
188 a.createUser(u, g.getName().val)
189 u = a.lookupExperimenter(self.name)
190 if self.admin:
191 a.addGroups(u,(a.lookupGroup("system"),))
192 client.c.sf.setSecurityPassword(password)
193 a.changeUserPassword(u.getOmeName().val, omero.gateway.omero_type(self.passwd))
194 if self.groupowner:
195 a.setGroupOwner(g, u)
196 return True
197
198 - def changePassword (self, client, password, rootpass):
202
203 @staticmethod
204 - def addGroupToUser (client, groupname, groupperms=None):
205 if groupperms is None:
206 groupperms = DEFAULT_GROUP_PERMS
207
208 a = client.getAdminService()
209 admin_gateway = None
210 try:
211 if not 'system' in [x.name.val for x in a.containedGroups(client.getUserId())]:
212 admin_gateway = loginAsRoot()
213 a = admin_gateway.getAdminService()
214 else:
215 admin = client
216 g = UserEntry._getOrCreateGroup(client, groupname, groupperms)
217 a.addGroups(a.getExperimenter(client.getUserId()), (g,))
218 finally:
219
220 if admin_gateway:
221 admin_gateway.seppuku()
222
223 @staticmethod
224 - def setGroupForSession (client, groupname, groupperms=None):
225 if groupperms is None:
226 groupperms = DEFAULT_GROUP_PERMS
227
228 a = client.getAdminService()
229 if not groupname in [x.name.val for x in a.containedGroups(client.getUserId())]:
230 UserEntry.addGroupToUser(client, groupname, groupperms)
231
232 t = client.clone()
233 client.c.closeSession()
234 client._proxies = omero.gateway.NoProxies()
235 client._ctx = None
236 client.c = t.c
237 client.connect()
238 a = client.getAdminService()
239 g = a.lookupGroup(groupname)
240 client.setGroupForSession(g.getId().val)
241 return client
242
243 -class ObjectEntry (object):
245
246 -class ProjectEntry (ObjectEntry):
247 - def __init__ (self, name, owner, create_group=False, group_perms=None):
248 self.name = name
249 self.owner = owner
250 self.create_group = create_group
251 self.group_perms = group_perms
252
253 - def get (self, client=None, fromCreate=False):
254 if client is None:
255 client = USERS[self.owner].login()
256 for p in client.listProjects():
257 if p.getName() == self.name:
258 p.__loadedHotSwap__()
259 return p
260 return None
261
262 - def create (self, client=None):
263 if client is None:
264 client = USERS[self.owner].login()
265 p = self.get(client)
266 if p is not None:
267 return p
268 p = omero.model.ProjectI(loaded=True)
269 p.setName(omero.gateway.omero_type(self.name))
270 p.setDescription(omero.gateway.omero_type(self.name))
271 if self.create_group:
272 if isinstance(self.create_group, StringTypes):
273 groupname = self.create_group
274 else:
275 raise ValueError('group must be string')
276 groupname = 'project_test'
277
278 s = loginAsRoot()
279 g = UserEntry._getOrCreateGroup(s, groupname, self.group_perms)
280 try:
281 UserEntry.addGroupToUser (s, groupname, self.group_perms)
282 finally:
283 s.seppuku()
284
285 UserEntry.setGroupForSession(client, groupname, self.group_perms)
286 p = omero.gateway.ProjectWrapper(client, client.getUpdateService().saveAndReturnObject(p))
287 return self.get(client, True)
288
289 -class DatasetEntry (ObjectEntry):
290 - def __init__ (self, name, project, description=None, callback=None):
291 self.name = name
292 self.project = project
293 self.description = description
294 self.callback = callback
295
296 - def get (self, client, forceproj=None):
297 if forceproj is None:
298 if isinstance(self.project, StringTypes):
299 project = PROJECTS[self.project].get(client)
300 elif isinstance(self.project, ProjectEntry):
301 project = self.project.get(client)
302 else:
303 project = self.project
304 else:
305 project = forceproj
306 for d in project.listChildren():
307 if d.getName() == self.name and ((self.description is None and d.getDescription() == '') or (self.description is not None and omero.gateway.omero_type(d.getDescription()) == omero.gateway.omero_type(self.description))):
308 d.__loadedHotSwap__()
309 return d
310 return None
311
313 if isinstance(self.project, StringTypes):
314 project = PROJECTS[self.project]
315 user = USERS[project.owner]
316 client = user.login()
317 project = project.get(client)
318 else:
319 project = self.project
320 client = project._conn
321 d = self.get(client, project)
322 if d is not None and ((self.description is None and d.getDescription() == '') or (self.description is not None and omero.gateway.omero_type(d.getDescription()) == omero.gateway.omero_type(self.description))):
323 return d
324 d = omero.model.DatasetI(loaded=True)
325 d.setName(omero.gateway.omero_type(self.name))
326 if self.description is not None:
327 d.setDescription(omero.gateway.omero_type(self.description))
328 project.linkDataset(d)
329 project.save()
330 rv = self.get(client, project)
331 if self.callback:
332 self.callback(rv)
333 return rv
334
335 -class ImageEntry (ObjectEntry):
336 - def __init__ (self, name, filename, dataset, callback=None):
337 self.name = name
338 self.filename = filename
339 if self.name is None and filename:
340 self.name = os.path.basename(filename)
341 self.dataset = dataset
342 self.callback = callback
343
344 - def get (self, client, forceds=None):
345 if forceds is None:
346 dataset = DATASETS[self.dataset].get(client)
347 else:
348 dataset = forceds
349 for i in dataset.listChildren():
350 if i.getName() == self.name:
351 return i
352 return None
353
355 if isinstance(self.dataset, StringTypes):
356 dataset = DATASETS[self.dataset]
357 project = PROJECTS[dataset.project]
358 client = USERS[project.owner].login()
359 dataset = dataset.get(client)
360 else:
361 dataset = self.dataset
362 client = dataset._conn
363 i = self.get(client, dataset)
364 if i is not None:
365
366 return i
367
368 sys.stderr.write('I')
369 if self.filename is False:
370 UserEntry.setGroupForSession(client, dataset.getDetails().getGroup().getName())
371 self._createWithoutPixels(client, dataset)
372 return self.get(client, dataset)
373 fpath = os.path.join(BASEPATH, self.filename)
374 if not os.path.exists(fpath):
375 if not os.path.exists(os.path.dirname(fpath)):
376 os.makedirs(os.path.dirname(fpath))
377
378 try:
379
380 sys.stderr.write('<')
381 f = urllib2.urlopen(TESTIMG_URL + self.filename)
382 open(fpath, 'wb').write(f.read())
383 except urllib2.HTTPError:
384 raise IOError('No such file %s' % fpath)
385 host = dataset._conn.c.ic.getProperties().getProperty('omero.host') or 'localhost'
386 port = dataset._conn.c.ic.getProperties().getProperty('omero.port') or '4063'
387
388 possiblepaths = (path(".") / ".." / "bin" /"omero",
389 path(".") / ".." / ".."/ ".." / "dist" / "bin" / "omero",
390 path(".") / ".." / ".."/ ".." / "bin" / "omero",
391 "omero",
392 )
393
394 for exe in possiblepaths:
395 if exe.exists():
396 break
397 if exe == 'omero':
398 print "\n\nNo omero found! Add OMERO_HOME/bin to your PATH variable (See #5176)\n\n"
399
400 newconn = dataset._conn.clone()
401 newconn.connect()
402 try:
403 UserEntry.setGroupForSession(newconn, dataset.getDetails().getGroup().getName())
404 session = newconn._sessionUuid
405
406 exe += ' -s %s -k %s -p %s import -d %i -n' % (host, session, port, dataset.getId())
407 exe = exe.split() + [self.name, fpath]
408 print ' '.join(exe)
409 try:
410 p = subprocess.Popen(exe, shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
411 except OSError:
412 print "!!Please make sure the 'omero' executable is in PATH"
413 return None
414
415 pid = p.communicate()
416
417 try:
418 img = omero.gateway.ImageWrapper(dataset._conn, dataset._conn.getQueryService().find('Pixels', long(pid[0].split('\n')[0].strip())).image)
419 except ValueError:
420 print pid
421 raise
422
423 img.setName(self.name)
424
425 img.save()
426 if self.callback:
427 self.callback(img)
428 return img
429 finally:
430 newconn.seppuku()
431
432 - def _createWithoutPixels (self, client, dataset):
433 img = omero.model.ImageI()
434 img.setName(omero.gateway.omero_type(self.name))
435 img.setAcquisitionDate(rtime(0))
436 if not dataset.imageLinksLoaded:
437 print ".!."
438 dataset._obj._imageLinksSeq = []
439 dataset._obj._imageLinksLoaded = True;
440 dataset.linkImage(img)
441 dataset.save()
442
445
454
457
458 -def getImage (client, alias, forceds=None, autocreate=False):
465
466 -def bootstrap (onlyUsers=False, skipImages=True):
489
507
508 ROOT=UserEntry('root','ome',admin=True)
509
510 USERS = {
511
512 }
513
514 PROJECTS = {
515
516 }
517
518 DATASETS = {
519
520 }
521
522 IMAGES = {
523
524 }
525