Exemplo n.º 1
0
    def test_raise(self):
        with self.assertRaises(KeyError):
            with catch(IndexError):
                dict()["nothing"]

        with self.assertRaises(IndexError):
            with catch(KeyError, reraise=IndexError):
                dict()["nothing"]

        with self.assertRaises(ValueError):
            with catch((ZeroDivisionError, IndexError), reraise=ValueError):
                1 / 0

        with self.assertRaises(ValueError):
            with catch((ZeroDivisionError, IndexError), reraise=ValueError):
                list()[1]

        with self.assertRaises(ValueError):
            try:
                valerr = ValueError()
                with catch(ZeroDivisionError, reraise=valerr):
                    1 / 0

            except ValueError as err:
                self.assertIs(err, valerr)
                raise
Exemplo n.º 2
0
    def test_callback(self):
        results = []

        with catch((ZeroDivisionError, IndexError), callback=results.append):
            1 / 0
        self.assertIsInstance(results.pop(), ZeroDivisionError)

        with catch((ZeroDivisionError, IndexError), callback=results.append):
            list()[1]
        self.assertIsInstance(results.pop(), IndexError)
Exemplo n.º 3
0
    def test_catch_errors(self):
        with catch():
            raise Exception()

        with catch(ZeroDivisionError):
            1 / 0

        with catch((KeyError, IndexError)):
            list()[1]
            dict()["nothing"]
Exemplo n.º 4
0
    def test_exec_info(self):
        with catch() as exec_info:
            self.assertTrue(exec_info["ok"])
            self.assertIsNone(exec_info["exception"])
            self.assertIsNone(exec_info["callback_returned"])

        self.assertTrue(exec_info["ok"])
        self.assertIsNone(exec_info["exception"])
        self.assertIsNone(exec_info["callback_returned"])

        callback = mock.MagicMock(return_value=1)
        with catch(NotImplementedError, callback=callback) as exec_info:
            raise NotImplementedError

        self.assertFalse(exec_info["ok"])
        self.assertIsInstance(exec_info["exception"], NotImplementedError)
        self.assertEqual(exec_info["callback_returned"], callback.return_value)
Exemplo n.º 5
0
def cd(path):
    """
    Switch to a directory to excute.

    :param path: directory string
    """
    current_dir = os.getcwd()
    os.chdir(path)
    try:
        yield
    finally:
        with contextutils.catch():
            os.chdir(current_dir)
Exemplo n.º 6
0
 def fix_value(self):
     with catch(reraise=ModelFieldError):
         type = ITEM_TYPE[self.type]
         self.value = type.factory(self.value)
Exemplo n.º 7
0
 def __getattr__(self, name):
     with catch(KeyError, reraise=AttributeError):
         return self[name]
Exemplo n.º 8
0
 def foo(*args, **kwargs):
     with contextutils.catch(
         getattr(exceptions, "WindowsError", OSError),
         reraise=OSError,
     ):
         return func(*args, **kwargs)
Exemplo n.º 9
0
    def post(self, request):
        logger.info("New request for item collector")
        try:
            self.PostValidator.validate(request.data)
        except ValidationError as err:
            return Response({
                "ok": False,
                "detail": err.message,
            }, status=status.HTTP_400_BAD_REQUEST)

        auth_key = request.data.get("auth")
        try:
            user = auth_utils.authenticate_from_key(auth_key)
        except auth_utils.exceptions.AuthenticationFailed as err:
            return Response({
                "ok": False,
                "detail": err.detail,
            }, status=status.HTTP_401_UNAUTHORIZED)

        project_name = request.data.get("project")
        try:
            project = project_models.Project.objects.get(
                name=project_name,
                group__in=user.groups.all(),
                status=project_models.PROJECT_STATUS.enable,
            )
        except project_models.Project.DoesNotExist as err:
            return Response({
                "ok": False,
                "detail": "enabled project(%s) not found" % project_name,
            }, status=status.HTTP_404_NOT_FOUND)

        item_name = request.data.get("item")
        try:
            item = item_models.MonitorItem.objects.get(
                name=item_name, project=project,
                status=item_models.ITEM_STATUS.enable,
            )
        except item_models.MonitorItem.DoesNotExist as err:
            return Response({
                "ok": False,
                "detail": "enabled item(%s) not found" % item_name,
            }, status=status.HTTP_404_NOT_FOUND)

        try:
            with transaction.atomic():
                self.update_item(item, request.data.get("value"))
                self.insert_item_history(item, user)
        except exceptions.ModelFieldError as err:
            return Response({
                "ok": False,
                "detail": "value(%s) of item(%s) save failed" % (
                    request.data.get("value"), item_name,
                ),
            }, status=status.HTTP_406_NOT_ACCEPTABLE)

        logger.info("Item[%s] has updated", item_name)
        try:
            return Response({
                "ok": True,
                "detail": {
                    "project": project.id,
                    "item": item.id,
                    "value": item.value,
                },
            }, status=status.HTTP_202_ACCEPTED)
        finally:
            with catch():
                TasksPool.apply_async(self.check_triggers, [item])