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

   1 package com.google.appengine.tools.development;
   2
   3 import com.google.appengine.api.labs.servers.ServersServicePb.ServersServiceError;
   4 import com.google.apphosting.api.ApiProxy;
   5 import com.google.apphosting.api.ApiProxy.ApplicationException;
   6 import com.google.apphosting.utils.config.AppEngineConfigException;
   7 import com.google.apphosting.utils.config.AppEngineWebXml;
   8 import com.google.apphosting.utils.config.AppEngineWebXml.ManualScaling;
   9 import com.google.common.collect.ImmutableList;
  10 import com.google.common.collect.ImmutableMap;
  11
  12 import java.io.File;
  13 import java.io.IOException;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.logging.Level;
  17 import java.util.logging.Logger;
  18
  19 import javax.servlet.ServletException;
  20 import javax.servlet.http.HttpServletRequest;
  21 import javax.servlet.http.HttpServletResponse;
  22
  23 /**
  24  * Manager for {@link DevAppServer} servers.
  25  *
  26  */
  27 public class Servers implements ServersController, ServersFilterHelper {
  28   private static final Logger LOGGER = Logger.getLogger(Servers.class.getName());
  29
  30   private final List<Server> servers;
  31   private final Map<String, Server> serverNameToServerMap;
  32
  33   static Servers createServers(ApplicationConfigurationManager applicationConfigurationManager,
  34       String serverInfo, File externalResourceDir, String address, int port,
  35       DevAppServerImpl devAppServer) {
  36     ImmutableList.Builder<Server> builder = ImmutableList.builder();
  37     LocalServerEnvironment mainEnvironment = null;
  38     for (ApplicationConfigurationManager.ServerConfigurationHandle serverConfigurationHandle :
  39       applicationConfigurationManager.getServerConfigurationHandles()) {
  40       AppEngineWebXml appEngineWebXml =
  41           serverConfigurationHandle.getModule().getAppEngineWebXml();
  42       Server server = null;
  43       if (!appEngineWebXml.getBasicScaling().isEmpty()) {
  44         throw new AppEngineConfigException("Basic scaling servers are currently not supported");
  45       } else if (!appEngineWebXml.getManualScaling().isEmpty()) {
  46         server = new ManualServer(serverConfigurationHandle, serverInfo, address, devAppServer,
  47             appEngineWebXml);
  48       } else {
  49         server = new AutomaticServer(serverConfigurationHandle, serverInfo, externalResourceDir,
  50             address, port, devAppServer);
  51       }
  52       builder.add(server);
  53
  54       port = 0;
  55       externalResourceDir = null;
  56     }
  57     return new Servers(builder.build());
  58   }
  59
  60   void shutdown() throws Exception {
  61     for (Server server : servers) {
  62       server.shutdown();
  63     }
  64   }
  65
  66   void configure(Map<String, Object>containerConfigProperties) throws Exception {
  67     for (Server server : servers) {
  68       server.configure(containerConfigProperties);
  69     }
  70   }
  71
  72   void createConnections() throws Exception {
  73     for (Server server : servers) {
  74       server.createConnection();
  75     }
  76   }
  77
  78   void startup() throws Exception {
  79     for (Server server : servers) {
  80       server.startup();
  81     }
  82   }
  83
  84   Server getMainServer() {
  85     return servers.get(0);
  86   }
  87
  88   private Servers(List<Server> servers) {
  89     if (servers.size() < 1) {
  90       throw new IllegalArgumentException("servers must not be empty.");
  91     }
  92     this.servers = servers;
  93
  94     ImmutableMap.Builder<String, Server> mapBuilder = ImmutableMap.builder();
  95     for (Server server : this.servers) {
  96       mapBuilder.put(server.getServerName(), server);
  97     }
  98     serverNameToServerMap = mapBuilder.build();
  99   }
 100
 101   LocalServerEnvironment getLocalServerEnvironment() {
 102     return servers.get(0).getLocalServerEnvironment();
 103   }
 104
 105   Server getServer(String serverName) {
 106     return serverNameToServerMap.get(serverName);
 107   }
 108
 109   @Override
 110   public Iterable<String> getServerNames() {
 111     return serverNameToServerMap.keySet();
 112   }
 113
 114   @Override
 115   public Iterable<String> getVersions(String serverName) throws ApplicationException {
 116     return ImmutableList.of(getDefaultVersion(serverName));
 117   }
 118
 119   @Override
 120   public String getDefaultVersion(String serverName) throws ApplicationException {
 121     Server server = getRequiredServer(serverName);
 122     return server.getMainContainer().getAppEngineWebXmlConfig().getMajorVersionId();
 123   }
 124
 125   @Override
 126   public int getNumInstances(String serverName, String version) throws ApplicationException {
 127     Server server = getRequiredServer(serverName);
 128     checkVersion(version, server);
 129     ManualScaling manualScaling = getRequiredManualScaling(server);
 130     return Integer.parseInt(manualScaling.getInstances());
 131   }
 132
 133   @Override
 134   public String getHostname(String serverName, String version, int instance)
 135       throws ApplicationException {
 136     Server server = getRequiredServer(serverName);
 137     checkVersion(version, server);
 138     if (instance != LocalEnvironment.MAIN_INSTANCE) {
 139       getRequiredManualScaling(server);
 140     }
 141     String hostAndPort = server.getHostAndPort(instance);
 142     if (hostAndPort == null) {
 143       throw new ApiProxy.ApplicationException(
 144           ServersServiceError.ErrorCode.INVALID_INSTANCES_VALUE,
 145           "Instance " + instance + " not found");
 146     }
 147     return hostAndPort;
 148   }
 149
 150   @Override
 151   public void startServer(String serverName, String version) throws ApplicationException {
 152     Server server = getRequiredServer(serverName);
 153     checkVersion(version, server);
 154     getRequiredManualScaling(server);
 155     try {
 156       server.startServing();
 157     } catch (Exception e) {
 158       LOGGER.log(Level.SEVERE, "startServing failed", e);
 159       new ApiProxy.ApplicationException(ServersServiceError.ErrorCode.UNEXPECTED_STATE_VALUE,
 160           "startServing failed with error " + e.getMessage());
 161     }
 162   }
 163
 164   @Override
 165   public void stopServer(String serverName, String version) throws ApplicationException {
 166     Server server = getRequiredServer(serverName);
 167     checkVersion(version, server);
 168     getRequiredManualScaling(server);
 169     try {
 170       server.stopServing();
 171     } catch (Exception e) {
 172       LOGGER.log(Level.SEVERE, "stopServing failed", e);
 173       new ApiProxy.ApplicationException(ServersServiceError.ErrorCode.UNEXPECTED_STATE_VALUE,
 174           "stopServing failed with error " + e.getMessage());
 175     }
 176   }
 177
 178   private Server getRequiredServer(String serverName) {
 179     Server server = serverNameToServerMap.get(serverName);
 180     if (server == null) {
 181       throw new ApiProxy.ApplicationException(ServersServiceError.ErrorCode.INVALID_SERVER_VALUE,
 182           "Server not found");
 183     }
 184     return server;
 185   }
 186
 187   private ManualScaling getRequiredManualScaling(Server server) {
 188     ManualScaling manualScaling =
 189         server.getMainContainer().getAppEngineWebXmlConfig().getManualScaling();
 190     if (manualScaling.isEmpty()) {
 191       throw new ApiProxy.ApplicationException(ServersServiceError.ErrorCode.INVALID_VERSION_VALUE,
 192           "Manual scaling is required.");
 193     }
 194     return manualScaling;
 195   }
 196
 197   private void checkVersion(String version, Server server) {
 198     String serverVersion =
 199         server.getMainContainer().getAppEngineWebXmlConfig().getMajorVersionId();
 200     if (version == null || !version.equals(serverVersion)) {
 201       throw new ApiProxy.ApplicationException(ServersServiceError.ErrorCode.INVALID_VERSION_VALUE,
 202           "Version not found");
 203     }
 204   }
 205
 206   @Override
 207   public boolean acquireServingPermit(
 208     String serverName, int instanceNumber, boolean allowQueueOnBackends) {
 209     Server server = getServer(serverName);
 210     InstanceHolder instanceHolder = server.getInstanceHolder(instanceNumber);
 211     return instanceHolder.acquireServingPermit();
 212   }
 213
 214   @Override
 215   public int getAndReserveFreeInstance(String requestedServer) {
 216     Server server = getServer(requestedServer);
 217     InstanceHolder instanceHolder = server.getAndReserveAvailableInstanceHolder();
 218     return instanceHolder == null ? -1 : instanceHolder.getInstance();
 219   }
 220
 221   @Override
 222   public void returnServingPermit(String serverName, int instance) {
 223   }
 224
 225   @Override
 226   public boolean checkInstanceExists(String serverName, int instance) {
 227     Server server = getServer(serverName);
 228     return server != null && server.getInstanceHolder(instance) != null;
 229   }
 230
 231   @Override
 232   public boolean checkServerExists(String serverName) {
 233      return getServer(serverName) != null;
 234   }
 235
 236   @Override
 237   public boolean checkServerStopped(String serverName) {
 238     return checkInstanceStopped(serverName, LocalEnvironment.MAIN_INSTANCE);
 239   }
 240
 241   @Override
 242   public boolean checkInstanceStopped(String serverName, int instance) {
 243     Server server = getServer(serverName);
 244     InstanceHolder instanceHolder = server.getInstanceHolder(instance);
 245     return instanceHolder.isStopped();
 246   }
 247
 248   @Override
 249   public void forwardToServer(String requestedServer, int instance, HttpServletRequest hrequest,
 250       HttpServletResponse hresponse) throws IOException, ServletException {
 251     Server server = getServer(requestedServer);
 252     InstanceHolder instanceHolder = server.getInstanceHolder(instance);
 253     instanceHolder.getContainerService().forwardToServer(hrequest, hresponse);
 254   }
 255
 256   @Override
 257   public boolean isServerLoadBalancingServer(String serverName, int instance) {
 258     Server server = getServer(serverName);
 259     InstanceHolder instanceHolder = server.getInstanceHolder(instance);
 260     return instanceHolder.isServerLoadBalancingServer();
 261   }
 262
 263   @Override
 264   public boolean expectsGeneratedStartRequests(String serverName,
 265       int instance) {
 266     Server server = getServer(serverName);
 267     InstanceHolder instanceHolder = server.getInstanceHolder(instance);
 268     return instanceHolder.expectsGeneratedStartRequest();
 269   }
 270 }