Overview

Namespaces

  • Mapbender
    • Component
      • HTTP
    • CoreBundle
      • Command
      • Component
        • Exception
      • Controller
      • DataFixtures
        • ORM
      • DependencyInjection
      • Element
        • Type
      • Entity
      • EventListener
      • Extension
      • Form
        • DataTransformer
        • EventListener
        • Type
      • Security
      • Template
    • DrupalIntegrationBundle
      • DependencyInjection
      • Security
        • Authentication
          • Provider
          • Token
        • Authorization
          • Voter
        • Factory
        • Firewall
        • User
      • Session
    • KmlBundle
      • Element
    • ManagerBundle
      • Controller
      • Form
        • DataTransformer
        • Type
    • MonitoringBundle
      • Command
      • Component
      • Controller
      • DependencyInjection
      • Entity
      • EventListener
      • Form
    • PrintBundle
      • Component
      • Controller
    • WmcBundle
      • Component
        • Exception
      • Element
        • Type
      • Entity
      • Form
        • EventListener
        • Type
    • WmsBundle
      • Component
        • Exception
      • Controller
      • DependencyInjection
      • Element
        • Type
      • Entity
      • Event
      • Form
        • EventListener
        • Type
    • WmtsBundle
      • Component
        • Exception
      • Controller
      • Entity
      • Form
        • Type
  • None
  • PHP

Classes

  • SchedulerCommand
  • Overview
  • Namespace
  • Class
  • Tree
  • Deprecated
  • Todo
  • Download
  1: <?php
  2: 
  3: namespace Mapbender\MonitoringBundle\Command;
  4: 
  5: use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
  6: use Sensio\Bundle\GeneratorBundle\Generator\Generator;
  7: use Symfony\Component\Console\Input\InputArgument;
  8: use Symfony\Component\Console\Input\InputOption;
  9: use Symfony\Component\Console\Input\InputInterface;
 10: use Symfony\Component\Console\Output\OutputInterface;
 11: use Symfony\Component\Console\Output\Output;
 12: use Mapbender\MonitoringBundle\Component\MonitoringRunner;
 13: use Mapbender\Component\HTTP\HTTPClient;
 14: 
 15: use Mapbender\MonitoringBundle\Entity\SchedulerProfile;
 16: 
 17: class SchedulerCommand extends ContainerAwareCommand {
 18:     protected function configure() {
 19:         $this->setDefinition(array(
 20:             new InputArgument('cmd', InputArgument::REQUIRED, 'Command (start,stop).'),
 21:             new InputArgument('caller', InputArgument::OPTIONAL, 'Caller()')
 22:             ))
 23:             ->setHelp(<<<EOT
 24: The <info>monitoring:scheduler</info> command starts the monitoring scheduler.
 25: <info>./app/console/ monitoring:scheduler</info>
 26: EOT
 27:             )
 28:             ->setName('monitoring:scheduler')
 29:             ->setDescription('Starts the monitoring scheduler.');
 30:     }
 31: 
 32:     protected function execute(InputInterface $input, OutputInterface $output) {
 33:         $output->writeln("\t\tEXEC");
 34:         $command = $input->getArgument('cmd');
 35:         if(!$command = strtolower($command)){
 36:         
 37:             return "";
 38:         }
 39: 
 40:         switch($command ){
 41:             case "run":
 42:                 $run = true;
 43:                 $num = 0;
 44:                 $this->getContainer()->get("doctrine")->resetEntityManager();
 45:                 $query = $this->getContainer()->get("doctrine")->getEntityManager()
 46:                         ->createQuery('SELECT sp FROM MapbenderMonitoringBundle:SchedulerProfile sp WHERE sp.current=true')
 47:                         ->useQueryCache(null)
 48:                         ->useResultCache(null);
 49:                 $sp_start_Arr = $query->getResult();
 50:                 $sp_start_id = -1;
 51:                 if($sp_start_Arr != null && count($sp_start_Arr) == 1){
 52:                     $sp_start = $sp_start_Arr[0];
 53:                     $sp_start->setLaststarttime(null);
 54:                     $sp_start->setLastendtime(null);
 55:                     $sp_start->setNextstarttime(null);
 56:                     $this->getContainer()->get("doctrine")
 57:                             ->getEntityManager()->persist($sp_start);
 58:                     $this->getContainer()->get("doctrine")
 59:                             ->getEntityManager()->flush();
 60:                     $sp_start_id = $sp_start->getId();
 61:                 }
 62:                 unset($sp_start_Arr);
 63:                 while($run){
 64:                     $num ++;
 65:                     $query = $this->getContainer()->get("doctrine")->getEntityManager()
 66:                             ->createQuery('SELECT sp FROM MapbenderMonitoringBundle:SchedulerProfile sp WHERE sp.current = true')
 67:                             ->useQueryCache(null)
 68:                             ->useResultCache(null);
 69:                     $sp_Arr = $query->getResult();
 70:                     if($sp_start_id  != -1 && count($sp_Arr) == 1 && $sp_start == $sp_Arr[0]){
 71:                         $sp = $sp_Arr[0];
 72:                         $now =  new \DateTime(date("Y-m-d H:i:s", time()));
 73:                         $hour_sec = 3600;
 74:                         $sleepbeforestart = 0;
 75:                         if($sp->getNextstarttime() === null) { // first time
 76:                             if($sp->getStarttime() > $now){
 77:                                 $sleepbeforestart = date_timestamp_get(
 78:                                         $sp->getStarttime())
 79:                                         - date_timestamp_get($now);
 80:                                 $sp->setNextstarttime(
 81:                                         new \DateTime(date("Y-m-d H:i:s",
 82:                                                 date_timestamp_get(
 83:                                                         $sp->getStarttime()))));
 84:                             } else {
 85:                                 $sleepbeforestart = $hour_sec * 24 - (
 86:                                         date_timestamp_get($now)
 87:                                         - date_timestamp_get(
 88:                                                 $sp->getStarttime()));
 89:                                 $sp->setNextstarttime(
 90:                                         new \DateTime(date("Y-m-d H:i:s",
 91:                                                 date_timestamp_get($now)
 92:                                                 + $sleepbeforestart)));
 93:                             }
 94:                         } else {
 95:                             if($sp->getNextstarttime() <= $now){
 96:                                 $nextstarttime_stamp =  date_timestamp_get(
 97:                                         $sp->getNextstarttime());
 98:                                 $now_stamp =  date_timestamp_get($now);
 99:                                 while($nextstarttime_stamp < $now_stamp){
100:                                     $nextstarttime_stamp += $sp->getStarttimeinterval();
101:                                 }
102:                                 $sp->setNextstarttime(null);
103:                                 $sp->setNextstarttime(
104:                                         new \DateTime(date("Y-m-d H:i:s",
105:                                                 $nextstarttime_stamp)));
106:                             }
107:                             $sleepbeforestart = date_timestamp_get(
108:                                     $sp->getNextstarttime()) - date_timestamp_get($now);
109:                         }
110:                         $sp->setStatusWaitstart();
111:                         $this->getContainer()->get("doctrine")
112:                                 ->getEntityManager()->persist($sp);
113:                         $this->getContainer()->get("doctrine")
114:                                 ->getEntityManager()->flush();
115:                         // sleep
116:                         sleep($sleepbeforestart);
117:                         $sp->setLaststarttime($sp->getNextstarttime());
118:                         $sp->setNextstarttime(null);
119:                         $sp->setNextstarttime(
120:                                 new \DateTime(date("Y-m-d H:i:s",
121:                                 date_timestamp_get($sp->getLaststarttime())
122:                                         + $sp->getStarttimeinterval())));
123:                         $this->getContainer()->get("doctrine")
124:                                 ->getEntityManager()->persist($sp);
125:                         $this->getContainer()->get("doctrine")
126:                                 ->getEntityManager()->flush();
127: 
128:                         $this->runCommandII($input, $output, $sp);
129: 
130:                         $sp->setLastendtime(
131:                                 new \DateTime(date("Y-m-d H:i:s", time())));
132:                         $sp->setStatusEnded();
133:                         $this->getContainer()->get("doctrine")
134:                                 ->getEntityManager()->persist($sp);
135:                         $this->getContainer()->get("doctrine")
136:                                 ->getEntityManager()->flush();
137:                         
138:                         if($sp->getStarttimeinterval() == 0){
139:                             $run = false;
140:                         }
141:                         unset($sp);
142:                     } else {
143:                         $run = false;
144:                     }
145:                     
146:                 }
147:             break;
148:             case "list":
149:                 $result = $this->listCommand($input, $output);
150:             break;
151:         }
152: 
153:     }
154: 
155:     protected function listCommand(InputInterface $input, OutputInterface $output){
156: 
157:         $defs = $this->getContainer()
158:             ->get("doctrine")
159:             ->getRepository('Mapbender\MonitoringBundle\Entity\MonitoringDefinition')
160:             ->findAll();
161:     
162:         foreach($defs as $md){
163:             $output->writeln($md->getTitle());
164:         }
165: 
166:     }
167: 
168:     protected function runCommand(InputInterface $input, OutputInterface $output){
169: 
170:         $defs = $this->getContainer()
171:             ->get("doctrine")
172:             ->getRepository('Mapbender\MonitoringBundle\Entity\MonitoringDefinition')
173:             ->findAll();
174:     
175: 
176:         $em = $this->getContainer()->get("doctrine")->getEntityManager();
177: 
178:         foreach($defs as $md){
179:             $now = new \DateTime();
180:             $output->write($now." ".$md->getTitle());
181:             $client = new HTTPClient($this->getContainer());
182:             $mr = new MonitoringRunner($md,$client);                                   
183:             if($md->getEnabled()){
184:                 $time_from = $this->md->getRuleStart();
185:                 $time_end = $this->md->getRuleEnd();
186:                 if($time_from == $time_end
187:                         || ($now > $time_from && $now < $time_end)){
188:                     $job = $mr->run();                                                         
189:                     $md->addMonitoringJob($job);                                               
190:                     $em->persist($md);                                                         
191:                     $em->flush();
192:                     $output->writeln("\t\t".$md->getLastMonitoringJob()->getStatus());
193:                 } else {
194:                     $output->writeln("\t\tEXCEPT TIME");
195:                 }
196:             }else{
197:                 $output->writeln("\t\tDISABLED");
198:             }
199:         }
200:         
201:     }
202:     
203:     protected function runCommandII(InputInterface $input, OutputInterface $output, SchedulerProfile $sp){
204: //        $this->getContainer()->get("doctrine")->resetEntityManager();
205:         $em = $this->getContainer()->get("doctrine")->getEntityManager();
206:         $query = $em->createQuery(
207:                 'SELECT d FROM MapbenderMonitoringBundle:MonitoringDefinition d')
208:                 ->useQueryCache(null)
209:                 ->useResultCache(null);
210:         $defs = $query->getResult();
211:         if(count($defs)==0){
212:             $output->writeln("\t\t NO JOB FOUND");
213:             return false;
214:         } else {
215:             $output->writeln("\t\t JOBS RUN:".count($defs));
216:             foreach($defs as $md){
217:                 $sp->setStatusRunning();
218:                 $em->persist($sp);
219:                 $em->flush();
220:                 $output->write($md->getTitle());
221:                 $client = new HTTPClient($this->getContainer());
222:                 $mr = new MonitoringRunner($md, $client);
223:                 if($md->getEnabled()){
224: //                    if($md->getRuleMonitor()){
225: //                        $now = new \DateTime();
226: //                        if($now > $md->getRuleStart() && $now < $md->getRuleEnd()){
227: //                            $job = $mr->run();                                                         
228: //                            $md->addMonitoringJob($job);                                               
229: //                            $em->persist($md);                                                         
230: //                            $em->flush();   
231: //                            $output->writeln("\t\t".$md->getLastMonitoringJob()->getStatus());
232: //                        } else {
233: //                            $output->writeln("\t\tEXCEPT TIME");
234: //                        }
235: //                    } else {
236:                         $job = $mr->run();                                                         
237:                         $md->addMonitoringJob($job);                                               
238:                         $em->persist($md);                                                         
239:                         $em->flush();   
240:                         $output->writeln("\t\t".$md->getLastMonitoringJob()->getStatus());
241: //                    }
242:                 }else{
243:                     $output->writeln("\t\tDISABLED");
244:                 }
245:                 $sp->setStatusWaitjobstart();
246:                 $em->persist($sp);
247:                 $em->flush();
248:                 sleep($sp->getJobinterval());
249:             }
250:         }
251:     }
252: }
253: 
254: 
Mapbender3 API documenation API documentation generated by ApiGen 2.8.0