Example #1
0
 static {
     GsonBuilder builder = new GsonBuilder();
     builder.setPrettyPrinting();
     builder.registerTypeAdapterFactory(new LowerCaseEnumTypeAdapterFactory());
     builder.registerTypeAdapter(Date.class, new DateTypeAdapter());
     builder.enableComplexMapKeySerialization();
     mojangGson = builder.create();
     builder = new GsonBuilder();
     builder.setPrettyPrinting();
     gson = builder.create();
 }
Example #2
0
 /*
  * Finds recipe task for machine if it has been already created otherwise makes a new one and adds it into the DAG
  */
 private static RunRecipeTask makeRecipeTaskIfNotExist(
     String recipeName,
     MachineRuntime machine,
     ClusterStats clusterStats,
     JsonObject chefJson,
     TaskSubmitter submitter,
     String cookbookId,
     String cookbookName,
     Map<String, RunRecipeTask> allRecipeTasks,
     Dag dag)
     throws DagConstructionException {
   String recId = RunRecipeTask.makeUniqueId(machine.getId(), recipeName);
   RunRecipeTask runRecipeTask = allRecipeTasks.get(recId);
   if (!allRecipeTasks.containsKey(recId)) {
     ChefJsonGenerator.addRunListForRecipe(chefJson, recipeName);
     GsonBuilder builder = new GsonBuilder();
     builder.disableHtmlEscaping();
     Gson gson = builder.setPrettyPrinting().create();
     String jsonString = gson.toJson(chefJson);
     runRecipeTask =
         new RunRecipeTask(
             machine, clusterStats, recipeName, jsonString, submitter, cookbookId, cookbookName);
     dag.addTask(runRecipeTask);
   }
   allRecipeTasks.put(recId, runRecipeTask);
   return runRecipeTask;
 }
Example #3
0
  private Note getNote(String key) throws IOException {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.setPrettyPrinting();
    Gson gson =
        gsonBuilder.registerTypeAdapter(Date.class, new NotebookImportDeserializer()).create();

    S3Object s3object;
    try {
      s3object = s3client.getObject(new GetObjectRequest(bucketName, key));
    } catch (AmazonClientException ace) {
      throw new IOException("Unable to retrieve object from S3: " + ace, ace);
    }

    Note note;
    try (InputStream ins = s3object.getObjectContent()) {
      String json = IOUtils.toString(ins, conf.getString(ConfVars.ZEPPELIN_ENCODING));
      note = gson.fromJson(json, Note.class);
    }

    for (Paragraph p : note.getParagraphs()) {
      if (p.getStatus() == Status.PENDING || p.getStatus() == Status.RUNNING) {
        p.setStatus(Status.ABORT);
      }
    }

    return note;
  }
  /**
   * import JSON as a new note.
   *
   * @param sourceJson - the note JSON to import
   * @param noteName - the name of the new note
   * @return notebook ID
   * @throws IOException
   */
  public Note importNote(String sourceJson, String noteName, AuthenticationInfo subject)
      throws IOException {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.setPrettyPrinting();

    Gson gson =
        gsonBuilder.registerTypeAdapter(Date.class, new NotebookImportDeserializer()).create();
    JsonReader reader = new JsonReader(new StringReader(sourceJson));
    reader.setLenient(true);
    Note newNote;
    try {
      Note oldNote = gson.fromJson(reader, Note.class);
      newNote = createNote(subject);
      if (noteName != null) newNote.setName(noteName);
      else newNote.setName(oldNote.getName());
      List<Paragraph> paragraphs = oldNote.getParagraphs();
      for (Paragraph p : paragraphs) {
        newNote.addCloneParagraph(p);
      }

      newNote.persist(subject);
    } catch (IOException e) {
      logger.error(e.toString(), e);
      throw e;
    }

    return newNote;
  }
 /**
  * Export existing note.
  *
  * @param noteId - the note ID to clone
  * @return Note JSON
  * @throws IOException, IllegalArgumentException
  */
 public String exportNote(String noteId) throws IOException, IllegalArgumentException {
   GsonBuilder gsonBuilder = new GsonBuilder();
   gsonBuilder.setPrettyPrinting();
   Gson gson = gsonBuilder.create();
   Note note = getNote(noteId);
   if (note == null) {
     throw new IllegalArgumentException(noteId + " not found");
   }
   return gson.toJson(note);
 }
 public String getInfoJson() {
   if (json == null) {
     CookbookInfoJson cookbookInfoJson = new CookbookInfoJson(urls.id, metadataRb);
     GsonBuilder builder = new GsonBuilder();
     builder.disableHtmlEscaping();
     Gson gson = builder.setPrettyPrinting().create();
     json = gson.toJson(cookbookInfoJson);
   }
   return json;
 }
Example #7
0
  /** start a new game */
  public Game(String name, Difficulty difficulty) throws Exception {
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeAdapterFactory(new LowercaseEnumTypeAdapterFactory());
    gson = builder.setPrettyPrinting().create();

    // order important: fetch exercises for name, then set difficulty to refresh
    setName(name);
    fetchMaterials();
    fetchExercises();
    setDifficulty(difficulty);
  }
Example #8
0
  public static void main(String args[]) {
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeAdapter(Student.class, new StudentAdapter());
    builder.setPrettyPrinting();
    Gson gson = builder.create();

    String jsonString = "{\"name\":\"Mahesh\", \"rollNo\":1}";

    Student student = gson.fromJson(jsonString, Student.class);
    System.out.println(student);
    jsonString = gson.toJson(student);
    System.out.println(jsonString);
  }
Example #9
0
 private static String encode(Map<String, Object> m) {
   try {
     Gson gson;
     final GsonBuilder builder = new GsonBuilder();
     builder.registerTypeAdapterFactory(new EnumAdaptorFactory());
     builder.registerTypeAdapter(Date.class, new DateAdapter());
     builder.registerTypeAdapter(File.class, new FileAdapter());
     builder.enableComplexMapKeySerialization();
     builder.setPrettyPrinting();
     gson = builder.create();
     return gson.toJson(m);
   } catch (Exception e) {
     Logger.logError("Error encoding Authlib JSON", e);
     return null;
   }
 }
Example #10
0
  @Override
  public List<ShellCommand> getCommands() throws IOException {

    Set<JsonElement> paramsToMerge = DagParams.getGlobalParams();
    if (paramsToMerge != null) {
      try {
        // Merge in Global return results into the json file.
        JsonElement obj = new JsonParser().parse(json);
        if (obj.isJsonObject()) {
          JsonObject jsonObj = obj.getAsJsonObject();

          for (JsonElement param : paramsToMerge) {
            if (param.isJsonObject()) {
              JsonObject paramObj = param.getAsJsonObject();
              merge(jsonObj, paramObj);
            }
          }
          GsonBuilder builder = new GsonBuilder();
          builder.disableHtmlEscaping();
          Gson gson = builder.setPrettyPrinting().create();
          json = gson.toJson(jsonObj);
        } else {
          logger.warn(String.format("Invalid json object for chef-solo: \n %s'", json));
        }
      } catch (JsonIOException | JsonSyntaxException ex) {
        logger.warn(
            String.format("Invalid return value as Json object: %s \n %s'", ex.toString(), json));
      }
    }

    if (commands == null) {
      String jsonFileName = recipeCanonicalName.replaceAll(Settings.COOOKBOOK_DELIMITER, "__");
      commands =
          ShellCommandBuilder.fileScript2Commands(
              Settings.SCRIPT_PATH_RUN_RECIPE,
              "chef_json",
              json,
              "json_file_name",
              jsonFileName,
              "log_file_name",
              jsonFileName,
              "sudo_command",
              ClusterService.getInstance().getCommonContext().getSudoCommand());
    }
    return commands;
  }
 @PostConstruct
 public void init() {
   monitoringService = (ActorRef) context.getAttribute(MonitoringService.class.getName());
   configuration = (Configuration) context.getAttribute(Configuration.class.getName());
   configuration = configuration.subset("runtime-settings");
   daos = (DaoManager) context.getAttribute(DaoManager.class.getName());
   super.init(configuration);
   CallinfoConverter converter = new CallinfoConverter(configuration);
   MonitoringServiceConverter listConverter = new MonitoringServiceConverter(configuration);
   builder = new GsonBuilder();
   builder.registerTypeAdapter(CallInfo.class, converter);
   builder.registerTypeAdapter(MonitoringServiceResponse.class, listConverter);
   builder.setPrettyPrinting();
   gson = builder.create();
   xstream = new XStream();
   xstream.alias("RestcommResponse", RestCommResponse.class);
   xstream.registerConverter(converter);
   xstream.registerConverter(listConverter);
   xstream.registerConverter(new RestCommResponseConverter(configuration));
 }
Example #12
0
  @Override
  public void save(Note note, AuthenticationInfo subject) throws IOException {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.setPrettyPrinting();
    Gson gson = gsonBuilder.create();
    String json = gson.toJson(note);
    String key = user + "/" + "notebook" + "/" + note.getId() + "/" + "note.json";

    File file = File.createTempFile("note", "json");
    try {
      Writer writer = new OutputStreamWriter(new FileOutputStream(file));
      writer.write(json);
      writer.close();
      s3client.putObject(new PutObjectRequest(bucketName, key, file));
    } catch (AmazonClientException ace) {
      throw new IOException("Unable to store note in S3: " + ace, ace);
    } finally {
      FileUtils.deleteQuietly(file);
    }
  }
Example #13
0
  /** Saves the state of the current settings to a file. */
  public static void saveToFile() {
    // Create a map of fields, indexed on categories then names.
    // Those are sorted maps, to preserve alphabetical order.
    SortedMap<String, SortedMap<String, Object>> categories = new TreeMap<>();

    for (Field field : getSettableFields()) {
      // Retrieve the field info.
      SettingsField fieldInfo = field.getAnnotation(SettingsField.class);

      // Create a category map, if it doesn't exist.
      SortedMap<String, Object> category;
      if (categories.containsKey(fieldInfo.category())) {
        category = categories.get(fieldInfo.category());
      } else {
        category = new TreeMap<>();
        categories.put(fieldInfo.category(), category);
      }

      // If the name wasn't set, get the field's declared name.
      String actualName = fieldInfo.name().isEmpty() ? field.getName() : fieldInfo.name();

      // Put the field and its value, as a string.
      category.put(actualName, get(field).toString());
    }

    // Export the result to a json file.
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.setPrettyPrinting();
    Gson gson = gsonBuilder.create();
    String jsonString = gson.toJson(categories);

    // Write to file.
    try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("settings.json"))) {
      bufferedWriter.write(jsonString);
    } catch (IOException ex) {
      // If the file can't be written, it's an error.
      Logger.getLogger(SettingsHandler.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
Example #14
0
  @PostConstruct
  public void init() {
    configuration = (Configuration) context.getAttribute(Configuration.class.getName());
    configuration = configuration.subset("runtime-settings");
    callManager =
        (ActorRef) context.getAttribute("org.mobicents.servlet.restcomm.telephony.CallManager");
    daos = (DaoManager) context.getAttribute(DaoManager.class.getName());
    super.init(configuration);
    CallDetailRecordConverter converter = new CallDetailRecordConverter(configuration);
    listConverter = new CallDetailRecordListConverter(configuration);
    builder = new GsonBuilder();
    builder.registerTypeAdapter(CallDetailRecord.class, converter);
    builder.registerTypeAdapter(CallDetailRecordList.class, listConverter);
    builder.setPrettyPrinting();
    gson = builder.create();
    xstream = new XStream();
    xstream.alias("RestcommResponse", RestCommResponse.class);
    xstream.registerConverter(converter);
    xstream.registerConverter(new RestCommResponseConverter(configuration));
    xstream.registerConverter(listConverter);

    normalizePhoneNumbers = configuration.getBoolean("normalize-numbers-for-outbound-calls");
  }
Example #15
0
  @RequestMapping("/view-data")
  public void viewJSON(HttpServletRequest request, HttpServletResponse res) {

    String query = request.getParameter("q");
    if (null == query || query.trim().length() == 0) query = null;
    String depthStr = request.getParameter("d");
    int depth = 1;
    try {
      depth = Integer.parseInt(depthStr);
      // check boundaries [1, 5]
      if (depth < 1 || depth > 5) depth = 1;

    } catch (Exception ex) {

    }

    Set<Connected> eList = new HashSet<Connected>();
    Network net = new Network();
    if (null != query) {
      try {
        Storage storage = NMSServerConfig.getInstance().getStorage(request.getParameter("storage"));
        if (null == storage) {
          logger.error("storage is not defined");
          return;
        }

        net = (Network) request.getSession().getAttribute(query);
        if (null == net) {
          net = storage.query(query);
        } else {
          request.getSession().removeAttribute(query);
        }

        String[] entities = net.getIds();

        for (String eid : entities) {
          doDepthView(net.getById(eid), eList, depth);
        }
      } catch (NQLException e) {
        logger.error("Wrong NQL query " + query, e);
      } catch (StorageException e) {
        logger.error("Can't execute query " + query, e);
      }
    } else {
      logger.error("No NQL query");
    }

    List<Node> nodes = adaptNodes(eList, net);

    GsonBuilder gb = new GsonBuilder();
    Gson gson = gb.setPrettyPrinting().create();

    String jsonStr = gson.toJson(nodes);
    res.setContentType("application/json");

    logger.debug("JSON: " + jsonStr);
    //		System.out.println(jsonStr);
    try {
      res.getWriter().write(jsonStr);
    } catch (IOException e) {
      logger.error("Can't write JSON string to output stream", e);
    }
    return;
  }
Example #16
0
 public static Gson prettyWithExpose() {
   GsonBuilder builder = new GsonBuilder();
   builder.setPrettyPrinting().excludeFieldsWithoutExposeAnnotation();
   return builder.create();
 }
Example #17
0
	static {
		GsonBuilder builder = new GsonBuilder();
		builder.setPrettyPrinting();
		gson = builder.create();
	}