Esempio n. 1
0
  public String configFile() {
    // Check template URL exists
    String templateUrl = driver.getEntity().getConfig(NginxController.SERVER_CONF_TEMPLATE_URL);
    ResourceUtils.create(this).checkUrlExists(templateUrl);

    // Check SSL configuration
    ProxySslConfig ssl = driver.getEntity().getConfig(NginxController.SSL_CONFIG);
    if (ssl != null
        && Strings.isEmpty(ssl.getCertificateDestination())
        && Strings.isEmpty(ssl.getCertificateSourceUrl())) {
      throw new IllegalStateException(
          "ProxySslConfig can't have a null certificateDestination and null certificateSourceUrl. One or both need to be set");
    }

    // For mapping by URL
    Iterable<UrlMapping> mappings = ((NginxController) driver.getEntity()).getUrlMappings();
    Multimap<String, UrlMapping> mappingsByDomain = LinkedHashMultimap.create();
    for (UrlMapping mapping : mappings) {
      Collection<String> addrs = mapping.getAttribute(UrlMapping.TARGET_ADDRESSES);
      if (addrs != null && addrs.size() > 0) {
        mappingsByDomain.put(mapping.getDomain(), mapping);
      }
    }
    Map<String, Object> substitutions =
        MutableMap.<String, Object>builder()
            .putIfNotNull("ssl", ssl)
            .put("urlMappings", mappings)
            .put("domainMappings", mappingsByDomain)
            .build();

    // Get template contents and process
    String contents = ResourceUtils.create(driver.getEntity()).getResourceAsString(templateUrl);
    return TemplateProcessor.processTemplateContents(contents, driver, substitutions);
  }
    @SuppressWarnings("unchecked")
    private void configureUrlMapping(UrlMapping urlMapping) {
      if (binding != null) {
        Map<String, Object> vars = binding.getVariables();
        for (String key : vars.keySet()) {
          if (isNotCoreMappingKey(key)) {
            parameterValues.put(key, vars.get(key));
          }
        }

        binding.getVariables().clear();
      }

      // Add the controller and action to the params map if
      // they are set. This ensures consistency of behaviour
      // for the application, i.e. "controller" and "action"
      // parameters will always be available to it.
      if (urlMapping.getControllerName() != null) {
        parameterValues.put("controller", urlMapping.getControllerName());
      }
      if (urlMapping.getActionName() != null) {
        parameterValues.put("action", urlMapping.getActionName());
      }

      urlMapping.setParameterValues(parameterValues);
      urlMappings.add(urlMapping);
    }
    private UrlMapping getURLMappingForNamedArgs(
        Map namedArguments, UrlMappingData urlData, String mapping, boolean isResponseCode) {
      @SuppressWarnings("hiding")
      Object controllerName;
      @SuppressWarnings("hiding")
      Object actionName;
      final Map bindingVariables = binding != null ? binding.getVariables() : null;
      boolean restRequest = false;
      if (namedArguments.containsKey(RESOURCE)) {
        controllerName = namedArguments.get(RESOURCE);
        actionName = DEFAULT_REST_MAPPING;
        restRequest = true;
      } else {
        controllerName = getControllerName(namedArguments, bindingVariables);
        actionName = getActionName(namedArguments, bindingVariables);
      }

      @SuppressWarnings("hiding")
      Object viewName = getViewName(namedArguments, bindingVariables);
      if (actionName != null && viewName != null) {
        viewName = null;
        LOG.warn(
            "Both [action] and [view] specified in URL mapping ["
                + mapping
                + "]. The action takes precendence!");
      }

      @SuppressWarnings("hiding")
      Object uri = getURI(namedArguments, bindingVariables);
      ConstrainedProperty[] constraints =
          previousConstraints.toArray(new ConstrainedProperty[previousConstraints.size()]);

      UrlMapping urlMapping;
      if (uri != null) {
        try {
          urlMapping = new RegexUrlMapping(urlData, new URI(uri.toString()), constraints, sc);
        } catch (URISyntaxException e) {
          throw new UrlMappingException("Cannot map to invalid URI: " + e.getMessage(), e);
        }
      } else {
        urlMapping =
            createURLMapping(
                urlData, isResponseCode, controllerName, actionName, viewName, constraints);
      }

      Object exceptionArg = getException(namedArguments, bindingVariables);

      if (isResponseCode && exceptionArg != null) {
        if (exceptionArg instanceof Class) {
          Class exClass = (Class) exceptionArg;
          if (Throwable.class.isAssignableFrom(exClass)) {
            ((ResponseCodeUrlMapping) urlMapping).setExceptionType(exClass);
          } else {
            LOG.error(
                "URL mapping argument [exception] with value ["
                    + exceptionArg
                    + "] must be a subclass of java.lang.Throwable");
          }
        } else {
          LOG.error(
              "URL mapping argument [exception] with value ["
                  + exceptionArg
                  + "] must be a valid class");
        }
      }

      if (restRequest) {
        urlMapping.setParseRequest(true);
        urlMapping.setRestfulMapping(true);
      } else {
        @SuppressWarnings("hiding")
        Object parseRequest = getParseRequest(namedArguments, bindingVariables);
        if (parseRequest instanceof Boolean) {
          urlMapping.setParseRequest((Boolean) parseRequest);
        }
      }

      if (actionName instanceof Map) {
        urlMapping.setRestfulMapping(true);
      }

      return urlMapping;
    }
    private Object _invoke(String methodName, Object arg, Object delegate) {
      Object[] args = (Object[]) arg;
      final boolean isResponseCode = isResponseCode(methodName);
      if (methodName.startsWith(SLASH) || isResponseCode) {
        // Create a new parameter map for this mapping.
        parameterValues = new HashMap<String, Object>();
        try {
          urlDefiningMode = false;
          args = args != null && args.length > 0 ? args : new Object[] {Collections.EMPTY_MAP};
          if (args[0] instanceof Closure) {
            UrlMappingData urlData = createUrlMappingData(methodName, isResponseCode);

            Closure callable = (Closure) args[0];
            if (delegate != null) callable.setDelegate(delegate);
            callable.call();

            @SuppressWarnings("hiding")
            Object controllerName;
            @SuppressWarnings("hiding")
            Object actionName;
            @SuppressWarnings("hiding")
            Object viewName;
            @SuppressWarnings("hiding")
            Object uri;

            if (binding != null) {
              controllerName = binding.getVariables().get(GrailsControllerClass.CONTROLLER);
              actionName = binding.getVariables().get(GrailsControllerClass.ACTION);
              viewName = binding.getVariables().get(GrailsControllerClass.VIEW);
              uri = binding.getVariables().get("uri");
            } else {
              controllerName = this.controllerName;
              actionName = this.actionName;
              viewName = this.viewName;
              uri = this.uri;
            }

            ConstrainedProperty[] constraints =
                previousConstraints.toArray(new ConstrainedProperty[previousConstraints.size()]);
            UrlMapping urlMapping;
            if (uri != null) {
              try {
                urlMapping = new RegexUrlMapping(urlData, new URI(uri.toString()), constraints, sc);
              } catch (URISyntaxException e) {
                throw new UrlMappingException("Cannot map to invalid URI: " + e.getMessage(), e);
              }
            } else {
              urlMapping =
                  createURLMapping(
                      urlData, isResponseCode, controllerName, actionName, viewName, constraints);
            }

            if (binding != null) {
              Map bindingVariables = binding.getVariables();
              Object parseRequest = getParseRequest(Collections.EMPTY_MAP, bindingVariables);
              if (parseRequest instanceof Boolean) {
                urlMapping.setParseRequest((Boolean) parseRequest);
              }
            }
            configureUrlMapping(urlMapping);
            return urlMapping;
          }

          if (args[0] instanceof Map) {
            Map namedArguments = (Map) args[0];
            UrlMappingData urlData = createUrlMappingData(methodName, isResponseCode);
            if (args.length > 1 && args[1] instanceof Closure) {
              Closure callable = (Closure) args[1];
              callable.call();
            }

            UrlMapping urlMapping =
                getURLMappingForNamedArgs(namedArguments, urlData, methodName, isResponseCode);
            configureUrlMapping(urlMapping);
            return urlMapping;
          }
          return null;
        } finally {
          if (binding != null) {
            binding.getVariables().clear();
          } else {
            controllerName = null;
            actionName = null;
            viewName = null;
          }
          previousConstraints.clear();
          urlDefiningMode = true;
        }
      } else if (!urlDefiningMode && CONSTRAINTS.equals(methodName)) {
        ConstrainedPropertyBuilder builder = new ConstrainedPropertyBuilder(this);
        if (args.length > 0 && (args[0] instanceof Closure)) {

          Closure callable = (Closure) args[0];
          callable.setDelegate(builder);
          for (ConstrainedProperty constrainedProperty : previousConstraints) {
            builder
                .getConstrainedProperties()
                .put(constrainedProperty.getPropertyName(), constrainedProperty);
          }
          callable.call();
        }
        return builder.getConstrainedProperties();
      } else {
        return super.invokeMethod(methodName, arg);
      }
    }