示例#1
0
  /** @see org.geoserver.config.GeoServerInitializer#initialize(org.geoserver.config.GeoServer) */
  public void initialize(final GeoServer geoServer) throws Exception {
    LOGGER.info(
        "Initializing GeoServer specific GWC configuration from "
            + GWCConfigPersister.GWC_CONFIG_FILE);

    final Version currentVersion = new Version("1.0.0");
    final File configFile = configPersister.findConfigFile();
    if (configFile == null) {
      LOGGER.fine("GWC's GeoServer specific configuration not found, creating with old defaults");
      GWCConfig oldDefaults = GWCConfig.getOldDefaults();
      oldDefaults.setVersion(currentVersion.toString());
      upgradeWMSIntegrationConfig(geoServer, oldDefaults);
      createDefaultTileLayerInfos(oldDefaults);
      configPersister.save(oldDefaults);
    }

    final GWCConfig config = configPersister.getConfig();
    final Version version = new Version(config.getVersion());
    if (currentVersion.compareTo(version) > 0) {
      // got the global config file, so old defaults are already in place if need be. Now
      // check whether we need to migrate the configuration from the Layer/GroupInfo metadata
      // maps to the tile layer catalog store
      moveTileLayerInfosToTileLayerCatalog();
      config.setVersion(currentVersion.toString());
      configPersister.save(config);
    }

    final GWCConfig gwcConfig = configPersister.getConfig();
    checkNotNull(gwcConfig);
  }
示例#2
0
  /**
   * Returns a version object for the specified version string optionally returning null when the
   * version string does not match one of the available WMS versions.
   *
   * @param version The version string.
   * @param exact If set to false, a version object will always be returned. If set to true only a
   *     version matching on of the available wms versions will be returned.
   * @return
   */
  public static Version version(String version, boolean exact) {
    if (version == null || 0 == version.trim().length()) {
      return null;
    }
    if (VERSION_1_1_1.toString().equals(version)) {
      return VERSION_1_1_1;
    } else if (VERSION_1_3_0.toString().equals(version)) {
      return VERSION_1_3_0;
    }

    return exact ? null : new Version(version);
  }
  @SuppressWarnings({"rawtypes", "unchecked"})
  @Override
  public Object read(Object req, Map kvp, Map rawKvp) throws Exception {
    GetFeatureInfoRequest request = (GetFeatureInfoRequest) super.read(req, kvp, rawKvp);
    request.setRawKvp(rawKvp);

    GetMapRequest getMapPart = new GetMapRequest();
    try {
      getMapPart = getMapReader.read(getMapPart, kvp, rawKvp);
    } catch (ServiceException se) {
      throw se;
    } catch (Exception e) {
      throw new ServiceException(e);
    }

    request.setGetMapRequest(getMapPart);

    List<MapLayerInfo> getMapLayers = getMapPart.getLayers();

    if ((getMapPart.getSldBody() != null || getMapPart.getSld() != null)
        && (rawKvp.get("QUERY_LAYERS") == null || "".equals(rawKvp.get("QUERY_LAYERS")))) {
      // in this case we assume all layers in SLD body are to be queried (GS own extension)(
      request.setQueryLayers(getMapLayers);
    } else {
      request.setQueryLayers(
          new MapLayerInfoKvpParser("QUERY_LAYERS", wms)
              .parse((String) rawKvp.get("QUERY_LAYERS")));
    }

    if (request.getQueryLayers().isEmpty()) {
      throw new ServiceException(
          "No QUERY_LAYERS has been requested, or no " + "queriable layer in the request anyways");
    }

    if (kvp.containsKey("propertyName")) {
      List<List<String>> propertyNames = (List<List<String>>) kvp.get("propertyName");
      if (propertyNames.size() == 1 && request.getQueryLayers().size() > 1) {
        // assume we asked the same list for all layers
        while (propertyNames.size() < request.getQueryLayers().size()) {
          propertyNames.add(propertyNames.get(0));
        }
      }
      if (propertyNames.size() != request.getQueryLayers().size()) {
        throw new ServiceException(
            "Mismatch between the property name set count "
                + propertyNames.size()
                + " and the query layers count "
                + request.getQueryLayers().size(),
            "InvalidParameter",
            "propertyName");
      }
      request.setPropertyNames(propertyNames);
    }

    // make sure they are a subset of layers
    List<MapLayerInfo> queryLayers = new ArrayList<MapLayerInfo>(request.getQueryLayers());
    queryLayers.removeAll(getMapLayers);
    if (queryLayers.size() > 0) {
      // we've already expanded base layers so let's avoid list the names, they are not
      // the original ones anymore
      throw new ServiceException(
          "QUERY_LAYERS contains layers not cited in LAYERS. "
              + "It should be a proper subset of those instead");
    }

    for (MapLayerInfo l : request.getQueryLayers()) {
      LayerInfo layerInfo = l.getLayerInfo();
      if (!wms.isQueryable(layerInfo)) {
        throw new ServiceException(
            "Layer " + l.getName() + " is not queryable",
            WMSErrorCode.LAYER_NOT_QUERYABLE.get(request.getVersion()),
            "QUERY_LAYERS");
      }
    }

    String format = (String) (kvp.containsKey("INFO_FORMAT") ? kvp.get("INFO_FORMAT") : null);

    if (format == null) {
      format = "text/plain";
    } else {
      List<String> infoFormats = wms.getAvailableFeatureInfoFormats();
      if (!infoFormats.contains(format)) {
        throw new ServiceException(
            "Invalid format '" + format + "', supported formats are " + infoFormats,
            "InvalidFormat",
            "info_format");
      }
      if (wms.getAllowedFeatureInfoFormats().contains(format) == false)
        throw wms.unallowedGetFeatureInfoFormatException(format);
    }

    request.setInfoFormat(format);

    request.setFeatureCount(1); // DJB: according to the WMS spec (7.3.3.7 FEATURE_COUNT) this
    // should be 1. also tested for by cite
    try {
      int maxFeatures = Integer.parseInt(String.valueOf(kvp.get("FEATURE_COUNT")));
      request.setFeatureCount(maxFeatures);
    } catch (NumberFormatException ex) {
      // do nothing, FEATURE_COUNT is optional
    }

    Version version = wms.negotiateVersion(request.getVersion());
    request.setVersion(version.toString());

    // JD: most wms 1.3 client implementations still use x/y rather than i/j, so we support those
    // too when i/j not specified when not running in strict cite compliance mode
    String colPixel, rowPixel;
    if (version.compareTo(WMS.VERSION_1_3_0) >= 0) {
      colPixel = "I";
      rowPixel = "J";

      if (!kvp.containsKey(colPixel) && !kvp.containsKey(rowPixel)) {
        if (!wms.getServiceInfo().isCiteCompliant()
            && kvp.containsKey("X")
            && kvp.containsKey("Y")) {
          colPixel = "X";
          rowPixel = "Y";
        }
      }
    } else {
      colPixel = "X";
      rowPixel = "Y";
    }

    try {
      String colParam = String.valueOf(kvp.get(colPixel));
      String rowParam = String.valueOf(kvp.get(rowPixel));
      int x = Integer.parseInt(colParam);
      int y = Integer.parseInt(rowParam);

      // ensure x/y in dimension of image
      if (x < 0 || x > getMapPart.getWidth() || y < 0 || y > getMapPart.getHeight()) {
        throw new ServiceException(
            String.format(
                "%d, %d not in dimensions of image: %d, %d",
                x, y, getMapPart.getWidth(), getMapPart.getHeight()),
            "InvalidPoint");
      }
      request.setXPixel(x);
      request.setYPixel(y);
    } catch (NumberFormatException ex) {
      String msg = colPixel + " and " + rowPixel + " incorrectly specified";
      throw new ServiceException(msg, "InvalidPoint");
    }

    return request;
  }
示例#4
0
  /**
   * Parses a map of key value pairs.
   *
   * <p>Important: This method modifies the map, overriding original values with parsed values.
   *
   * <p>This routine performs a lookup of {@link KvpParser} to parse the kvp entries.
   *
   * <p>If an individual parse fails, this method saves the exception, and adds it to the list that
   * is returned.
   *
   * @param rawKvp raw or unparsed kvp.
   * @return A list of errors that occured.
   */
  public static List<Throwable> parse(Map kvp) {

    // look up parser objects
    Collection parsers = GeoServerExtensions.extensions(KvpParser.class);

    // strip out parsers which do not match current service/request/version
    String service = (String) kvp.get("service");
    String version = (String) kvp.get("version");
    String request = (String) kvp.get("request");
    for (Iterator p = parsers.iterator(); p.hasNext(); ) {
      KvpParser parser = (KvpParser) p.next();

      if (parser.getService() != null && !parser.getService().equalsIgnoreCase(service)) {
        p.remove();
        continue;
      }

      if (parser.getVersion() != null && !parser.getVersion().toString().equals(version)) {
        p.remove();
        continue;
      }

      if (parser.getRequest() != null && !parser.getRequest().equalsIgnoreCase(request)) {
        p.remove();
      }
    }

    // parser the kvp's
    ArrayList<Throwable> errors = new ArrayList<Throwable>();
    for (Iterator itr = kvp.entrySet().iterator(); itr.hasNext(); ) {
      Map.Entry entry = (Map.Entry) itr.next();
      String key = (String) entry.getKey();

      // find the parser for this key value pair
      KvpParser parser = null;
      for (Iterator pitr = parsers.iterator(); pitr.hasNext(); ) {
        KvpParser candidate = (KvpParser) pitr.next();
        if (key.equalsIgnoreCase(candidate.getKey())) {
          if (parser == null) {
            parser = candidate;
          } else {
            String curService = parser.getService();
            Version curVersion = parser.getVersion();

            String trgService = candidate.getService();
            Version trgVersion = candidate.getVersion();

            // determine if this parser more closely matches the request
            if (curService == null) {
              // if target service matches, it is a closer match
              if (trgService != null && trgService.equalsIgnoreCase(service)) {
                parser = candidate;
              }
            } else {
              if (trgService != null && trgService.equalsIgnoreCase(service)) {
                // both match, filter by version
                if (trgVersion != null) {
                  if (curVersion == null && trgVersion.toString().equals(version)) {
                    parser = candidate;
                  }
                } else {
                  if (curVersion == null) {
                    // ambiguous, unable to match
                    // TODO: use request
                    throw new IllegalStateException(
                        "Multiple kvp parsers: " + parser + "," + candidate);
                  }
                }
              }
            }
          }
        }
      }

      // parse the value
      Object parsed = null;
      if (parser != null) {
        try {
          if (entry.getValue() instanceof String) {
            String value = (String) entry.getValue();
            parsed = parser.parse(value);
          } else {
            String[] values = (String[]) entry.getValue();
            List result = new ArrayList();
            for (String v : values) {
              result.add(parser.parse(v));
            }
            parsed = result;
          }
        } catch (Throwable t) {
          // dont throw any exceptions yet, befor the service is
          // known
          errors.add(t);
        }
      }

      // if noone could parse, just set to string value
      if (parsed != null) {
        entry.setValue(parsed);
      }
    }

    return errors;
  }