Exemplo n.º 1
0
    def test_transaction(self):
        @transaction(Core.logger, Contexts.em)
        def test_commit():
            self.em._session_.add(RepositoryORM(None, 'test', '127.0.0.1'))

        wrapper = ResultWrapper()
        wrapper2 = ResultWrapper()
        wrapper.EXPECTED_RESPONSE = 'Commit'
        wrapper2.EXPECTED_RESPONSE = 'Close session'
        when(self.em._session_).commit().thenAnswer(wrapper.exec)
        when(self.em._session_).close().thenAnswer(wrapper2.exec)
        test_commit()
        self.assertEqual(wrapper.RESPONSE, wrapper.EXPECTED_RESPONSE)
        self.assertEqual(wrapper2.RESPONSE, wrapper2.EXPECTED_RESPONSE)
        unstub(self.em._session_)

        @transaction(Core.logger, Contexts.em)
        def test_rollback():
            raise Exception('Rollback')

        wrapper = ResultWrapper()
        wrapper.EXPECTED_RESPONSE = 'Rollback'
        when(self.em._session_).rollback().thenAnswer(wrapper.exec)
        when(Core.logger()).warning(...).thenReturn(None)
        with self.assertRaises(Exception):
            test_rollback()
        self.assertEqual(wrapper.RESPONSE, wrapper.EXPECTED_RESPONSE)
        unstub(self.em._session_)
        unstub(Core.logger())
Exemplo n.º 2
0
    def __init__(self, configfile):
        if not os.path.exists(configfile):
            raise IOError('No such configuration file: %s' % configfile)
        self.configparser.read(configfile)
        check_configuration_keys(self.expected_keys, self.configparser)

        logging_config = self.configparser.get('logging', 'configuration')
        if not os.path.exists(logging_config):
            raise IOError('No such configuration file: %s' % logging_config)
        setup_logging(logging_config)

        database_dsn = self.configparser.get('database', 'dsn')
        broker_dsn = self.configparser.get('broker', 'dsn')
        storage_uri = '%(proto)s://%(uri)s' % (
            {
                'proto': self.configparser.get('storage', 'proto'),
                'uri': self.configparser.get('storage', 'uri')
            })

        component_token = self.configparser.get('application', 'cpnttoken')
        data = {
            'broker': {
                'dsn': broker_dsn
            },
            'database': {
                'dsn': database_dsn
            },
            'app': {
                'storage_uri': storage_uri
            },
            'tokens': {
                'component': component_token
            }
        }
        set_configuration(data)
        celery_app = Factories.celery_factory()
        celery_app.config_from_object(celery_config())
        celery_app.conf.task_routes = ROUTES

        Core.logger.override(providers.Singleton(logging.getLogger, 'bpm'))
        Core.profiler.override(
            providers.Singleton(logging.getLogger, 'bpm_profiling'))

        self.loglevel = (logging.getLevelName(
            logging.getLogger().getEffectiveLevel()) or logging.WARN)

        profiling = (
            self.configparser.getboolean('application', 'profiling') if
            (self.configparser.has_section('application')
             and self.configparser.has_option('application', 'profiling')) else
            False)

        if profiling:
            Core.logger().info('Running with profiling active')
            setup_task_profiling()
Exemplo n.º 3
0
def process_image(self, uid, metadata):
    """
    Image processing that generates kpis, overlay & image.

    Keywords:
    uid -- Image uid
    image_metadata -- Computation request payload sent w/o pixelmap
    """
    logger = Core.logger()
    logger.info('Running image processing for image uid %(uid)s' % (
        {'uid': uid}
    ))
    try:
        metrics, processed_image = wrapped_process_image(uid, metadata)
        if processed_image:
            req = StorageClient.post_metrics_image(
                {'Content-Type': 'application/json'},
                json.dumps({'metrics_uid': metrics.uid,
                            'image': list(processed_image)})
            )
            if req.status_code != 200:
                raise ValueError('Could not persist processed image')
        logger.info('Image %(uid)s has been processed' % ({'uid': uid}))
    except Exception as e:
        logger.exception(e)
        self.retry(exc=e)
Exemplo n.º 4
0
 def test_match_procedure_images(self):
     (issuer, repository, exam, exam_status, procedure, procedure_status,
      modality_type, sop_class, image_metadata, image, image_status,
      image_metrics,
      image_metrics_display) = self.create_processed_image_stack()
     wf = Services.workflow()
     wrapper = ResultWrapper()
     wrapper.EXPECTED_RESPONSE = 'Retry called'
     # Prevents logger to log exception as expected in unittests
     when(Core.logger()).exception(...).thenReturn(None)
     when(Core.logger()).warning(...).thenReturn(None)
     when(wf).match_procedure(...).thenRaise(Exception())
     (when(matching.match_procedure_images).retry(...).thenAnswer(
         wrapper.exec))
     matching.match_procedure_images(procedure.uid)
     self.assertEqual(wrapper.RESPONSE, wrapper.EXPECTED_RESPONSE)
     unstub()
Exemplo n.º 5
0
    def test_process_image(self):
        when(Core.logger()).warning(...).thenReturn(None)
        (issuer, repository, exam, exam_status, procedure, procedure_status,
         modality_type, sop_class, image_metadata, image,
         image_status) = self.create_image_stack()

        bytes_json = SimpleImageModel(bytes=[])
        bytes_ = mock({
            'status_code': 200,
            'text': json.dumps(bytes_json)
        },
                      spec=requests.Response)
        when(bytes_).json().thenReturn(bytes_json)
        status = StatusModel(message='success')
        metrics_resp = mock({
            'status_code': 200,
            'text': json.dumps(status)
        },
                            spec=requests.Response)
        when(metrics_resp).json().thenReturn(status)
        when(StorageClient).get_image(...).thenReturn(bytes_)
        when(StorageClient).post_metrics_image(...).thenReturn(metrics_resp)

        (when(BPMBusiness).process_image(...).thenReturn(({}, {}, None)))
        processing.process_image(image.uid, COMPUTATION_REQUEST)
        image_status = self.em.get_image_status('image_uid', image.uid)
        self.assertEqual(image_status.status, ImageStatusEnum.Processed.value)
        unstub(when(BPMBusiness).process_image(...))

        error = mock({
            'status_code': 500,
            'text': 'Failed'
        },
                     spec=requests.Response)
        wrapper = ResultWrapper()
        wrapper.EXPECTED_RESPONSE = {'retry': 'ok'}
        # Prevents logger to log exception as expected in unittests
        when(Core.logger()).exception(...).thenReturn(None)
        when(error).json().thenReturn({'status': 'Failed'})
        when(StorageClient).post_metrics_image(...).thenReturn(error)
        when(processing.process_image).retry(...).thenAnswer(wrapper.exec)

        res = processing.process_image(image.uid, COMPUTATION_REQUEST)
        self.assertEqual(wrapper.RESPONSE, wrapper.EXPECTED_RESPONSE)
        unstub()
Exemplo n.º 6
0
def identity_and_match_processed_procedures():
    broker = Factories.celery_factory()
    wf = Services.workflow()
    logger = Core.logger()
    procedures = wf.update_processed_procedures()
    for proc in procedures:
        logger.info('Processed procedure %(uid)s has been sent to matching' %
                    ({
                        'uid': proc
                    }))
        produce_matching_task(broker, proc)
Exemplo n.º 7
0
 def func_wrapper(*args, **kwargs):
     logger = Core.profiler()
     start = time()
     result = func(*args, **kwargs)
     end = time()
     data = {}
     data['timestamp'] = ge_format_time(datetime.now())
     data['func'] = fname
     data['duration_seconds'] = float('%0.4f' % (end - start))
     logger.info(json.dumps(data))
     return result
Exemplo n.º 8
0
def match_procedure_images(self, procedure_uid):
    """
    Matches up to two sets of two images for a procedure.

    Keyword arguments:
    procedure_uid -- Int, Procedure  UID
    images_metadata -- List of tuple which contains for each image uid the
    image_laterality, view_position, acquisition_time and overlay_data
    """
    logger = Core.logger()
    logger.info('Running matching for procedure %(uid)s' %
                ({
                    'uid': procedure_uid
                }))
    try:
        wrapped_match_procedure_images(procedure_uid)
        logger.info('Procedure %(uid)s has been matched' %
                    ({
                        'uid': procedure_uid
                    }))
    except Exception as e:
        logger.exception(e)
        self.retry(exc=e)
Exemplo n.º 9
0
 def tearDown(self):
     super(TasksTestCase, self).tearDown()
     unstub(when(Core.logger()).warning(...))
Exemplo n.º 10
0
 def setUp(self):
     when(Core.logger()).warning(...).thenReturn(None)
     super(TasksTestCase, self).setUp()
Exemplo n.º 11
0
    def __init__(self, configfile):
        if not os.path.exists(configfile):
            raise IOError('No such configuration file: %s' % configfile)
        self.configparser.read(configfile)
        check_configuration_keys(self.expected_keys, self.configparser)

        logging_config = self.configparser.get('logging', 'configuration')
        if not os.path.exists(logging_config):
            raise IOError('No such configuration file: %s' % logging_config)
        setup_logging(logging_config)

        database_dsn = self.configparser.get('database', 'dsn')
        host = self.configparser.get('application', 'host') if (
            self.configparser.has_section('application') and
            self.configparser.has_option('application', 'host')) \
            else '0.0.0.0'
        port = int(self.configparser.get('application', 'port')) if (
            self.configparser.has_section('application') and
            self.configparser.has_option('application', 'port')) \
            else 8080
        storage_uri = '%(proto)s://%(uri)s' % ({
            'proto': self.configparser.get('storage', 'proto') if (
                self.configparser.has_section('storage') and
                self.configparser.has_option('storage', 'proto')) else 'http',
            'uri': self.configparser.get('storage', 'uri') if (
                self.configparser.has_section('storage') and
                self.configparser.has_option('storage', 'uri')) else (
                    'localhost:9080')
        })
        role_token = self.configparser.get('application', 'roletoken')
        component_token = self.configparser.get('application', 'cpnttoken')

        data = {
            'database': {'dsn': database_dsn},
            'app': {'identifier': self.identifier,
                    'title': self.title,
                    'host': host,
                    'port': port,
                    'storage_uri': storage_uri},
            'tokens': {'role': role_token,
                       'component': component_token},
            'webdav': {'options': {}, 'client_options': {}},
            'swagger': {'security_definitions': self.security_defs},
        }
        set_configuration(data)
        self.build_webdav_opts()

        Core.logger.override(providers.Singleton(
            logging.getLogger, 'bpm'))
        Core.profiler.override(providers.Singleton(
            logging.getLogger, 'bpm_profiling'))

        profiling = (self.configparser.getboolean('application', 'profiling')
                     if (
            self.configparser.has_section('application') and
            self.configparser.has_option('application', 'profiling'))
            else False)

        ignite = (self.configparser.getboolean('application', 'ignite') if (
            self.configparser.has_section('application') and
            self.configparser.has_option('application', 'ignite'))
            else False)

        if profiling:
            Core.logger().info('Running with profiling active')
            setup_resource_profiling()

        if ignite:
            Core.logger().info('Igniting application')
            metadata.create_all(Gateways.session().bind)
Exemplo n.º 12
0
 def setUp(self):
     when(Core.logger()).warning(...).thenReturn(None)
     super(WorkflowTestCase, self).setUp()
     self.wf = Services.workflow()
Exemplo n.º 13
0
 def _logger_(self):
     return Core.logger()