Exemplo n.º 1
0
 public static function createSampleDowntime($severity = 'OUTAGE', $classification = 'SCHEDULED')
 {
     $downtime = new Downtime();
     $downtime->setDescription("A sample skeleton downtime");
     $downtime->setSeverity($severity);
     $downtime->setClassification($classification);
     return $downtime;
 }
Exemplo n.º 2
0
function newDowntime($downtimeXml)
{
    $downtime = new Downtime();
    foreach ($downtimeXml->attributes() as $key => $value) {
        switch ($key) {
            case "ID":
                $promId = (int) $value;
                break;
            case "PRIMARY_KEY":
                $primaryKey = (string) $value;
                break;
            case "CLASSIFICATION":
                $classification = (string) $value;
                break;
        }
    }
    // Get the largest v4 downtime PK which is an integer appended by the string 'G0'
    // slice off the 'G0' and get the integer value.
    $v4pk = (int) substr($primaryKey, 0, strlen($primaryKey) - 2);
    if ($v4pk > $GLOBALS['largestV4DowntimePK']) {
        $GLOBALS['largestV4DowntimePK'] = $v4pk;
    }
    $downtime->setClassification($classification);
    $downtime->setDescription((string) $downtimeXml->DESCRIPTION);
    $downtime->setSeverity((string) $downtimeXml->SEVERITY);
    $startDate = new DateTime("@" . (string) $downtimeXml->START_DATE);
    $downtime->setStartDate($startDate);
    $endDate = new DateTime("@" . (string) $downtimeXml->END_DATE);
    $downtime->setEndDate($endDate);
    $insertDate = new DateTime("@" . (string) $downtimeXml->INSERT_DATE);
    $downtime->setInsertDate($insertDate);
    $downtime->setPrimaryKey($primaryKey);
    return $downtime;
}
Exemplo n.º 3
0
 /**
  * Show how Bidirectional relationships must be correctly managed in 
  * userland/application code. (See Doctrine the tutorial: 
  * "Consistency of bi-directional references on the inverse side of a 
  * relation have to be managed in userland application code. Doctrine 
  * cannot magically update your collections to be consistent."). 
  */
 public function testDowntimeEndpoint_BidirectionalJoinConsistencyManagement()
 {
     print __METHOD__ . "\n";
     // create a linked entity graph as beow:
     //
     //     se        (1 service)
     //    / | \
     // el1 el2 el3   (3 endpoints)
     //    \ | /
     //     dt1       (1 downtime)
     $se = TestUtil::createSampleService('service1');
     $el1 = TestUtil::createSampleEndpointLocation();
     $el2 = TestUtil::createSampleEndpointLocation();
     $el3 = TestUtil::createSampleEndpointLocation();
     $se->addEndpointLocationDoJoin($el1);
     $se->addEndpointLocationDoJoin($el2);
     $se->addEndpointLocationDoJoin($el3);
     $dt1 = new Downtime();
     $dt1->setDescription('downtime description');
     $dt1->setSeverity("WARNING");
     $dt1->setClassification("UNSCHEDULED");
     $dt1->addEndpointLocation($el1);
     $dt1->addEndpointLocation($el2);
     $dt1->addEndpointLocation($el3);
     // persist and flush
     $this->em->persist($se);
     $this->em->persist($el1);
     $this->em->persist($el2);
     $this->em->persist($el3);
     $this->em->persist($dt1);
     $this->em->flush();
     // Now delete the relationship between dt1 and el1 + el2 using OWNING
     // SIDE ONLY; since downtime is the OWNING side we must remove el1 + el2
     // from downtime to actually delete the relationships in the DB
     // (on the subsequent flush). Since we have only removed the relationship
     // on the downtime side, our in-mem entity model is now inconsistent !
     $dt1->getEndpointLocations()->removeElement($el1);
     //$el1->getDowntimes()->removeElement($dt1);
     $dt1->getEndpointLocations()->removeElement($el2);
     //$el2->getDowntimes()->removeElement($dt1);
     $this->em->flush();
     // Entity model in DB now looks like this:
     //     se
     //    / | \
     // el1 el2 el3
     //        /
     //     dt1      (note FKs/relationships have been removed)
     // Assert that there are still three EndpointLocations and one Downtimes in the database
     $testConn = $this->getConnection();
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM EndpointLocations");
     $this->assertTrue($result->getRowCount() == 3);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes");
     $this->assertTrue($result->getRowCount() == 1);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes_EndpointLocations");
     $this->assertTrue($result->getRowCount() == 1);
     // Assert that our in-mem entity model is now inconsistent with DB
     // when VIEWED FROM THE ENDPOINT SIDE.
     $this->assertEquals(1, count($el1->getDowntimes()));
     $this->assertEquals(1, count($el2->getDowntimes()));
     $this->assertEquals(1, count($el3->getDowntimes()));
     // Assert that our in-mem entity model is consistent with DB
     // when VIEWED FROM THE DOWNTIME SIDE:
     // dt1 still has el3 linked (as expected) but not el1 or el2.
     // Note we use first() method to fetch first array collection entry!
     // (calling get(0) would not work as expected because the collection
     // is a map so array key values are preserved - el3 was added 3rd so it
     // preserves its zero-offset key value of 2).
     $this->assertEquals(1, count($dt1->getEndpointLocations()));
     $this->assertSame($el3, $dt1->getEndpointLocations()->first());
     $this->assertSame($el3, $dt1->getEndpointLocations()->get(2));
     // Next lines keep our in-mem inverse side consistent with DB. If we
     // didn't do this, then our first assertion on the following lines below
     // would fail! This shows that you have to keep your bi-directional
     // relationships consistent in userland/application code, doctrine
     // won't do this for you!
     $el1->getDowntimes()->removeElement($dt1);
     $el2->getDowntimes()->removeElement($dt1);
     // After updating the 'in-memory' entity model, check that el1 and el2
     // have no linked downtimes while el3 still has dt linked.
     // This mirrors what we have in the DB.
     $this->assertEquals(0, count($el1->getDowntimes()));
     $this->assertEquals(0, count($el2->getDowntimes()));
     $this->assertEquals(1, count($el3->getDowntimes()));
     // our collection key value is still same
     $this->assertSame($el3, $dt1->getEndpointLocations()->get(2));
 }
 /**
  * Test the <code>$serviceDAO->removeEndpoint($endpoint)</code> method.   
  */
 public function testServiceDAORemoveEndpoint()
 {
     print __METHOD__ . "\n";
     // create a linked entity graph as beow:
     //
     //      se -----|    (1 service)
     //     / | \    |
     //  el1 el2 el3 |    (3 endpoints)
     //  |  \ | /    |
     // dt0  dt1 ----|    (1 downtime)
     $dt1 = new Downtime();
     $dt1->setDescription('downtime description');
     $dt1->setSeverity("WARNING");
     $dt1->setClassification("UNSCHEDULED");
     $dt0 = new Downtime();
     $dt0->setDescription('downtime description');
     $dt0->setSeverity("WARNING");
     $dt0->setClassification("UNSCHEDULED");
     $se = TestUtil::createSampleService('service1');
     $el1 = TestUtil::createSampleEndpointLocation();
     $el2 = TestUtil::createSampleEndpointLocation();
     $el3 = TestUtil::createSampleEndpointLocation();
     $se->addEndpointLocationDoJoin($el1);
     $se->addEndpointLocationDoJoin($el2);
     $se->addEndpointLocationDoJoin($el3);
     //$se->_addDowntime($dt1); // we don't call this in client code !
     $dt1->addEndpointLocation($el1);
     $dt1->addEndpointLocation($el2);
     $dt1->addEndpointLocation($el3);
     $dt1->addService($se);
     $dt0->addEndpointLocation($el1);
     //$dt0->addService($se); // note we don't add this relationship for purposes of the test
     // persist and flush
     $this->em->persist($se);
     $this->em->persist($el1);
     $this->em->persist($el2);
     $this->em->persist($el3);
     $this->em->persist($dt1);
     $this->em->persist($dt0);
     $this->em->flush();
     // create DAO to test
     $serviceDao = new ServiceDAO();
     $serviceDao->setEntityManager($this->em);
     // remove first endpoint causing dt0 to be orphaned
     $serviceDao->removeEndpoint($el1);
     $this->em->flush();
     // Assert expected object graph
     //     se -----|   (1 service)
     //      | \    |
     //     el2 el3 |   (2 endpoints)
     //      | /    |
     // dt0 dt1-----|   (2 downtime)
     //
     $testConn = $this->getConnection();
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM EndpointLocations");
     $this->assertTrue($result->getRowCount() == 2);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes");
     $this->assertTrue($result->getRowCount() == 2);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes_EndpointLocations");
     $this->assertTrue($result->getRowCount() == 2);
     // Assert expected object graph in ORM Mem
     $this->assertEquals(1, count($el2->getDowntimes()));
     $this->assertEquals(1, count($el3->getDowntimes()));
     $this->assertEquals(2, count($se->getEndpointLocations()));
     $this->assertEquals(1, count($se->getDowntimes()));
     $this->assertEquals(2, count($dt1->getEndpointLocations()));
     $this->assertEquals(1, count($dt1->getServices()));
     // remove another el
     $serviceDao->removeEndpoint($el2);
     $this->em->flush();
     // Assert expected object graph in DB
     //     se -----| (1 service)
     //       \     |
     //        el3  | (1 endpoints)
     //        /    |
     // dt0 dt1-----| (2 downtime)
     //
     $testConn = $this->getConnection();
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM EndpointLocations");
     $this->assertTrue($result->getRowCount() == 1);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes");
     $this->assertTrue($result->getRowCount() == 2);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes_EndpointLocations");
     $this->assertTrue($result->getRowCount() == 1);
     // Assert expected object graph in ORM Mem
     $this->assertEquals(1, count($el3->getDowntimes()));
     $this->assertEquals(1, count($se->getEndpointLocations()));
     $this->assertEquals(1, count($se->getDowntimes()));
     $this->assertEquals(1, count($dt1->getEndpointLocations()));
     $this->assertEquals(1, count($dt1->getServices()));
     // remove another el
     $serviceDao->removeEndpoint($el3);
     $this->em->flush();
     // Assert expected object graph in DB
     //     se -----| (1 service)
     //             |
     //             | (1 endpoints)
     //             |
     // dt0 dt1-----| (2 downtime)
     //
     $testConn = $this->getConnection();
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM EndpointLocations");
     $this->assertTrue($result->getRowCount() == 0);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes");
     $this->assertTrue($result->getRowCount() == 2);
     $result = $testConn->createQueryTable('results_table', "SELECT * FROM Downtimes_EndpointLocations");
     $this->assertTrue($result->getRowCount() == 0);
     // Assert expected object graph in ORM Mem
     $this->assertEquals(0, count($se->getEndpointLocations()));
     $this->assertEquals(1, count($se->getDowntimes()));
     $this->assertEquals(0, count($dt1->getEndpointLocations()));
     $this->assertEquals(1, count($dt1->getServices()));
 }
Exemplo n.º 5
0
 /**
  * Array
  * (
  *     [DOWNTIME] => Array
  *     (
  *         [SEVERITY] => OUTAGE
  *         [DESCRIPTION] => Test
  *         [START_TIMESTAMP] => 20/03/2013 00:00
  *         [END_TIMESTAMP] => 23/03/2013 00:00
  *     )
  *     [Impacted_Services] => Array
  *     (
  *         [0] => 824
  *         [1] => 825
  *         [2] => 2146
  *     )
  *     [Impacted_Endpoints] => Array
  *     (
  *         [0] => 54
  *         [1] => 15
  *         [2] => 26     
  *      )
  * Adds a downtime
  * @param Array $values Downtime values, shown above
  * @param \User $user User making the request
  * @return \Downtime $dt The new downtime
  */
 public function addDowntime($values, \User $user = null)
 {
     //Check the portal is not in read only mode, throws exception if it is
     $this->checkPortalIsNotReadOnlyOrUserIsAdmin($user);
     require_once __DIR__ . '/ServiceService.php';
     $serviceService = new \org\gocdb\services\ServiceService();
     $serviceService->setEntityManager($this->em);
     // Get the affected services
     $services = array();
     foreach ($values['Impacted_Services'] as $service) {
         $services[] = $serviceService->getService($service);
     }
     // Get the affected endpoints
     $endpoints = array();
     foreach ($values['Impacted_Endpoints'] as $endpoint) {
         $endpoints[] = $serviceService->getEndpoint($endpoint);
     }
     if (count($services) == 0) {
         throw new \Exception("A downtime must affect at least one service");
     }
     // Check that each endpoint belongs to one of the services.
     // It is an error if an endpoint does not belong to one of the services.
     foreach ($endpoints as $checkEndpoint) {
         $endpointBelongsToService = false;
         foreach ($services as $checkService) {
             if (in_array($checkEndpoint, $checkService->getEndpointLocations()->toArray())) {
                 $endpointBelongsToService = true;
             }
         }
         if (!$endpointBelongsToService) {
             throw new \Exception('Error, affected endpoint is not owned by an affected service');
         }
     }
     // get the affected sites
     $sites = array();
     foreach ($services as $se) {
         $site = $se->getParentSite();
         if (!in_array($site, $sites)) {
             $sites[] = $site;
         }
     }
     if (count($sites) != 1) {
         // if there are multiple affected services from multiple sites,
         // the gui must either enforce single site selection
         // or prevent selecting 'define DT in site timezone' if selecting
         // multiple sites (i.e. utc only when selecting services from multiple sites).
         throw new \Exception("Downtime creation for multiple sites not supported yet");
     }
     // Check the user has a role covering the passed SEs
     $this->authorization($services, $user);
     $this->validate($values['DOWNTIME']);
     $startStr = $values['DOWNTIME']['START_TIMESTAMP'];
     $endStr = $values['DOWNTIME']['END_TIMESTAMP'];
     //echo($startStr. ' '.$endStr); // 14/05/2015 16:16      14/05/2015 16:17   d/m/Y H:i
     // did the user specify the downtime info in utc (default) or in site's local timezone?
     /*$requestUtcOrSiteTimezone = $values['DOWNTIME']['DEFINE_TZ_BY_UTC_OR_SITE'];
             $tzStr = 'UTC'; // the timezone label specified by the user (e.g. 'UTC' or 'Europe/London') 
             if($requestUtcOrSiteTimezone == 'site'){
                 // if there are multiple affected services from multiple sites, 
                 // we assume utc - the gui must therefore either enforce single site selection 
                 // or prevent selecting 'define DT in site timezone' if selecting 
                 // multiple sites (i.e. utc only when selecting services from multiple sites). 
                  
                 // get the site timezone label 
                 if(count($sites) > 1){
                     $tzStr = 'UTC'; // if many sites are affected (not implemented yet), assume UTC 
                 } else {
                     $siteTzOrNull = $sites[0]->getTimezoneId();  
                     if( !empty($siteTzOrNull)){
                         $tzStr = $siteTzOrNull;  
                     } else {
                         $tzStr = 'UTC'; 
                     }
                 }
             }
     
             // convert start and end into UTC 
             $UTC = new \DateTimeZone("UTC");
             if($tzStr != 'UTC'){
                 // specify dateTime in source TZ
                 $sourceTZ = new \DateTimeZone($tzStr);
                 $start = \DateTime::createFromFormat($this::FORMAT, $startStr, $sourceTZ);
                 $end = \DateTime::createFromFormat($this::FORMAT, $endStr, $sourceTZ);
                 // reset the TZ to UTC
                 $start->setTimezone($UTC); 
                 $end->setTimezone($UTC); 
             } else {
                 $start = \DateTime::createFromFormat($this::FORMAT, $startStr, $UTC);
                 $end = \DateTime::createFromFormat($this::FORMAT, $endStr, $UTC); 
             }*/
     $start = \DateTime::createFromFormat($this::FORMAT, $startStr, new \DateTimeZone("UTC"));
     $end = \DateTime::createFromFormat($this::FORMAT, $endStr, new \DateTimeZone("UTC"));
     $this->validateDates($start, $end);
     // calculate classification
     $nowPlus1Day = new \DateTime(null, new \DateTimeZone('UTC'));
     $oneDay = \DateInterval::createFromDateString('1 days');
     if ($start > $nowPlus1Day->add($oneDay)) {
         $class = "SCHEDULED";
     } else {
         $class = "UNSCHEDULED";
     }
     $this->em->getConnection()->beginTransaction();
     try {
         $dt = new \Downtime();
         $dt->setClassification($class);
         $dt->setDescription($values['DOWNTIME']['DESCRIPTION']);
         $dt->setSeverity($values['DOWNTIME']['SEVERITY']);
         $dt->setStartDate($start);
         $dt->setEndDate($end);
         $dt->setInsertDate(new \DateTime(null, new \DateTimeZone('UTC')));
         // Create a new pk and persist/flush to sync in-mem object state
         // with DB - is needed so that the call to v4DowntimePK->getId() actually
         // returns a value (we can still rollback no probs if an issue occurs
         // to remove the Downtime)
         $v4DowntimePk = new \PrimaryKey();
         $this->em->persist($v4DowntimePk);
         $this->em->flush();
         $dt->setPrimaryKey($v4DowntimePk->getId() . 'G0');
         //Create a link to the services
         foreach ($services as $service) {
             $dt->addService($service);
         }
         //Create a link to the affected endpoints (if any endpoints were selected)
         foreach ($endpoints as $endpoint) {
             $dt->addEndpointLocation($endpoint);
         }
         $this->em->persist($dt);
         $this->em->flush();
         $this->em->getConnection()->commit();
     } catch (\Exception $e) {
         $this->em->getConnection()->rollback();
         $this->em->close();
         throw $e;
     }
     return $dt;
 }