private static void migrateDB() {
   if (PropertyUtil.getOptional("db.flyway", true) == false) {
     log.warn(
         "Skipping flyway migration! Remove 'db.flyway' property or set it to 'true' to enable migration");
     return;
   }
   // upgrade database structure with http://flywaydb.org/
   log.info("Oskari-map checking DB status");
   try {
     FlywaydbMigrator.migrate(DS_HELPER.getDataSource());
     log.info("Oskari core DB migrated successfully");
   } catch (Exception e) {
     log.error(e, "DB migration for Oskari core failed!");
   }
   final String[] additionalPools = PropertyUtil.getCommaSeparatedList(KEY_MODULE_LIST);
   for (String module : additionalPools) {
     final String poolName = DS_HELPER.getOskariDataSourceName(module);
     try {
       FlywaydbMigrator.migrate(DS_HELPER.getDataSource(poolName), module);
       log.info(module + " DB migrated successfully");
     } catch (Exception e) {
       log.error(e, "DB migration for module " + module + " failed!", e);
       e.printStackTrace();
     }
   }
 }
  @Override
  public void handleGet(ActionParameters params) throws ActionException {
    log.info("handleGet");
    final JSONObject response;
    long id = getId(params);
    try {
      if (id > -1) {
        log.info("handleGet: has id");
        User user = userService.getUser(id);
        response = user2Json(user);
      } else {
        log.info("handleGet: no id");
        List<User> users = userService.getUsers();

        log.info("found: " + users.size() + "users");
        response = new JSONObject();
        JSONArray arr = new JSONArray();
        response.put("users", arr);

        List<User> newUsers = userService.getUsersWithRoles();

        for (User user : newUsers) {
          arr.put(user2Json(user));
        }
      }
    } catch (ServiceException se) {
      throw new ActionException(se.getMessage(), se);
    } catch (JSONException je) {
      throw new ActionException(je.getMessage(), je);
    }
    log.info(response);
    ResponseHelper.writeResponse(params, response);
  }
Example #3
0
  /**
   * Creates SLD style
   *
   * @param layer
   * @param styleName
   * @return style
   */
  private Style getSLDStyle(WFSLayerStore layer, String styleName) {
    Style style = null;
    log.debug("Trying to get style with name:", styleName);
    if (layer.getStyles().containsKey(styleName)) {
      style = createSLDStyle(layer.getStyles().get(styleName).getSLDStyle());
    } else if (STYLE_HIGHLIGHT.equals(styleName)) {
      style = createSLDStyle(layer.getSelectionSLDStyle());
    } else if (layer.getStyles().containsKey(STYLE_DEFAULT)) {
      style = createSLDStyle(layer.getStyles().get(STYLE_DEFAULT).getSLDStyle());
    }

    // if styles couldn't be parsed, use defaults
    if (style == null) {
      log.info("Layer style not customized or parsing failed. Using defaults.");
      if (STYLE_HIGHLIGHT.equals(styleName)) {
        // style = createDefaultHighlightSLDStyle(layer.getGMLGeometryProperty());
        // TODO: check if we really always want to use without namespace
        style = createDefaultHighlightSLDStyle(layer.getGMLGeometryPropertyNoNamespace());
      } else {
        style =
            createSLDStyle(
                WFSImage.class.getResourceAsStream(DEFAULT_SLD)); // getClass() (non-static)
      }
    }
    if (style == null) {
      // something is seriously wrong, even default styles can't be parsed
      log.error("Failed to get SLD style (even default failed)!!");
    }

    return style;
  }
 public void notifyCompleted(final boolean success) {
   log.info("Completed - layer:", layerId, "type:", type, "success:", success);
   Map<String, Object> output = createCommonResponse("completed");
   output.put("success", success);
   output.put("type", type.toString());
   this.service.addResults(session.getClient(), ResultProcessor.CHANNEL_STATUS, output);
 }
  /** Main initialization method */
  public static void initializeOskariContext() {

    log.info("- checking default DataSource");
    final Context ctx = DS_HELPER.getContext();
    if (!DS_HELPER.checkDataSource(ctx)) {
      log.error("Couldn't initialize default DataSource");
    }

    // loop "db.additional.pools" to see if we need any more pools configured
    log.info("- checking additional DataSources");
    final String[] additionalPools = PropertyUtil.getCommaSeparatedList(KEY_MODULE_LIST);
    for (String pool : additionalPools) {
      if (!DS_HELPER.checkDataSource(ctx, pool)) {
        log.error("Couldn't initialize DataSource for module:", pool);
      }
    }
  }
Example #6
0
 /**
  * Parses SLD style from a String (XML)
  *
  * @param xml
  * @return sld
  */
 private Style createSLDStyle(String xml) {
   if (xml == null) {
     log.info("Trying to create style from <null> String!");
     return null;
   }
   final Style style = createSLDStyle(new ByteArrayInputStream(xml.getBytes()));
   if (style == null) {
     log.warn("Couldn't create style from XML:", xml);
   }
   return style;
 }
  private String transformResponse(final String xslt, final String response) {

    if (xslt == null || "".equals(xslt)) {
      // if not found, return as is
      return response;
    }

    ByteArrayInputStream respInStream = null;
    ByteArrayInputStream xsltInStream = null;
    Writer outWriter = null;
    try {
      final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      factory.setValidating(false);
      factory.setNamespaceAware(true);
      final DocumentBuilder builder = factory.newDocumentBuilder();

      respInStream = new ByteArrayInputStream(response.getBytes("UTF-8"));
      final Document document = builder.parse(respInStream);
      xsltInStream = new ByteArrayInputStream(xslt.getBytes());
      final StreamSource stylesource = new StreamSource(xsltInStream);
      final String transformedResponse = getFormatedJSONString(document, stylesource);

      if (transformedResponse == null || transformedResponse.isEmpty()) {
        log.info("got empty result from transform with:", xslt, " - Response:", response);
        return response;
      }

      return transformedResponse;
    } catch (Exception e) {
      log.error(e, "Error transforming GFI response: ", response, "- with XSLT:", xslt);
    } finally {
      if (respInStream != null) {
        try {
          respInStream.close();
        } catch (Exception ignored) {
        }
      }
      if (xsltInStream != null) {
        try {
          xsltInStream.close();
        } catch (Exception ignored) {
        }
      }
      if (outWriter != null) {
        try {
          outWriter.close();
        } catch (Exception ignored) {
        }
      }
    }
    // Sanitize response
    return Jsoup.clean(response, Whitelist.relaxed());
  }
 public static void teardown() {
   if (schedulerService != null) {
     try {
       schedulerService.shutdownScheduler();
     } catch (final SchedulerException e) {
       log.error(e, "Failed to shut down the Oskari scheduler");
     }
   }
   DS_HELPER.teardown();
   JedisManager.shutdown();
   log.info("Context destroy");
 }
 private Bundle addBundle(final View view, final String bundleid) {
   Bundle bundle = view.getBundleByName(bundleid);
   if (bundle == null) {
     log.info("Bundle with id:", bundleid, "not found in currentView - adding");
     if (!bundleCache.containsKey(bundleid)) {
       log.warn("Trying to add bundle that isn't loaded:", bundleid, "- Skipping it!");
       return null;
     }
     bundle = bundleCache.get(bundleid).clone();
     view.addBundle(bundle);
   }
   return bundle;
 }
  public void migrate(Connection connection) {
    List<OskariLayer> layers = LAYER_SERVICE.findAll();

    LOG.info("Start populating capabilities for layers - count:", layers.size());
    Set<String> keys = new HashSet<>();
    int progress = 0;
    for (OskariLayer layer : layers) {
      try {
        final String layerKey =
            (layer.getSimplifiedUrl(true) + "----" + layer.getType()).toLowerCase();
        if (keys.contains(layerKey)) {
          progress++;
          continue;
        }
        keys.add(layerKey);
        CAPABILITIES_SERVICE.getCapabilities(layer);
        progress++;
        LOG.info("Capabilities populated:", progress, "/", layers.size());
      } catch (ServiceException e) {
        LOG.error(e, "Error getting capabilities for layer", layer);
      }
    }
  }
  private void setupBundle(final View view, final JSONObject publisherData, final String bundleid) {

    final JSONObject bundleData = publisherData.optJSONObject(bundleid);
    if (bundleData != null && bundleData.names().length() > 0) {
      log.info("config found for", bundleid);
      final Bundle bundle = addBundle(view, bundleid);
      mergeBundleConfiguration(bundle, bundleData, null);
    } else {
      log.warn("config not found for", bundleid, "- removing bundle.");
      // We have to remove the bundle...
      // TODO: check if we really want to remove the bundle from view since it could be template
      // view???
      view.removeBundle(bundleid);
    }
  }
  public void init() {
    // setup service if it hasn't been initialized
    if (viewService == null) {
      setViewService(new ViewServiceIbatisImpl());
    }

    if (myPlaceService == null) {
      setMyPlacesService(new MyPlacesServiceIbatisImpl());
    }

    if (permissionsService == null) {
      setPermissionsService(new PermissionsServiceIbatisImpl());
    }

    if (bundleService == null) {
      setBundleService(new BundleServiceIbatisImpl());
    }
    final String publishTemplateIdProperty = PropertyUtil.getOptional("view.template.publish");
    PUBLISHED_VIEW_TEMPLATE_ID =
        ConversionHelper.getLong(publishTemplateIdProperty, PUBLISHED_VIEW_TEMPLATE_ID);
    if (publishTemplateIdProperty == null) {
      log.warn("Publish template id not configured (property: view.template.publish)!");
    } else {
      log.info("Using publish template id: ", PUBLISHED_VIEW_TEMPLATE_ID);
    }

    // setup roles authorized to enable drawing tools on published map
    drawToolsEnabledRoles = PropertyUtil.getCommaSeparatedList(PROPERTY_DRAW_TOOLS_ENABLED);

    for (String bundleid : CACHED_BUNDLE_IDS) {
      final Bundle bundle = bundleService.getBundleTemplateByName(bundleid);
      if (bundle == null) {
        log.warn("Couldn't get", bundleid, "bundle template from DB!");
        continue;
      }
      bundleCache.put(bundleid, bundle);
    }
  }
  public static void init() {
    try {
      if (!propsLoaded) {
        loadProperties();
      }
      // catch all so we don't get mysterious listener start errors
      log.info(STR_LOG_LINE);
      log.info("Oskari-map context is being initialized");
      initializeOskariContext();

      // create initial content if properties tells us to
      if ("true".equals(PropertyUtil.getOptional("oskari.init.db"))) {
        log.info("- checking for initial db content");
        DBHandler.createContentIfNotCreated(DS_HELPER.getDataSource());
      }

      migrateDB();

      // init jedis
      log.info("Initializing Redis connections");
      JedisManager.connect(
          ConversionHelper.getInt(PropertyUtil.get(KEY_REDIS_POOL_SIZE), 30),
          PropertyUtil.get(KEY_REDIS_HOSTNAME, "localhost"),
          ConversionHelper.getInt(PropertyUtil.get(KEY_REDIS_PORT), 6379));
      log.info("Oskari-map context initialization done");
      log.info(STR_LOG_LINE);
    } catch (Exception ex) {
      log.error(ex, "!!! Error initializing context for Oskari !!!");
    }

    schedulerService = new SchedulerService();
    try {
      schedulerService.initializeScheduler();
    } catch (final SchedulerException e) {
      log.error(e, "Failed to start up the Oskari scheduler");
    }
  }
 public void notifyStart() {
   log.info("On start - layer:", layerId, "type:", type);
   this.service.addResults(
       session.getClient(), ResultProcessor.CHANNEL_STATUS, createCommonResponse("started"));
 }