protected DocumentMetadata getMetaFromVersionKey(String versionDocPath) {
   String metaData = metaStore.get(versionDocPath);
   if (metaData != null) {
     return JacksonUtil.objectFromJson(metaData, DocumentMetadata.class);
   }
   return null;
 }
Ejemplo n.º 2
0
 public EmailAlerter(String templateName) {
   String templateJson =
       Kernel.getSys()
           .retrieveSystemConfig(
               ContextFactory.getKernelUser(), "CONFIG", TEMPLATE_URI + templateName);
   this.emailTemplate = JacksonUtil.objectFromJson(templateJson, EmailTemplate.class);
 }
Ejemplo n.º 3
0
 public static EmailTemplate getEmailTemplate(CallingContext context, String templateName) {
   String templateJson =
       Kernel.getSys().retrieveSystemConfig(context, "CONFIG", EMAIL_TEMPLATE_DIR + templateName);
   if (StringUtils.isBlank(templateJson)) {
     throw RaptureExceptionFactory.create("Email template " + templateName + " does not exist");
   }
   return JacksonUtil.objectFromJson(templateJson, EmailTemplate.class);
 }
 @Override
 public ReflexValue readContent(ReflexStreamValue file, IReflexIOHandler ioHandler) {
   // The file is one big JSON document, and in fact is an array, so
   // convert it to an array
   ReflexValue content = ioHandler.getContent(file);
   List<?> ret = JacksonUtil.objectFromJson(content.toString(), List.class);
   return new ReflexValue(ret);
 }
Ejemplo n.º 5
0
 public static SMTPConfig getSMTPConfig() {
   String configString =
       Kernel.getSys()
           .retrieveSystemConfig(ContextFactory.getKernelUser(), "CONFIG", SMTP_CONFIG_URL);
   if (StringUtils.isBlank(configString)) {
     throw RaptureExceptionFactory.create("No SMTP configured");
   }
   return JacksonUtil.objectFromJson(configString, SMTPConfig.class);
 }
Ejemplo n.º 6
0
 @Test
 public void testGetRepositories() {
   List<DocumentRepoConfig> documentRepositories =
       Kernel.getDoc().getDocRepoConfigs(callingContext);
   int preexisting = documentRepositories.size();
   if (!Kernel.getDoc().docRepoExists(callingContext, repoUri)) {
     Kernel.getDoc().createDocRepo(callingContext, repoUri, config);
   }
   documentRepositories = Kernel.getDoc().getDocRepoConfigs(callingContext);
   assertEquals(
       JacksonUtil.jsonFromObject(documentRepositories),
       preexisting + 1,
       documentRepositories.size());
 }
Ejemplo n.º 7
0
 @Override
 public PluginTransportItem encode(CallingContext ctx, String uri) {
   try {
     Object o = getReflectionObject(ctx, uri);
     MessageDigest md = MessageDigest.getInstance("MD5");
     PluginTransportItem item = new PluginTransportItem();
     item.setContent(JacksonUtil.bytesJsonFromObject(o));
     md.update(item.getContent());
     item.setHash(Hex.encodeHexString(md.digest()));
     item.setUri(uri);
     return item;
   } catch (NoSuchAlgorithmException e) {
     throw RaptureExceptionFactory.create(
         HttpURLConnection.HTTP_INTERNAL_ERROR, "Error encoding item", e);
   }
 }
Ejemplo n.º 8
0
  @Override
  public void addMetadata(CallingContext context, Map<String, String> values, Boolean overwrite) {
    if ((values == null) || values.isEmpty()) return;

    Map<String, String> metadata = context.getMetadata();
    if (metadata == null) metadata = new HashMap<String, String>();
    for (String key : values.keySet()) {
      if (!overwrite && metadata.containsKey(key)) {
        throw RaptureExceptionFactory.create(
            HttpURLConnection.HTTP_BAD_REQUEST, key + " exists and overwrite was disallowed");
      }
      metadata.put(key, values.get(key));
    }
    context.setMetadata(metadata);
    getEphemeralRepo()
        .addToStage(
            RaptureConstants.OFFICIAL_STAGE,
            "session/" + context.getContext(),
            JacksonUtil.jsonFromObject(context),
            false);
  }
 /**
  * Insert values into the array, preserving the original order of the request
  *
  * @param docsWithMeta - array to set values in with the correct order
  * @param positions - the original ordering
  * @param contents - the document contents
  * @param metaContents - the meta document contents
  */
 protected void constructDocumentWithMetaList(
     DocumentWithMeta[] docsWithMeta,
     List<RaptureURI> uris,
     List<Integer> positions,
     List<String> contents,
     List<String> metaContents) {
   if (contents.size() != metaContents.size()) {
     log.error("Batch getDocAndMetas failed due to different size of content vs metaContent");
     return;
   }
   for (int i = 0; i < contents.size(); i++) {
     DocumentWithMeta dwm = new DocumentWithMeta();
     String meta = metaContents.get(i);
     if (meta != null) {
       dwm.setMetaData(JacksonUtil.objectFromJson(meta, DocumentMetadata.class));
     }
     dwm.setContent(contents.get(i));
     dwm.setDisplayName(uris.get(positions.get(i)).getDocPath());
     docsWithMeta[positions.get(i)] = dwm;
   }
 }
Ejemplo n.º 10
0
  @SuppressWarnings("unchecked")
  private void setupRoutes() {

    before(
        (req, res) -> {
          log.info("Path is: " + req.pathInfo());
          CallingContext ctx = ctxs.get(req.session().id());
          if (ctx == null) {
            // check x-api-key header
            String apiKey = req.headers("x-api-key");
            if (StringUtils.isNotBlank(apiKey)) {
              ctx = Kernel.INSTANCE.loadContext(APP_KEY, apiKey);
              if (ctx == null) {
                String msg = String.format("Invalid apiKey [%s] for app [%s]", apiKey, APP_KEY);
                log.warn(msg);
                halt(401, msg);
              }
              String id = req.session(true).id();
              ctxs.put(id, ctx);
            } else {
              log.warn("x-api-key header not found, rejecting...");
              halt(401, "Please provide 'x-api-key' header to access this API");
            }
          }
        });

    post(
        "/doc/:authority",
        (req, res) -> {
          log.info(req.body());
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          String authority = req.params(":authority");
          String config = (String) data.get("config");
          CallingContext ctx = getContext(req);
          if (Kernel.getDoc().docRepoExists(ctx, authority)) {
            halt(409, String.format("Repo [%s] already exists", authority));
          }
          Kernel.getDoc().createDocRepo(ctx, authority, config);
          return new RaptureURI(authority, Scheme.DOCUMENT).toString();
        });

    get(
        "/doc/*",
        (req, res) -> {
          String meta = req.queryParams("meta");
          if (StringUtils.isNotBlank(meta)) {
            return Kernel.getDoc().getDocAndMeta(getContext(req), getDocUriParam(req));
          }
          return Kernel.getDoc().getDoc(getContext(req), getDocUriParam(req));
        });

    put(
        "/doc/*",
        (req, res) -> {
          return Kernel.getDoc().putDoc(getContext(req), getDocUriParam(req), req.body());
        });

    delete(
        "/doc/:authority",
        (req, res) -> {
          Kernel.getDoc().deleteDocRepo(getContext(req), req.params(":authority"));
          return true;
        });

    delete(
        "/doc/*",
        (req, res) -> {
          return Kernel.getDoc().deleteDoc(getContext(req), getDocUriParam(req));
        });

    post(
        "/blob/:authority",
        (req, res) -> {
          log.info(req.body());
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          String authority = req.params(":authority");
          String config = (String) data.get("config");
          String metaConfig = (String) data.get("metaConfig");
          CallingContext ctx = getContext(req);
          if (Kernel.getBlob().blobRepoExists(ctx, authority)) {
            halt(409, String.format("Repo [%s] already exists", authority));
          }
          Kernel.getBlob().createBlobRepo(ctx, authority, config, metaConfig);
          return new RaptureURI(authority, Scheme.BLOB).toString();
        });

    get(
        "/blob/*",
        (req, res) -> {
          return Kernel.getBlob().getBlob(getContext(req), getBlobUriParam(req));
        },
        json());

    put(
        "/blob/*",
        (req, res) -> {
          String uri = getBlobUriParam(req);
          Kernel.getBlob().putBlob(getContext(req), uri, req.bodyAsBytes(), req.contentType());
          return uri;
        });

    delete(
        "/blob/:authority",
        (req, res) -> {
          Kernel.getBlob().deleteBlobRepo(getContext(req), req.params(":authority"));
          return true;
        });

    delete(
        "/blob/*",
        (req, res) -> {
          Kernel.getBlob().deleteBlob(getContext(req), getBlobUriParam(req));
          return true;
        });

    post(
        "/series/:authority",
        (req, res) -> {
          log.info(req.body());
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          String authority = req.params(":authority");
          String config = (String) data.get("config");
          CallingContext ctx = getContext(req);
          if (Kernel.getSeries().seriesRepoExists(ctx, authority)) {
            halt(409, String.format("Repo [%s] already exists", authority));
          }
          Kernel.getSeries().createSeriesRepo(ctx, authority, config);
          return new RaptureURI(authority, Scheme.SERIES).toString();
        });

    get(
        "/series/*",
        (req, res) -> {
          return Kernel.getSeries().getPoints(getContext(req), getSeriesUriParam(req));
        },
        json());

    put(
        "/series/*",
        (req, res) -> {
          String uri = getSeriesUriParam(req);
          Map<String, Object> data = JacksonUtil.getMapFromJson(req.body());
          List<String> keys = (List<String>) data.get("keys");
          List<Object> values = (List<Object>) data.get("values");
          if (!values.isEmpty()) {
            Object obj = values.get(0);
            if (obj instanceof Long) {
              Kernel.getSeries()
                  .addLongsToSeries(getContext(req), uri, keys, (List<Long>) (List<?>) values);
            } else if (obj instanceof String) {
              Kernel.getSeries()
                  .addStringsToSeries(getContext(req), uri, keys, (List<String>) (List<?>) values);
            } else if (obj instanceof Double) {
              Kernel.getSeries()
                  .addDoublesToSeries(getContext(req), uri, keys, (List<Double>) (List<?>) values);
            } else {
              halt(400, "Unknown type in values parameter");
            }
          }
          return uri;
        });

    delete(
        "/series/:authority",
        (req, res) -> {
          Kernel.getSeries().deleteSeriesRepo(getContext(req), req.params(":authority"));
          return true;
        });

    delete(
        "/series/*",
        (req, res) -> {
          Kernel.getSeries().deleteSeries(getContext(req), getSeriesUriParam(req));
          return true;
        });

    post(
        "/workorder/*",
        (req, res) -> {
          Map<String, String> params = new HashMap<>();
          String body = req.body();
          if (StringUtils.isNotBlank(body)) {
            Map<String, Object> data = JacksonUtil.getMapFromJson(body);
            params = (Map<String, String>) data.get("params");
          }
          return Kernel.getDecision()
              .createWorkOrder(getContext(req), getWorkorderUriParam(req), params);
        });
  }
Ejemplo n.º 11
0
 HooksConfig readFromFile() {
   String json = ConfigLoader.getConf().DefaultApiHooks;
   return JacksonUtil.objectFromJson(json, HooksConfig.class);
 }
Ejemplo n.º 12
0
  @Override
  public String invoke(CallingContext ctx) {
    DecisionApi decision = Kernel.getDecision();
    String workOrderUri = new RaptureURI(getWorkerURI(), Scheme.WORKORDER).toShortString();
    String config =
        StringUtils.stripToNull(decision.getContextValue(ctx, workOrderUri, "CONFIGURATION"));

    try {
      decision.setContextLiteral(ctx, getWorkerURI(), "STEPNAME", getStepName());

      String docPath = new RaptureURI(workOrderUri).getDocPath();
      int lio = docPath.lastIndexOf('/');
      if (lio < 0) lio = 0;

      StringBuilder externalUrl = new StringBuilder();
      String host = System.getenv("HOST");
      String port = System.getenv("PORT");
      externalUrl
          .append("http://")
          .append((host != null) ? host : LOCALHOST)
          .append(":")
          .append((port != null) ? port : DEFAULT_RIM_PORT)
          .append("/process/")
          .append(docPath.substring(0, lio))
          .append(WORKORDER_DELIMETER)
          .append(docPath.substring(lio + 1));
      decision.setContextLiteral(
          ctx, workOrderUri, EXTERNAL_RIM_WORKORDER_URL, externalUrl.toString());

      Map<String, String> view = new HashMap<>();
      DocApi docApi = Kernel.getDoc();

      if (config == null) {
        decision.writeWorkflowAuditEntry(
            ctx, getWorkerURI(), "No configuration document specified", false);
        return this.getNextTransition();
      }
      List<String> configs;
      try {
        // Could be a list or a single entry.
        configs = JacksonUtil.objectFromJson(config, ArrayList.class);
      } catch (Exception e) {
        configs = ImmutableList.of(config);
      }

      for (String conf : configs) {
        if (docApi.docExists(ctx, conf)) {
          String doc = docApi.getDoc(ctx, conf);
          Map<String, Object> map = JacksonUtil.getMapFromJson(doc);
          for (Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = StringUtils.stripToNull(entry.getValue().toString());
            ContextValueType type = ContextValueType.getContextValueType(value.charAt(0));
            if (type == ContextValueType.NULL) {
              type = ContextValueType.LITERAL;
            } else value = value.substring(1);
            ExecutionContextUtil.setValueECF(ctx, workOrderUri, view, key, type, value);
            decision.writeWorkflowAuditEntry(
                ctx,
                getWorkerURI(),
                getStepName() + ": Read configuration data from " + conf,
                false);
          }
        } else {
          decision.writeWorkflowAuditEntry(
              ctx,
              getWorkerURI(),
              getStepName() + ": Cannot locate configuration document " + conf,
              true);
        }
      }
      return Steps.NEXT.toString();
    } catch (Exception e) {
      decision.setContextLiteral(
          ctx, getWorkerURI(), getStepName(), "Exception in workflow : " + e.getLocalizedMessage());
      decision.setContextLiteral(ctx, getWorkerURI(), getErrName(), ExceptionToString.summary(e));
      log.error(ExceptionToString.format(ExceptionToString.getRootCause(e)));
      decision.writeWorkflowAuditEntry(
          ctx,
          getWorkerURI(),
          "Problem in " + getStepName() + ": unable to read the configuration document " + config,
          true);
      decision.writeWorkflowAuditEntry(
          ctx,
          getWorkerURI(),
          ": " + ExceptionToString.getRootCause(e).getLocalizedMessage(),
          true);

      return getErrorTransition();
    }
  }
Ejemplo n.º 13
0
 public static ReflexValue deserialize(String json) throws ClassNotFoundException {
   Object x = JacksonUtil.objectFromJson(json, Object.class);
   return KernelExecutor.reconstructFromObject(x);
 }
 protected void addLatestToMetaStore(String latestKey, DocumentMetadata newMetaData) {
   metaStore.put(latestKey, JacksonUtil.jsonFromObject(newMetaData));
 }
Ejemplo n.º 15
0
 private static SMTPConfig getEmailConfig() {
   String configString =
       Kernel.getSys().retrieveSystemConfig(ContextFactory.getKernelUser(), "CONFIG", CONFIG_URI);
   return JacksonUtil.objectFromJson(configString, SMTPConfig.class);
 }