java/src/main/com/google/appengine/tools/development/AbstractServer.java

   1 package com.google.appengine.tools.development;
   2
   3 import com.google.appengine.tools.development.ApplicationConfigurationManager.ServerConfigurationHandle;
   4
   5 import java.io.File;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.concurrent.CopyOnWriteArrayList;
   9 import java.util.logging.Logger;
  10
  11 /**
  12  * Abstract super class for {@link Server} implementations.
  13  */
  14 public abstract class AbstractServer implements Server {
  15    static final Logger LOGGER = Logger.getLogger(AbstractServer.class.getName());
  16
  17   private final ServerConfigurationHandle serverConfigurationHandle;
  18   private final String serverInfo;
  19   private final File externalResourceDir;
  20   private final String address;
  21   private final Map<String, Object> containerConfigProperties;
  22   private final DevAppServerImpl devAppServer;
  23   private final List<InstanceHolder> instancesHolders;
  24
  25   private LocalServerEnvironment localServerEnvironment;
  26
  27   protected AbstractServer(ServerConfigurationHandle serverConfigurationHandle,
  28       String serverInfo, File externalResourceDir, String address,
  29       Map<String, Object> containerConfigProperties, DevAppServerImpl devAppServer,
  30       List<InstanceHolder> instances) {
  31     this.serverConfigurationHandle = serverConfigurationHandle;
  32     this.serverInfo = serverInfo;
  33     this.externalResourceDir = externalResourceDir;
  34     this.address = address;
  35     this.containerConfigProperties = containerConfigProperties;
  36     this.devAppServer = devAppServer;
  37     this.instancesHolders = new CopyOnWriteArrayList<InstanceHolder>(instances);
  38   }
  39
  40   @Override
  41   public String getServerName() {
  42     return serverConfigurationHandle.getModule().getServerName();
  43   }
  44
  45   protected List<InstanceHolder> getInstanceHolders() {
  46     return instancesHolders;
  47   }
  48
  49   @Override
  50   public LocalServerEnvironment getLocalServerEnvironment() {
  51     return localServerEnvironment;
  52   }
  53
  54   @Override
  55   public final void configure() throws Exception {
  56     if (localServerEnvironment == null) {
  57         localServerEnvironment = doConfigure(serverConfigurationHandle, serverInfo,
  58             externalResourceDir, address, containerConfigProperties, devAppServer);
  59     }
  60   }
  61
  62   @Override
  63   public void createConnection() throws Exception {
  64     for (InstanceHolder instanceHolder : instancesHolders) {
  65       ContainerService containerService = instanceHolder.getContainerService();
  66       containerService.createConnection();
  67      }
  68   }
  69
  70   @Override
  71   public void startup() throws Exception {
  72     for (InstanceHolder instanceHolder : instancesHolders) {
  73       ContainerService containerService = instanceHolder.getContainerService();
  74       containerService.startup();
  75       String prettyAddress = containerService.getAddress();
  76       if (prettyAddress.equals("0.0.0.0") || prettyAddress.equals("127.0.0.1")) {
  77         prettyAddress = "localhost";
  78       }
  79
  80       String listeningHostAndPort = prettyAddress + ":" + containerService.getPort();
  81       if (instanceHolder.isMainInstance()) {
  82         LOGGER.info(String.format("Server %s is running at http://%s/", getServerName(),
  83             listeningHostAndPort));
  84       } else {
  85         LOGGER.info(String.format("Server %s instance %s is running at http://%s/",
  86             getServerName(), instanceHolder.getInstance(), listeningHostAndPort));
  87       }
  88       LOGGER.info("The admin console is running at http://" + listeningHostAndPort + "/_ah/admin");
  89     }
  90   }
  91
  92   @Override
  93   public void shutdown() throws Exception {
  94     for (InstanceHolder instanceHolder : instancesHolders) {
  95       instanceHolder.getContainerService().shutdown();
  96       if (instanceHolder.isMainInstance()) {
  97         LOGGER.info("Shutting down server " + getServerName());
  98       } else {
  99         LOGGER.info("Shutting down server " + getServerName() + " instance "
 100             + instanceHolder.getInstance());
 101       }
 102     }
 103   }
 104
 105   @Override
 106   public ContainerService getMainContainer() {
 107     return instancesHolders.get(0).getContainerService();
 108   }
 109
 110   /**
 111    * Configures the containers for a {@link Server} and returns the
 112    * {@link LocalServerEnvironment} for the main container.
 113    */
 114   protected abstract LocalServerEnvironment doConfigure(
 115       ServerConfigurationHandle serverConfigurationHandle, String serverInfo,
 116       File externalResourceDir, String address, Map<String, Object> containerConfigProperties,
 117       DevAppServerImpl devAppServer) throws Exception;
 118
 119   /**
 120    * Holder for instance related state.
 121    */
 122   static class InstanceHolder {
 123     private final ContainerService containerService;
 124     private final int instance;
 125
 126     /**
 127      * Construct an instance holder.
 128      * @param containerService for the instance.
 129      * @param instance nonnegative instance number or
 130      *     {link {@link LocalEnvironment#MAIN_INSTANCE}.
 131      */
 132     InstanceHolder(ContainerService containerService, int instance) {
 133       this.containerService = containerService;
 134       this.instance = instance;
 135     }
 136
 137     final ContainerService getContainerService() {
 138       return containerService;
 139     }
 140
 141     final int getInstance() {
 142       return instance;
 143     }
 144
 145     final boolean isMainInstance() {
 146       return instance < 0;
 147     }
 148
 149     @Override
 150     public String toString() {
 151       return "InstanceHolder: containerservice=" + containerService + " instance=" + instance;
 152     }
 153   }
 154 }