runtime/org.argeo.slc.server/src/main/java/org/argeo/slc/services/impl/AgentServiceImpl.java

   1 /*
   2  * Copyright (C) 2010 Mathieu Baudier <mbaudier@argeo.org>
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.argeo.slc.services.impl;
  18
  19 import java.util.ArrayList;
  20 import java.util.List;
  21 import java.util.concurrent.Executor;
  22
  23 import org.apache.commons.logging.Log;
  24 import org.apache.commons.logging.LogFactory;
  25 import org.argeo.slc.dao.runtime.SlcAgentDescriptorDao;
  26 import org.argeo.slc.runtime.SlcAgent;
  27 import org.argeo.slc.runtime.SlcAgentDescriptor;
  28 import org.argeo.slc.runtime.SlcAgentFactory;
  29 import org.argeo.slc.services.AgentService;
  30 import org.springframework.beans.factory.DisposableBean;
  31 import org.springframework.beans.factory.InitializingBean;
  32
  33 public class AgentServiceImpl implements AgentService, InitializingBean,
  34                 DisposableBean {
  35         private final static Log log = LogFactory.getLog(AgentServiceImpl.class);
  36
  37         private final SlcAgentDescriptorDao slcAgentDescriptorDao;
  38         private final SlcAgentFactory agentFactory;
  39
  40         private Executor systemExecutor;
  41
  42         private Long pingCycle = 20000l;
  43
  44         private Boolean pingThreadActive = true;
  45
  46         public AgentServiceImpl(SlcAgentDescriptorDao slcAgentDescriptorDao,
  47                         SlcAgentFactory agentFactory) {
  48                 this.slcAgentDescriptorDao = slcAgentDescriptorDao;
  49                 this.agentFactory = agentFactory;
  50         }
  51
  52         public void register(SlcAgentDescriptor slcAgentDescriptor) {
  53                 if (slcAgentDescriptorDao.getAgentDescriptor(slcAgentDescriptor
  54                                 .getUuid()) == null)
  55                         slcAgentDescriptorDao.create(slcAgentDescriptor);
  56                 log.info("Registered agent #" + slcAgentDescriptor.getUuid());
  57         }
  58
  59         public void unregister(SlcAgentDescriptor slcAgentDescriptor) {
  60                 slcAgentDescriptorDao.delete(slcAgentDescriptor);
  61                 log.info("Unregistered agent #" + slcAgentDescriptor.getUuid());
  62         }
  63
  64         public void afterPropertiesSet() throws Exception {
  65                 // if (pingCycle > 0)
  66                 // new PingThread().start();
  67                 if (pingCycle > 0) {
  68                         Thread authenticatedThread = new Thread("SLC Agents Ping") {
  69                                 public void run() {
  70                                         systemExecutor.execute(new AgentsPing());
  71                                 }
  72                         };
  73                         authenticatedThread.start();
  74
  75                 }
  76         }
  77
  78         public synchronized void destroy() throws Exception {
  79                 pingThreadActive = false;
  80                 notifyAll();
  81         }
  82
  83         public void setPingCycle(Long pingCycle) {
  84                 this.pingCycle = pingCycle;
  85         }
  86
  87         public void setSystemExecutor(Executor securityService) {
  88                 this.systemExecutor = securityService;
  89         }
  90
  91         protected class AgentsPing implements Runnable {
  92                 public void run() {
  93
  94                         // FIXME: temporary hack so that the ping starts after the server
  95                         // has been properly started.
  96                         try {
  97                                 Thread.sleep(10 * 1000);
  98                         } catch (InterruptedException e1) {
  99                                 // silent
 100                         }
 101
 102                         log.info("Start pinging agents.");
 103                         while (pingThreadActive) {
 104                                 List<SlcAgentDescriptor> lst = slcAgentDescriptorDao
 105                                                 .listSlcAgentDescriptors();
 106                                 List<String> agentIds = new ArrayList<String>();
 107                                 for (SlcAgentDescriptor ad : lst)
 108                                         agentIds.add(ad.getUuid());
 109
 110                                 if (log.isTraceEnabled())
 111                                         log.trace("Ping " + agentIds.size() + " agent(s).");
 112                                 for (String agentId : agentIds) {
 113                                         SlcAgent agent = agentFactory.getAgent(agentId);
 114                                         if (!agent.ping()) {
 115                                                 log.info("Agent " + agentId + " did not reply to ping,"
 116                                                                 + " removing its descriptor...");
 117                                                 slcAgentDescriptorDao.delete(agentId);
 118                                         }
 119                                 }
 120
 121                                 lst = slcAgentDescriptorDao.listSlcAgentDescriptors();
 122                                 agentIds = new ArrayList<String>();
 123                                 for (SlcAgentDescriptor ad : lst)
 124                                         agentIds.add(ad.getUuid());
 125                                 agentFactory.pingAll(agentIds);
 126
 127                                 synchronized (AgentServiceImpl.this) {
 128                                         try {
 129                                                 AgentServiceImpl.this.wait(pingCycle);
 130                                         } catch (InterruptedException e) {
 131                                                 // silent
 132                                         }
 133                                 }
 134                         }
 135                         log.info("Stopped pinging agents.");
 136                 }
 137
 138         }
 139
 140 }