def load(self, info):
getPlugin('large_image').load(info)
ModelImporter.registerModel('annotation', Annotation, 'large_image')
info['apiRoot'].annotation = AnnotationResource()
# Ask for some models to make sure their singletons are initialized.
Annotation()
# add copyAnnotations option to POST resource/copy, POST item/{id}/copy
# and POST folder/{id}/copy
info['apiRoot'].resource.copyResources.description.param(
'copyAnnotations',
'Copy annotations when copying resources (default true)',
required=False,
dataType='boolean')
info['apiRoot'].item.copyItem.description.param(
'copyAnnotations',
'Copy annotations when copying item (default true)',
required=False,
dataType='boolean')
info['apiRoot'].folder.copyFolder.description.param(
'copyAnnotations',
'Copy annotations when copying folder (default true)',
required=False,
dataType='boolean')
def load(self, info):
ModelImporter.registerModel('project', ProjectModel, 'hpccloud')
ModelImporter.registerModel('simulation', SimulationModel, 'hpccloud')
info['apiRoot'].projects = Projects()
info['apiRoot'].simulations = Simulations()
file.load(info['apiRoot'])
def load(self, info):
getPlugin('worker').load(info)
unbindGirderEventsByHandlerName('large_image')
ModelImporter.registerModel('image_item', ImageItem, 'large_image')
large_image.config.setConfig('logger', girder.logger)
large_image.config.setConfig('logprint', girder.logprint)
# Load girder's large_image config
curConfig = config.getConfig().get('large_image')
for key, value in six.iteritems(curConfig or {}):
large_image.config.setConfig(key, value)
girder_tilesource.loadGirderTileSources()
TilesItemResource(info['apiRoot'])
info['apiRoot'].large_image = LargeImageResource()
Item().exposeFields(level=AccessType.READ, fields='largeImage')
events.bind('data.process', 'large_image', _postUpload)
events.bind('jobs.job.update.after', 'large_image', _updateJob)
events.bind('model.job.save', 'large_image', _updateJob)
events.bind('model.job.remove', 'large_image', _updateJob)
events.bind('model.folder.save.after', 'large_image', invalidateLoadModelCache)
events.bind('model.group.save.after', 'large_image', invalidateLoadModelCache)
events.bind('model.user.save.after', 'large_image', invalidateLoadModelCache)
events.bind('model.collection.save.after', 'large_image', invalidateLoadModelCache)
events.bind('model.item.remove', 'large_image', invalidateLoadModelCache)
events.bind('model.item.copy.prepare', 'large_image', prepareCopyItem)
events.bind('model.item.copy.after', 'large_image', handleCopyItem)
events.bind('model.item.save.after', 'large_image', invalidateLoadModelCache)
events.bind('model.file.save.after', 'large_image', checkForLargeImageFiles)
events.bind('model.item.remove', 'large_image.removeThumbnails', removeThumbnails)
events.bind('server_fuse.unmount', 'large_image', large_image.cache_util.cachesClear)
events.bind('model.file.remove', 'large_image', handleRemoveFile)
def load(self, info):
Assetstore().exposeFields(AccessType.READ, AssetstoreRuleMarker)
ModelImporter.registerModel(
GCSNotificationRecord().name,
GCSNotificationRecord,
plugin='dive_server',
)
info["apiRoot"].bucket_notifications = BucketNotification()
def load(self, info):
ModelImporter.registerModel('histogram', Histogram, 'histogram')
info['apiRoot'].histogram = HistogramResource()
events.bind('model.item.remove', 'Histogram', _onRemoveItem)
events.bind('model.file.remove', 'Histogram', _onRemoveFile)
events.bind('data.process', 'Histogram', _onUpload)
events.bind('jobs.job.update.after', 'Histogram', _updateJob)
events.bind('model.job.save', 'Histogram', _updateJob)
events.bind('model.job.remove', 'Histogram', _updateJob)
def load(self, info):
ModelImporter.registerModel('annotationItem', AnnotationItem, plugin='dive_server')
ModelImporter.registerModel('revisionLogItem', RevisionLogItem, plugin='dive_server')
info["apiRoot"].dive_annotation = AnnotationResource("dive_annotation")
info["apiRoot"].dive_configuration = ConfigurationResource("dive_configuration")
info["apiRoot"].dive_dataset = DatasetResource("dive_dataset")
info["apiRoot"].dive_rpc = RpcResource("dive_rpc")
# Setup route additions for exsting resources
info["apiRoot"].user.route("PUT", (":id", "use_private_queue"), use_private_queue)
User().exposeFields(AccessType.READ, constants.UserPrivateQueueEnabledMarker)
# Expose Job dataset assocation
Job().exposeFields(AccessType.READ, constants.JOBCONST_DATASET_ID)
DIVE_MAIL_TEMPLATES = Path(os.path.realpath(__file__)).parent / 'mail_templates'
mail_utils.addTemplateDirectory(str(DIVE_MAIL_TEMPLATES))
# Relocate Girder
info["serverRoot"], info["serverRoot"].girder = (
ClientWebroot(),
info["serverRoot"],
)
info["serverRoot"].api = info["serverRoot"].girder.api
events.bind(
"filesystem_assetstore_imported",
"process_fs_import",
process_fs_import,
)
events.bind(
"s3_assetstore_imported",
"process_s3_import",
process_s3_import,
)
events.bind(
'model.user.save.created',
'send_new_user_email',
send_new_user_email,
)
# Create dependency on worker
plugin.getPlugin('worker').load(info)
Setting().set(
'worker.api_url',
os.environ.get('WORKER_API_URL', 'http://girder:8080/api/v1'),
)
broker_url = os.environ.get('CELERY_BROKER_URL', None)
if broker_url is None:
raise RuntimeError('CELERY_BROKER_URL must be set')
Setting().set('worker.broker', broker_url)
def load(self, info):
ModelImporter.registerModel('aws', AwsModel, 'cumulus')
ModelImporter.registerModel('cluster', ClusterModel, 'cumulus')
ModelImporter.registerModel('job', JobModel, 'cumulus')
ModelImporter.registerModel('script', ScriptModel, 'cumulus')
ModelImporter.registerModel('volume', VolumeModel, 'cumulus')
info['apiRoot'].clusters = Cluster()
info['apiRoot'].jobs = Job()
info['apiRoot'].scripts = Script()
info['apiRoot'].volumes = Volume()
# Augment user resource with aws profiles
aws.load(info['apiRoot'])
def load(self, info):
# Register models for ModelImporter
ModelImporter.registerModel('calculation', CalculationModel,
'molecules')
ModelImporter.registerModel('cubecache', CubecacheModel, 'molecules')
ModelImporter.registerModel('experimental', ExperimentalModel,
'molecules')
ModelImporter.registerModel('geometry', GeometryModel, 'molecules')
ModelImporter.registerModel('molecule', MoleculeModel, 'molecules')
info['apiRoot'].molecules = Molecule()
info['apiRoot'].calculations = Calculation()
info['apiRoot'].experiments = Experiment()
events.bind('model.setting.validate', 'molecules', validateSettings)
def load(self, info):
ModelImporter.registerModel('aws', AwsModel, 'cumulus')
ModelImporter.registerModel('cluster', ClusterModel, 'cumulus')
ModelImporter.registerModel('job', JobModel, 'cumulus')
ModelImporter.registerModel('script', ScriptModel, 'cumulus')
ModelImporter.registerModel('volume', VolumeModel, 'cumulus')
info['apiRoot'].clusters = Cluster()
info['apiRoot'].jobs = Job()
info['apiRoot'].scripts = Script()
info['apiRoot'].volumes = Volume()
# Add a user route to lookup assetstores by name.
info['apiRoot'].assetstore.route('GET', ('lookup', ), lookupAssetstore)
# Augment user resource with aws profiles
aws.load(info['apiRoot'])
def setUp(self):
base.TestCase.setUp(self)
users = ({
'email': '*****@*****.**',
'login': '******',
'firstName': 'First',
'lastName': 'Last',
'password': '******'
}, {
'email': '*****@*****.**',
'login': '******',
'firstName': 'First',
'lastName': 'Last',
'password': '******'
})
self.admin, self.user = [
self.model('user').createUser(**user) for user in users]
ModelImporter.registerModel('fake_ac', FakeAcModel())
ModelImporter.registerModel('fake', FakeModel())
def setUp(self):
base.TestCase.setUp(self)
users = ({
'email': '*****@*****.**',
'login': '******',
'firstName': 'First',
'lastName': 'Last',
'password': '******'
}, {
'email': '*****@*****.**',
'login': '******',
'firstName': 'First',
'lastName': 'Last',
'password': '******'
})
self.admin, self.user = [
self.model('user').createUser(**user) for user in users
]
ModelImporter.registerModel('fake_ac', FakeAcModel())
ModelImporter.registerModel('fake', FakeModel())
def load(self, info):
getPlugin('gravatar').load(info)
getPlugin('jobs').load(info)
getPlugin('worker').load(info)
getPlugin('thumbnails').load(info)
mail_utils.addTemplateDirectory(os.path.join(_HERE, 'mail_templates'))
ModelImporter.registerModel('challenge', Challenge, 'covalic')
ModelImporter.registerModel('phase', Phase, 'covalic')
ModelImporter.registerModel('submission', Submission, 'covalic')
resource.allowedSearchTypes.add('challenge.covalic')
info['apiRoot'].challenge = ChallengeResource()
info['apiRoot'].challenge_phase = PhaseResource()
info['apiRoot'].covalic_submission = SubmissionResource()
webroot = WebrootBase(os.path.join(_HERE, 'webroot.mako'))
webroot.updateHtmlVars({
'pluginCss': [
plugin for plugin in loadedPlugins()
if os.path.exists(os.path.join(
STATIC_ROOT_DIR, 'built', 'plugins', plugin, 'plugin.min.css'))
],
'pluginJs': [
plugin for plugin in loadedPlugins()
if os.path.exists(os.path.join(
STATIC_ROOT_DIR, 'built', 'plugins', plugin, 'plugin.min.js'))
]
})
registerPluginWebroot(webroot, 'covalic')
events.bind('jobs.job.update', 'covalic', onJobUpdate)
events.bind('model.setting.validate', 'covalic', validateSettings)
events.bind('model.challenge_challenge.save.after', 'covalic',
challengeSaved)
events.bind('model.challenge_phase.save.after', 'covalic',
onPhaseSave)
events.bind('model.user.save.after', 'covalic', onUserSave)
def fakeModel(db):
ModelImporter.registerModel('fake', Fake(), plugin='fake_plugin')
yield Fake
ModelImporter.unregisterModel('fake', plugin='fake_plugin')
def fakeModel(db):
ModelImporter.registerModel('fake', Fake(), plugin='fake_plugin')
yield Fake
ModelImporter.unregisterModel('fake', plugin='fake_plugin')
def load(self, info):
ModelImporter.registerModel('labels', Labels, 'configuration')
info['apiRoot'].configuration = Configuration()
# events.bind('data.process', info['name'], _onUpload)
def load(self, info):
ModelImporter.registerModel('user_module', UserModule, plugin='ums')
info['apiRoot'].user_module = UserModule()
def setUp(self):
base.TestCase.setUp(self)
ModelImporter.registerModel('fake_ac', FakeAcModel())
ModelImporter.registerModel('fake', FakeModel())
def setUp(self):
base.TestCase.setUp(self)
ModelImporter.registerModel('fake_ac', FakeAcModel())
ModelImporter.registerModel('fake', FakeModel())
def load(self, info):
sentry_sdk.init()
getPlugin('large_image').load(info)
oauth = getPlugin('oauth')
if oauth:
oauth.load(info)
isic_discourse_sso = getPlugin('isic_discourse_sso')
if isic_discourse_sso:
# If this plugin is enabled, ensure it loads first, so its API docs are cleared
isic_discourse_sso.load(info)
# set the title of the HTML pages
info['serverRoot'].updateHtmlVars({'title': 'ISIC Archive'})
# register models
ModelImporter.registerModel('annotation', Annotation, 'isic_archive')
ModelImporter.registerModel('batch', Batch, 'isic_archive')
ModelImporter.registerModel('dataset', Dataset, 'isic_archive')
ModelImporter.registerModel('image', Image, 'isic_archive')
ModelImporter.registerModel('segmentation', Segmentation,
'isic_archive')
ModelImporter.registerModel('study', Study, 'isic_archive')
ModelImporter.registerModel('user', User, 'isic_archive')
# add event listeners
events.bind('rest.get.describe/:resource.after',
'isic.onDescribeResource', onDescribeResource)
events.bind('model.user.save.created', 'isic.onUserCreate',
onUserCreate)
# add custom model searching
resource.allowedSearchTypes.update({
'image.isic_archive',
'study.isic_archive',
})
# register license and mail templates
mail_utils.addTemplateDirectory(pkg_resources.resource_filename(
'isic_archive', 'license_templates'),
prepend=True)
mail_utils.addTemplateDirectory(pkg_resources.resource_filename(
'isic_archive', 'mail_templates'),
prepend=True)
# create all necessary users, groups, collections, etc
provisionDatabase()
# add api routes
# remove docs for default Girder API, to simplify page
clearRouteDocs()
# Customize API docs template
baseTemplateFilename = info['apiRoot'].templateFilename
info['apiRoot'].updateHtmlVars(
{'baseTemplateFilename': baseTemplateFilename})
templatePath = pkg_resources.resource_filename('isic_archive',
'isic_api_docs.mako')
info['apiRoot'].setTemplatePath(templatePath)
# TODO: nest these under a "/isic" path?
info['apiRoot'].annotation = api.AnnotationResource()
info['apiRoot'].dataset = api.DatasetResource()
info['apiRoot'].image = api.ImageResource()
info['apiRoot'].redirects = api.RedirectsResource()
info['apiRoot'].segmentation = api.SegmentationResource()
info['apiRoot'].study = api.StudyResource()
info['apiRoot'].task = api.TaskResource()
api.attachUserApi(info['apiRoot'].user)
def load(self, info):
ModelImporter.registerModel('task', TaskModel, 'taskflow')
ModelImporter.registerModel('taskflow', TaskflowModel, 'taskflow')
info['apiRoot'].tasks = Tasks()
info['apiRoot'].taskflows = TaskFlows()
def load(self, info):
plugin.getPlugin('jobs').load(info)
plugin.getPlugin('slicer_cli_web').load(info)
plugin.getPlugin('large_image_annotation').load(info)
# Python's http cookie parser fails for all cookies when there are some
# invalid cookies. Work around some of that.
patchCookieParsing()
ModelImporter.registerModel('aperio', Aperio, 'histomicsui')
ModelImporter.registerModel('case', Case, 'histomicsui')
ModelImporter.registerModel('cohort', Cohort, 'histomicsui')
ModelImporter.registerModel('image', Image, 'histomicsui')
ModelImporter.registerModel('pathology', Pathology, 'histomicsui')
ModelImporter.registerModel('slide', Slide, 'histomicsui')
rest.addEndpoints(info['apiRoot'])
info['serverRoot'].updateHtmlVars(
{'brandName': Setting().get(SettingKey.BRAND_NAME)})
global originalChildItems
if not getattr(Folder, '_childItemsBeforeHUI', None):
Folder._childItemsBeforeHUI = Folder.childItems
Folder.childItems = childItems
girderRoot = info['serverRoot']
huiRoot = WebrootHistomicsUI(_template)
huiRoot.updateHtmlVars(girderRoot.vars)
# The interface is always available under hui and also available
# under the specified path.
info['serverRoot'].hui = huiRoot
webrootPath = Setting().get(PluginSettings.HUI_WEBROOT_PATH)
alternateWebrootPath = Setting().get(
PluginSettings.HUI_ALTERNATE_WEBROOT_PATH)
setattr(info['serverRoot'], webrootPath, huiRoot)
if alternateWebrootPath:
for alt_webroot_path in alternateWebrootPath.split(','):
if alt_webroot_path:
setattr(info['serverRoot'], alt_webroot_path, huiRoot)
info['serverRoot'].girder = girderRoot
# auto-ingest annotations into database when a .anot file is uploaded
events.bind('data.process', 'histomicsui', process_annotations)
events.bind('model.job.save', 'histomicsui', _saveJob)
def updateWebroot(event):
"""
If the webroot path setting is changed, bind the new path to the
hui webroot resource. Note that a change to the alternate webroot
requires a restart.
"""
if event.info.get('key') == PluginSettings.HUI_WEBROOT_PATH:
setattr(info['serverRoot'], event.info['value'], huiRoot)
events.bind('model.setting.save.after', 'histomicsui', updateWebroot)
curConfig = config.getConfig().get('histomicsui', {})
if curConfig.get('restrict_downloads'):
# Change some endpoints to require token access
endpoints = [
('collection', 'GET', (':id', 'download')),
('file', 'GET', (':id', 'download')),
('file', 'GET', (':id', 'download', ':name')),
('folder', 'GET', (':id', 'download')),
('item', 'GET', (':id', 'download')),
('resource', 'GET', ('download', )),
('resource', 'POST', ('download', )),
('item', 'GET', (':itemId', 'tiles', 'images', ':image')),
]
for resource, method, route in endpoints:
cls = getattr(info['apiRoot'], resource)
func = cls.getRouteHandler(method, route)
if func.accessLevel == 'public':
func = access.token(func)
cls.removeRoute(method, route)
cls.route(method, route, func)
def load(self, info):
plugin.getPlugin('histomicsui').load(info)
ModelImporter.registerModel('activity', Activity, 'annotation_tracker')
info['apiRoot'].annotation_tracker = AnnotationTrackerResource()
def load(self, info):
ModelImporter.registerModel('job', Job(), 'jobs')
info['apiRoot'].job = job_rest.Job()
events.bind('jobs.schedule', 'jobs', scheduleLocal)
def load(self, info):
ModelImporter.registerModel('overlay', Overlay, 'overlays')
info['apiRoot'].overlay = OverlayResource()
# initialize model and bind events
Overlay()
def load(self, info):
ModelImporter.registerModel('colormap', Colormap, 'colormaps')
info['apiRoot'].colormap = ColormapResource()
