← Back to branch summary

~ko-de-r-de/zabbix/precise

« back to all changes in this revision

Viewing changes to frontends/php/api/classes/CAction.php

  • Committer: ivo
  • Date: 2013-08-02 13:27:53 UTC
  • Revision ID: svn-v4:f4e7fd02-d210-4e34-a1e0-d4093fb66cc2:trunk:37534
A.F....... [ZBX-6808] fixed "Host metadata" field in actions; improved validation for action conditions; improved functions to get list of discovery objects and trigger values; minor coding style fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
frontends/php/api/classes/CAction.php
533
533
                $duplicates = array();
534
534
                foreach ($actions as $action) {
535
535
                        if (!check_db_fields($actionDbFields, $action)) {
536
 
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Incorrect parameter for action "%s".', $action['name']));
 
536
                                self::exception(ZBX_API_ERROR_PARAMETERS,
 
537
                                        _s('Incorrect parameter for action "%1$s".', $action['name']));
537
538
                        }
538
539
                        if (isset($action['esc_period']) && $action['esc_period'] < SEC_PER_MIN && $action['eventsource'] == EVENT_SOURCE_TRIGGERS) {
539
540
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%1$s" has incorrect value for "esc_period" (minimum %2$s seconds).', $action['name'], SEC_PER_MIN));
540
541
                        }
541
542
                        if (isset($duplicates[$action['name']])) {
542
 
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%s" already exists.', $action['name']));
 
543
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%1$s" already exists.', $action['name']));
543
544
                        }
544
545
                        else {
545
546
                                $duplicates[$action['name']] = $action['name'];
553
554
                        'nopermissions' => true
554
555
                ));
555
556
                foreach ($dbActions as $dbAction) {
556
 
                        self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%s" already exists.', $dbAction['name']));
 
557
                        self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%1$s" already exists.', $dbAction['name']));
557
558
                }
558
559
 
559
560
                $actionids = DB::insert('actions', $actions);
560
561
 
561
562
                $conditions = $operations = array();
562
563
                foreach ($actions as $anum => $action) {
563
 
                        if (isset($action['conditions']) && !empty($action['conditions'])) {
 
564
                        // conditions are optional, but when set, its fields must be validated
 
565
                        if (isset($action['conditions'])) {
 
566
                                if (!is_array($action['conditions'])) {
 
567
                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
568
                                                _s('Incorrect action conditions for action "%1$s".', $action['name']));
 
569
                                }
 
570
 
564
571
                                foreach ($action['conditions'] as $condition) {
 
572
                                        if (!isset($condition['conditiontype'])) {
 
573
                                                self::exception(ZBX_API_ERROR_PARAMETERS,
 
574
                                                        _s('Missing "%1$s" field for action condition.', 'conditiontype'));
 
575
                                        }
 
576
 
 
577
                                        $condition['operator'] = isset($condition['operator'])
 
578
                                                ? $condition['operator']
 
579
                                                : CONDITION_OPERATOR_EQUAL;
 
580
 
565
581
                                        $condition['actionid'] = $actionids[$anum];
566
582
                                        $conditions[] = $condition;
567
583
                                }
568
584
                        }
569
585
 
570
586
                        if (!isset($action['operations']) || empty($action['operations'])) {
571
 
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Incorrect parameter for action "%s".', $action['name']));
 
587
                                self::exception(ZBX_API_ERROR_PARAMETERS,
 
588
                                        _s('Incorrect parameter for action "%1$s".', $action['name']));
572
589
                        }
573
590
                        else {
574
591
                                foreach ($action['operations'] as $operation) {
614
631
                        'selectOperations' => API_OUTPUT_EXTEND,
615
632
                        'selectConditions' => API_OUTPUT_EXTEND
616
633
                ));
617
 
                        foreach ($actions as $action) {
 
634
 
 
635
                foreach ($actions as $action) {
618
636
                        if (isset($action['actionid']) && !isset($updActions[$action['actionid']])) {
619
 
                                self::exception(ZBX_API_ERROR_PERMISSIONS, _('No permissions to referred object or it does not exist!'));
 
637
                                self::exception(ZBX_API_ERROR_PERMISSIONS,
 
638
                                        _('No permissions to referred object or it does not exist!'));
620
639
                        }
621
640
                }
622
641
 
660
679
                                        'nopermissions' => true,
661
680
                                        'preservekeys' => true
662
681
                                ));
663
 
                                if (($actionExist = reset($actionExists)) && (bccomp($actionExist['actionid'], $action['actionid']) != 0)) {
664
 
                                        self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%s" already exists.', $action['name']));
 
682
                                if (($actionExist = reset($actionExists))
 
683
                                                && (bccomp($actionExist['actionid'], $action['actionid']) != 0)) {
 
684
                                        self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%1$s" already exists.', $action['name']));
665
685
                                }
666
686
                        }
667
687
 
668
688
                        if (isset($action['conditions'])) {
669
 
                                $conditionsDb = isset($updActions[$action['actionid']]['conditions']) ? $updActions[$action['actionid']]['conditions'] : array();
 
689
                                if (!is_array($action['conditions'])) {
 
690
                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
691
                                                _s('Incorrect action conditions for action "%1$s".', $updActions[$action['actionid']]['name']));
 
692
                                }
 
693
 
 
694
                                $conditionsDb = isset($updActions[$action['actionid']]['conditions'])
 
695
                                        ? $updActions[$action['actionid']]['conditions']
 
696
                                        : array();
670
697
                                $conditionsDb = zbx_toHash($conditionsDb, 'conditionid');
671
 
                                self::validateConditions($action['conditions']);
672
698
 
673
699
                                foreach ($action['conditions'] as $condition) {
674
700
                                        $condition['actionid'] = $action['actionid'];
677
703
                                                $conditionsCreate[] = $condition;
678
704
                                        }
679
705
                                        elseif (isset($conditionsDb[$condition['conditionid']])) {
 
706
                                                // value and operator validation depends on condition type
 
707
                                                $defaultFields = array('conditiontype', 'operator', 'value');
 
708
                                                foreach ($defaultFields as $field) {
 
709
                                                        $condition[$field] = isset($condition[$field])
 
710
                                                                ? $condition[$field]
 
711
                                                                : $conditionsDb[$condition['conditionid']][$field];
 
712
                                                }
 
713
 
680
714
                                                $conditionsUpdate[] = $condition;
681
715
                                                unset($conditionsDb[$condition['conditionid']]);
682
716
                                        }
689
723
                        }
690
724
 
691
725
                        if (isset($action['operations']) && empty($action['operations'])) {
692
 
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%s" no operations defined.', $action['name']));
 
726
                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Action "%1$s" no operations defined.', $action['name']));
693
727
                        }
694
728
                        elseif (isset($action['operations'])) {
695
729
                                $this->validateOperations($action['operations']);
725
759
 
726
760
                DB::update('actions', $update);
727
761
 
 
762
                self::validateConditions($conditionsCreate);
728
763
                $this->addConditions($conditionsCreate);
 
764
 
 
765
                self::validateConditions($conditionsUpdate, true);
729
766
                $this->updateConditions($conditionsUpdate);
 
767
 
730
768
                if (!empty($conditionidsDelete)) {
731
769
                        $this->deleteConditions($conditionidsDelete);
732
770
                }
1405
1443
         *
1406
1444
         * @return bool
1407
1445
         */
1408
 
        public static function validateConditions($conditions) {
 
1446
        public static function validateConditions($conditions, $update = false) {
1409
1447
                $conditions = zbx_toArray($conditions);
1410
1448
 
1411
1449
                $hostGroupIdsAll = array();
1416
1454
                $proxyIdsAll = array();
1417
1455
                $proxyidsAll = array();
1418
1456
 
1419
 
                $discoveryCheckTypes = discovery_check_type2str();
1420
 
                $discoveryObjectStatuses = discovery_object_status2str();
 
1457
                // build validators
1421
1458
                $timePeriodValidator = new CTimePeriodValidator();
 
1459
                $discoveryCheckTypeValidator = new CSetValidator(array(
 
1460
                        'values' => array_keys(discovery_check_type2str())
 
1461
                ));
 
1462
                $discoveryObjectStatusValidator = new CSetValidator(array(
 
1463
                        'values' => array_keys(discovery_object_status2str())
 
1464
                ));
 
1465
                $triggerSeverityValidator = new CSetValidator(array(
 
1466
                        'values' => array_keys(getSeverityCaption())
 
1467
                ));
 
1468
                $discoveryObjectValidator = new CSetValidator(array(
 
1469
                        'values' => array_keys(discovery_object2str())
 
1470
                ));
 
1471
                $triggerValueValidator = new CSetValidator(array(
 
1472
                        'values' => array_keys(trigger_value2str())
 
1473
                ));
 
1474
                $eventTypeValidator = new CSetValidator(array(
 
1475
                        'values' => array_keys(eventType())
 
1476
                ));
1422
1477
 
1423
1478
                foreach ($conditions as $condition) {
1424
 
                        switch ($condition['conditiontype']) {
1425
 
                                case CONDITION_TYPE_HOST_GROUP:
1426
 
                                        $hostGroupIdsAll[$condition['value']] = $condition['value'];
1427
 
                                        break;
1428
 
 
1429
 
                                case CONDITION_TYPE_TEMPLATE:
1430
 
                                        $templateIdsAll[$condition['value']] = $condition['value'];
1431
 
                                        break;
1432
 
 
1433
 
                                case CONDITION_TYPE_TRIGGER:
1434
 
                                        $triggerIdsAll[$condition['value']] = $condition['value'];
1435
 
                                        break;
1436
 
 
1437
 
                                case CONDITION_TYPE_HOST:
1438
 
                                        $hostIdsAll[$condition['value']] = $condition['value'];
1439
 
                                        break;
1440
 
 
1441
 
                                case CONDITION_TYPE_DRULE:
1442
 
                                        $discoveryRuleIdsAll[$condition['value']] = $condition['value'];
1443
 
                                        break;
1444
 
 
1445
 
                                case CONDITION_TYPE_DCHECK:
1446
 
                                        $proxyIdsAll[$condition['value']] = $condition['value'];
1447
 
                                        break;
1448
 
 
1449
 
                                case CONDITION_TYPE_PROXY:
1450
 
                                        $proxyidsAll[$condition['value']] = $condition['value'];
1451
 
                                        break;
1452
 
 
1453
 
                                case CONDITION_TYPE_TIME_PERIOD:
1454
 
                                        if (!$timePeriodValidator->validate($condition['value'])) {
1455
 
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Incorrect action condition period "%s".', $condition['value']));
1456
 
                                        }
1457
 
                                        break;
1458
 
 
1459
 
                                case CONDITION_TYPE_DHOST_IP:
1460
 
                                        if (!validate_ip_range($condition['value'])) {
1461
 
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Incorrect action condition ip "%s".', $condition['value']));
1462
 
                                        }
1463
 
                                        break;
1464
 
 
1465
 
                                case CONDITION_TYPE_DSERVICE_TYPE:
1466
 
                                        if (!isset($discoveryCheckTypes[$condition['value']])) {
1467
 
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition discovery check.'));
1468
 
                                        }
1469
 
                                        break;
1470
 
 
1471
 
                                case CONDITION_TYPE_DSERVICE_PORT:
1472
 
                                        if (!validate_port_list($condition['value'])) {
1473
 
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _s('Incorrect action condition port "%s".', $condition['value']));
1474
 
                                        }
1475
 
                                        break;
1476
 
 
1477
 
                                case CONDITION_TYPE_DSTATUS:
1478
 
                                        if (!isset($discoveryObjectStatuses[$condition['value']])) {
1479
 
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition discovery status.'));
1480
 
                                        }
1481
 
                                        break;
1482
 
 
1483
 
                                case CONDITION_TYPE_MAINTENANCE:
1484
 
                                        // maintenance condition has no value...
1485
 
                                        break;
1486
 
 
1487
 
                                case CONDITION_TYPE_TRIGGER_NAME:
1488
 
                                case CONDITION_TYPE_TRIGGER_VALUE:
1489
 
                                case CONDITION_TYPE_TRIGGER_SEVERITY:
1490
 
                                case CONDITION_TYPE_NODE:
1491
 
                                case CONDITION_TYPE_DOBJECT:
1492
 
                                case CONDITION_TYPE_DUPTIME:
1493
 
                                case CONDITION_TYPE_DVALUE:
1494
 
                                case CONDITION_TYPE_APPLICATION:
1495
 
                                case CONDITION_TYPE_HOST_NAME:
1496
 
                                case CONDITION_TYPE_HOST_METADATA:
1497
 
                                case CONDITION_TYPE_EVENT_TYPE:
1498
 
                                        if (zbx_empty($condition['value'])) {
1499
 
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
1500
 
                                        }
1501
 
                                        break;
1502
 
 
1503
 
                                default:
1504
 
                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition type.'));
1505
 
                                        break;
 
1479
                        // on create operator is mandatory and needs validation, but on update it must be validated only if it's set
 
1480
                        if (!$update || ($update && isset($condition['operator']))) {
 
1481
                                $operatorValidator = new CSetValidator(array(
 
1482
                                        'values' => get_operators_by_conditiontype($condition['conditiontype'])
 
1483
                                ));
 
1484
                                if (!$operatorValidator->validate($condition['operator'])) {
 
1485
                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition operator.'));
 
1486
                                }
 
1487
                        }
 
1488
 
 
1489
                        if (!$update || ($update && isset($condition['value']))) {
 
1490
                                // validate condition values depending on condition type
 
1491
                                switch ($condition['conditiontype']) {
 
1492
                                        case CONDITION_TYPE_HOST_GROUP:
 
1493
                                                if (!$condition['value']) {
 
1494
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1495
                                                }
 
1496
                                                $hostGroupIdsAll[$condition['value']] = $condition['value'];
 
1497
                                                break;
 
1498
 
 
1499
                                        case CONDITION_TYPE_TEMPLATE:
 
1500
                                                if (!$condition['value']) {
 
1501
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1502
                                                }
 
1503
                                                $templateIdsAll[$condition['value']] = $condition['value'];
 
1504
                                                break;
 
1505
 
 
1506
                                        case CONDITION_TYPE_TRIGGER:
 
1507
                                                if (!$condition['value']) {
 
1508
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1509
                                                }
 
1510
                                                $triggerIdsAll[$condition['value']] = $condition['value'];
 
1511
                                                break;
 
1512
 
 
1513
                                        case CONDITION_TYPE_HOST:
 
1514
                                                if (!$condition['value']) {
 
1515
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1516
                                                }
 
1517
                                                $hostIdsAll[$condition['value']] = $condition['value'];
 
1518
                                                break;
 
1519
 
 
1520
                                        case CONDITION_TYPE_DRULE:
 
1521
                                                if (!$condition['value']) {
 
1522
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1523
                                                }
 
1524
                                                $discoveryRuleIdsAll[$condition['value']] = $condition['value'];
 
1525
                                                break;
 
1526
 
 
1527
                                        case CONDITION_TYPE_DCHECK:
 
1528
                                                if (!$condition['value']) {
 
1529
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1530
                                                }
 
1531
                                                $proxyIdsAll[$condition['value']] = $condition['value'];
 
1532
                                                break;
 
1533
 
 
1534
                                        case CONDITION_TYPE_PROXY:
 
1535
                                                if (!$condition['value']) {
 
1536
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1537
                                                }
 
1538
                                                $proxyidsAll[$condition['value']] = $condition['value'];
 
1539
                                                break;
 
1540
 
 
1541
                                        case CONDITION_TYPE_DOBJECT:
 
1542
                                                if (zbx_empty($condition['value'])) {
 
1543
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1544
                                                }
 
1545
                                                elseif (!$discoveryObjectValidator->validate($condition['value'])) {
 
1546
                                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
1547
                                                                _('Incorrect action condition discovery object.'));
 
1548
                                                }
 
1549
                                                break;
 
1550
 
 
1551
                                        case CONDITION_TYPE_TIME_PERIOD:
 
1552
                                                if (!$timePeriodValidator->validate($condition['value'])) {
 
1553
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, $timePeriodValidator->getError());
 
1554
                                                }
 
1555
                                                break;
 
1556
 
 
1557
                                        case CONDITION_TYPE_DHOST_IP:
 
1558
                                                if (zbx_empty($condition['value'])) {
 
1559
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1560
                                                }
 
1561
                                                else if (!validate_ip_range($condition['value'])) {
 
1562
                                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
1563
                                                                _s('Incorrect action condition ip "%1$s".', $condition['value']));
 
1564
                                                }
 
1565
                                                break;
 
1566
 
 
1567
                                        case CONDITION_TYPE_DSERVICE_TYPE:
 
1568
                                                if (zbx_empty($condition['value'])) {
 
1569
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1570
                                                }
 
1571
                                                elseif (!$discoveryCheckTypeValidator->validate($condition['value'])) {
 
1572
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition discovery check.'));
 
1573
                                                }
 
1574
                                                break;
 
1575
 
 
1576
                                        case CONDITION_TYPE_DSERVICE_PORT:
 
1577
                                                if (zbx_empty($condition['value'])) {
 
1578
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1579
                                                }
 
1580
                                                elseif (!validate_port_list($condition['value'])) {
 
1581
                                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
1582
                                                                _s('Incorrect action condition port "%1$s".', $condition['value']));
 
1583
                                                }
 
1584
                                                break;
 
1585
 
 
1586
                                        case CONDITION_TYPE_DSTATUS:
 
1587
                                                if (zbx_empty($condition['value'])) {
 
1588
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1589
                                                }
 
1590
                                                elseif (!$discoveryObjectStatusValidator->validate($condition['value'])) {
 
1591
                                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
1592
                                                                _('Incorrect action condition discovery status.'));
 
1593
                                                }
 
1594
                                                break;
 
1595
 
 
1596
                                        case CONDITION_TYPE_MAINTENANCE:
 
1597
                                                if (!zbx_empty($condition['value'])) {
 
1598
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Maintenance action condition value must be empty.'));
 
1599
                                                }
 
1600
                                                break;
 
1601
 
 
1602
                                        case CONDITION_TYPE_TRIGGER_SEVERITY:
 
1603
                                                if (zbx_empty($condition['value'])) {
 
1604
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1605
                                                }
 
1606
                                                elseif (!$triggerSeverityValidator->validate($condition['value'])) {
 
1607
                                                        self::exception(ZBX_API_ERROR_PARAMETERS,
 
1608
                                                                _('Incorrect action condition trigger severity.'));
 
1609
                                                }
 
1610
                                                break;
 
1611
 
 
1612
                                        case CONDITION_TYPE_TRIGGER_VALUE:
 
1613
                                                if (zbx_empty($condition['value'])) {
 
1614
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1615
                                                }
 
1616
                                                elseif (!$triggerValueValidator->validate($condition['value'])) {
 
1617
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition trigger value.'));
 
1618
                                                }
 
1619
                                                break;
 
1620
 
 
1621
                                        case CONDITION_TYPE_EVENT_TYPE:
 
1622
                                                if (zbx_empty($condition['value'])) {
 
1623
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1624
                                                }
 
1625
                                                elseif (!$eventTypeValidator->validate($condition['value'])) {
 
1626
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition event type.'));
 
1627
                                                }
 
1628
                                        break;
 
1629
 
 
1630
                                        case CONDITION_TYPE_TRIGGER_NAME:
 
1631
                                        case CONDITION_TYPE_NODE:
 
1632
                                        case CONDITION_TYPE_DUPTIME:
 
1633
                                        case CONDITION_TYPE_DVALUE:
 
1634
                                        case CONDITION_TYPE_APPLICATION:
 
1635
                                        case CONDITION_TYPE_HOST_NAME:
 
1636
                                        case CONDITION_TYPE_HOST_METADATA:
 
1637
                                                if (zbx_empty($condition['value'])) {
 
1638
                                                        self::exception(ZBX_API_ERROR_PARAMETERS, _('Empty action condition.'));
 
1639
                                                }
 
1640
                                                break;
 
1641
 
 
1642
                                        default:
 
1643
                                                self::exception(ZBX_API_ERROR_PARAMETERS, _('Incorrect action condition type.'));
 
1644
                                                break;
 
1645
                                }
1506
1646
                        }
1507
1647
                }
1508
1648