YAMLUtils.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.json;

  23. import java.io.Serializable;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.TimeZone;
  28. import java.util.regex.Matcher;
  29. import java.util.regex.Pattern;

  31. import org.openspcoop2.utils.SemaphoreLock;
  32. import org.openspcoop2.utils.UtilsException;
  33. import org.slf4j.Logger;

  35. import com.fasterxml.jackson.annotation.JsonInclude.Include;
  36. import com.fasterxml.jackson.databind.ObjectMapper;
  37. import com.fasterxml.jackson.databind.ObjectWriter;
  38. import com.fasterxml.jackson.databind.SerializationFeature;
  39. import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
  40. import com.fasterxml.jackson.datatype.joda.JodaModule;
  41. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

  43. /** 
  44.  * YAMLUtils
  45.  *
  46.  * @author Poli Andrea (apoli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class YAMLUtils extends AbstractUtils {
  51.     
  52.     static {
  53.         YamlSnakeLimits.initialize();
  54.     }
  55.     
  56.     private static YAMLUtils yamlUtils = null;
  57.     private static YAMLUtils yamlUtilsPretty = null;
  58.     private static synchronized void init(boolean prettyPrint){
  59.         if(prettyPrint) {
  60.             if(YAMLUtils.yamlUtilsPretty==null){
  61.                 YAMLUtils.yamlUtilsPretty = new YAMLUtils(true);
  62.             }
  63.         }
  64.         else {
  65.             if(YAMLUtils.yamlUtils==null){
  66.                 YAMLUtils.yamlUtils = new YAMLUtils(false);
  67.             }
  68.         }
  69.     }
  70.     public static YAMLUtils getInstance(){
  71.         return getInstance(false);
  72.     }
  73.     public static YAMLUtils getInstance(boolean prettyPrint){
  74.         if(prettyPrint) {
  75.             if(YAMLUtils.yamlUtilsPretty==null){
  76.                 // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED'
  77.                 synchronized (YAMLUtils.class) {
  78.                     YAMLUtils.init(true);
  79.                 }
  80.             }
  81.             return YAMLUtils.yamlUtilsPretty;
  82.         }
  83.         else {
  84.             if(YAMLUtils.yamlUtils==null){
  85.                 // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED'
  86.                 synchronized (YAMLUtils.class) {
  87.                     YAMLUtils.init(false);
  88.                 }
  89.             }
  90.             return YAMLUtils.yamlUtils;
  91.         }
  92.     }
  93.     

  95.     private static org.openspcoop2.utils.Semaphore semaphore = new org.openspcoop2.utils.Semaphore("JSONUtils");
  96.     private static YAMLMapper internalMapper;
  97.     private static synchronized void initMapper()  {
  98.         SemaphoreLock lock = semaphore.acquireThrowRuntime("initMapper");
  99.         try {
  100.             if(internalMapper==null){
  101.                 internalMapper = new YAMLMapper();
  102.                 internalMapper.setTimeZone(TimeZone.getDefault());
  103.                 internalMapper.setSerializationInclusion(Include.NON_NULL);
  104.                 internalMapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
  105.                 internalMapper.configure(com.fasterxml.jackson.databind.SerializationFeature.
  106.                         WRITE_DATES_AS_TIMESTAMPS , false);
  107.                 // Since 2.1.4, the field exampleSetFlag appears in json produced with ObjectMapper#writeValue(File, Object) when serializing an object of type OpenApi.
  108.                 // "exampleSetFlag" : false
  109.                 // Con il codice sottostante, nelle classi Mixin l'attributo 'getExampleSetFlag' viene ignorato
  110.                 internalMapper.addMixIn(io.swagger.v3.oas.models.media.Schema.class, io.swagger.v3.core.jackson.mixin.SchemaMixin.class);
  111.                 internalMapper.addMixIn(io.swagger.v3.oas.models.media.MediaType.class, io.swagger.v3.core.jackson.mixin.MediaTypeMixin.class);
  112.             }
  113.         }finally {
  114.             semaphore.release(lock, "initMapper");
  115.         }
  116.     }
  117.     public static void setMapperTimeZone(TimeZone timeZone) {
  118.         if(internalMapper==null){
  119.             initMapper();
  120.         }
  121.         SemaphoreLock lock = semaphore.acquireThrowRuntime("setMapperTimeZone");
  122.         try {
  123.             internalMapper.setTimeZone(timeZone);
  124.         }finally {
  125.             semaphore.release(lock, "setMapperTimeZone");
  126.         }
  127.     }
  128.     public static void registerJodaModule() {
  129.         if(internalMapper==null){
  130.             initMapper();
  131.         }
  132.         SemaphoreLock lock = semaphore.acquireThrowRuntime("registerJodaModule");
  133.         try {
  134.             internalMapper.registerModule(new JodaModule());
  135.         }finally {
  136.             semaphore.release(lock, "registerJodaModule");
  137.         }
  138.     }
  139.     public static void registerJavaTimeModule() {
  140.         if(internalMapper==null){
  141.             initMapper();
  142.         }
  143.         SemaphoreLock lock = semaphore.acquireThrowRuntime("registerJavaTimeModule");
  144.         try {
  145.             internalMapper.registerModule(new JavaTimeModule());
  146.         }finally {
  147.             semaphore.release(lock, "registerJavaTimeModule");
  148.         }
  149.     }
  150.     
  151.     public static YAMLMapper getObjectMapper() {
  152.         if(internalMapper==null){
  153.             initMapper();
  154.         }
  155.         return internalMapper;
  156.     }
  157.     
  158.     private static ObjectWriter writer;
  159.     private static synchronized void initWriter()  {
  160.         if(internalMapper==null){
  161.             initMapper();
  162.         }
  163.         if(writer==null){
  164.             writer = internalMapper.writer();
  165.         }
  166.     }
  167.     public static ObjectWriter getObjectWriter() {
  168.         if(writer==null){
  169.             initWriter();
  170.         }
  171.         return writer;
  172.     }
  173.     
  174.     private static ObjectWriter writerPrettyPrint;
  175.     private static synchronized void initWriterPrettyPrint()  {
  176.         if(internalMapper==null){
  177.             initMapper();
  178.         }
  179.         if(writerPrettyPrint==null){
  180.             writerPrettyPrint = internalMapper.writer().withDefaultPrettyPrinter();
  181.         }
  182.     }
  183.     public static ObjectWriter getObjectWriterPrettyPrint() {
  184.         if(writerPrettyPrint==null){
  185.             initWriterPrettyPrint();
  186.         }
  187.         return writerPrettyPrint;
  188.     }
  189.     
  190.     
  191.     
  192.     private YAMLUtils(boolean prettyPrint) {
  193.         super(prettyPrint);
  194.     }
  195.     
  196.     @Override
  197.     protected void _initMapper() {
  198.         initMapper();
  199.     }
  200.     @Override
  201.     protected void _initWriter(boolean prettyPrint) {
  202.         if(prettyPrint) { 
  203.             initWriterPrettyPrint();
  204.         }
  205.         else {
  206.             initWriter();
  207.         }
  208.     }
  209.     
  210.     @Override
  211.     protected ObjectMapper _getObjectMapper() {
  212.         return getObjectMapper();
  213.     }
  214.     @Override
  215.     protected ObjectWriter _getObjectWriter(boolean prettyPrint) {
  216.         if(prettyPrint) { 
  217.             return getObjectWriterPrettyPrint();
  218.         }
  219.         else {
  220.             return getObjectWriter();
  221.         }
  222.     }
  223.     
  224.     
  225.     // IS
  226.     
  227.     public boolean isYaml(byte[]jsonBytes){
  228.         return !JSONUtils.getInstance().isJson(jsonBytes) && this.isValid(jsonBytes);
  229.     }
  230.     
  231.     public boolean isYaml(String jsonString){
  232.         return !JSONUtils.getInstance().isJson(jsonString) && this.isValid(jsonString);
  233.     }
  234.     
  235.     
  236.     // UTILS per ANCHOR
  237.     
  238.     public static boolean containsKeyAnchor(String yaml) {
  239.         return containsMergeKeyAnchor(yaml) || containsRefKeyAnchor(yaml);
  240.     }
  241.     public static boolean containsMergeKeyAnchor(String yaml) {
  242.         return yaml!=null && yaml.contains("<<: *");
  243.     }
  244.     public static boolean containsRefKeyAnchor(String yaml) {
  245.         return yaml!=null && yaml.contains(" *") && yaml.contains(" &");
  246.     }
  247.     
  248.     public static String resolveMergeKeyAndConvertToJson(String yaml) throws UtilsException {
  249.         return resolveMergeKeyAndConvertToJson(yaml, JSONUtils.getInstance());
  250.     }
  251.     public static String resolveMergeKeyAndConvertToJson(String yaml, JSONUtils jsonUtils) throws UtilsException {
  252.         return  resolveAnchorAndConvertToJson(yaml, jsonUtils, false);
  253.     }
  254.     public static String resolveKeyAnchorAndConvertToJson(String yaml) throws UtilsException {
  255.         return resolveKeyAnchorAndConvertToJson(yaml, JSONUtils.getInstance());
  256.     }
  257.     public static String resolveKeyAnchorAndConvertToJson(String yaml, JSONUtils jsonUtils) throws UtilsException {
  258.         return  resolveAnchorAndConvertToJson(yaml, jsonUtils, true);
  259.     }
  260.     private static String resolveAnchorAndConvertToJson(String yaml, JSONUtils jsonUtils, boolean resolveAllAnchor) throws UtilsException {
  261.         // Fix merge key '<<: *'
  262.         // La funzionalità di merge key è supportata fino allo yaml 1.1 (https://ktomk.github.io/writing/yaml-anchor-alias-and-merge-key.html)
  263.         // Mentre OpenAPI dice di usare preferibilmente YAML 1.2 (https://swagger.io/specification/):
  264.         //   "n order to preserve the ability to round-trip between YAML and JSON formats, YAML version 1.2 is RECOMMENDED"
  265.         // Inoltre le anchor utilizzate nelle merge key non sono supportate correttamente in jackson:
  266.         //   https://github.com/FasterXML/jackson-dataformats-text/issues/98
  267.         // Mentre vengono gestite correttamente da snake (https://linuxtut.com/convert-json-and-yaml-in-java-(using-jackson-and-snakeyaml)-0ad0a/)
  268.         // Come fix quindi nel caso siano presenti viene fatta una serializzazione tramite snake che le risolve.
  269.         boolean contains = resolveAllAnchor ? containsKeyAnchor(yaml) : containsMergeKeyAnchor(yaml);
  270.         if(contains) {
  271.             // Risoluzione merge key '<<: *'
  272.             Map<String, Object> obj = new org.yaml.snakeyaml.Yaml().load(yaml);
  273.             /**System.out.println("COSTRUITO ["+jsonUtils.toString(obj)+"]");*/
  274.             return jsonUtils.toString(obj); // jsonRepresentation
  275.         }
  276.         return null;
  277.     }
  278.     
  279.     
  280.     /** UTILS per tipi vuoi schema: {} */
  281.     
  282.     // Fix: 1620
  283.     public static boolean containsEmptySchema(String yaml) {
  284.         String pattern = "(?m)^([ \\t]*)schema\\s*:\\s*\\{\\s*\\}\\s*$";
  285.         try {
  286.             Pattern p = Pattern.compile(pattern);
  287.             Matcher matcher = p.matcher(yaml);
  288.             return matcher.find();
  289.         }catch(Exception e) {
  290.             return false;
  291.         }
  292.     }
  293.     public static String resolveEmptySchema(String yaml) {
  294.          // Regex: trova righe con "schema: {}" e sostituisce con due righe correttamente indentate
  295.         return yaml.replaceAll("(?m)^([ \\t]*)schema:\\s*\\{\\s*\\}", "$1schema:\n$1  type: string");
  296.     }
  297.     
  298.     // CONVERT TO MAP 
  299.     
  300.     public Map<String, Serializable> convertToMap(Logger log, String source, String raw) {
  301.         return this.convertToMap(log, source, raw, null);
  302.     }
  303.     public Map<String, Serializable> convertToMap(Logger log, String source, String raw, List<String> claimsToConvert) {
  304.         if(this.isYaml(raw)) {
  305.             return super.convertToMapEngine(log, source, raw, claimsToConvert);
  306.         }
  307.         else {
  308.             return new HashMap<>(); // empty return
  309.         }   
  310.     }
  311.     
  312.     public Map<String, Serializable> convertToMap(Logger log, String source, byte[]raw) {
  313.         return this.convertToMap(log, source, raw, null);
  314.     }
  315.     public Map<String, Serializable> convertToMap(Logger log, String source, byte[]raw, List<String> claimsToConvert) {
  316.         if(this.isYaml(raw)) {
  317.             return super.convertToMapEngine(log, source, raw, claimsToConvert);
  318.         }
  319.         else {
  320.             return new HashMap<>(); // empty return
  321.         }   
  322.     }
  323. }
Created with JaCoCo 0.8.8.202204050719