HazelcastManager.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.  */
  20. package org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast;

  22. import java.io.ByteArrayInputStream;
  23. import java.io.File;
  24. import java.io.FileInputStream;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
  32. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  33. import org.openspcoop2.utils.Utilities;
  34. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  35. import org.openspcoop2.utils.json.JsonPathNotFoundException;
  36. import org.openspcoop2.utils.json.YAMLUtils;
  37. import org.openspcoop2.utils.resources.Charset;
  38. import org.openspcoop2.utils.resources.FileSystemUtilities;
  39. import org.slf4j.Logger;

  41. import com.fasterxml.jackson.databind.JsonNode;
  42. import com.hazelcast.config.Config;
  43. import com.hazelcast.config.InMemoryYamlConfig;
  44. import com.hazelcast.config.NetworkConfig;
  45. import com.hazelcast.config.YamlConfigBuilder;
  46. import com.hazelcast.core.Hazelcast;
  47. import com.hazelcast.core.HazelcastInstance;

  49. /**     
  50.  *  HazelcastManager
  51.  *
  52.  * @author Francesco Scarlato (scarlato@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */
  56. public class HazelcastManager {

  58.     private static String GOVWAY_INSTANCE_PORT = "GOVWAY_INSTANCE_PORT";
  59.     
  60.     public static Map<PolicyGroupByActiveThreadsType, HazelcastInstance> staticMapInstance = null;
  61.     private static Map<PolicyGroupByActiveThreadsType,String> staticMapConfig = null;
  62.     private static String groupId;
  63.     
  64.     private static YAMLUtils yamlUtils = null;
  65.     private static JsonPathExpressionEngine engine = null;
  66.     
  67.     private static JsonNode sharedConfigNode;
  68.     private static File shareConfigFile;
  69.     
  70.     private static Logger logStartup;
  71.     private static Logger log;
  72.     
  73.     public static synchronized void initialize(Logger logStartup, Logger log, Map<PolicyGroupByActiveThreadsType,String> config, String groupId, File shareConfigFile) throws Exception {
  74.         
  75.         if(HazelcastManager.staticMapInstance==null){
  76.         
  77.             /*
  78.              * This configuration disables the shutdown hook in hazelcast, which ensures that the hazelcast instance shuts down gracefully whenever the product node shuts down. 
  79.              * If the hazelcast shutdown hook is enabled (which is the default behavior of a product), 
  80.              * you will see errors such as " Hazelcast instance is not active! " at the time of shutting down the product node: 
  81.              * This is because the hazelcast instance shuts down too early when the shutdown hook is enabled.
  82.              **/
  83.             System.setProperty("hazelcast.shutdownhook.enabled","false");
  84.     
  85.             /*
  86.              * This configuration sets the hazelcast logging type to log4j2, which allows hazelcast logs to be written to the govway_hazelcast.log file.
  87.              **/
  88.             System.setProperty("hazelcast.logging.type", "log4j2");
  89.             
  90.             
  91.             HazelcastManager.staticMapInstance = new HashMap<PolicyGroupByActiveThreadsType, HazelcastInstance>();
  92.             HazelcastManager.staticMapConfig = new HashMap<PolicyGroupByActiveThreadsType, String>();
  93.             HazelcastManager.groupId = groupId;
  94.             HazelcastManager.logStartup = logStartup;
  95.             HazelcastManager.log = log;
  96.                         
  97.             if(shareConfigFile!=null) {
  98.                 
  99.                 HazelcastManager.shareConfigFile = shareConfigFile;
  100.                 HazelcastManager.yamlUtils = YAMLUtils.getInstance();
  101.                 HazelcastManager.engine = new JsonPathExpressionEngine();
  102.                 
  103.                 String sharedContentBytes = FileSystemUtilities.readFile(shareConfigFile); 
  104.                 
  105.                 try {
  106.                     HazelcastManager.sharedConfigNode = yamlUtils.getAsNode(sharedContentBytes.getBytes());
  107.                 }catch(Throwable t) {
  108.                     throw new PolicyException("Configuration '"+shareConfigFile.getAbsolutePath()+"' is not valid yaml config: "+t.getMessage()+"\n"+sharedContentBytes,t);
  109.                 }
  110.                 Config sharedConfig = null;
  111.                 try {
  112.                     // La valido ma poi la ricostruiro' tutte le volte per poi sostituire la porta
  113.                     try(ByteArrayInputStream bin = new ByteArrayInputStream(sharedContentBytes.getBytes())){
  114.                         YamlConfigBuilder builder = new  YamlConfigBuilder(bin);
  115.                         sharedConfig = builder.build();
  116.                     }
  117.                 }catch(Throwable t) {
  118.                     throw new PolicyException("Configuration '"+shareConfigFile.getAbsolutePath()+"' is not valid yaml config (YamlConfigBuilder): "+t.getMessage()+"\n"+sharedContentBytes,t);
  119.                 }
  120.             
  121.                 if(sharedConfig!=null && 
  122.                         sharedConfig.getClusterName()!=null && 
  123.                         StringUtils.isNotEmpty(sharedConfig.getClusterName())) {
  124.                     // Se definita sovrascrive il valore indicato nella proprietà 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.group_id' in govway_local.properties
  125.                     // passato come parametro 'groupId'
  126.                     HazelcastManager.groupId = sharedConfig.getClusterName();
  127.                 }
  128.             }
  129.             
  130.             if(config!=null && !config.isEmpty()) {
  131.                 for (PolicyGroupByActiveThreadsType type : config.keySet()) {
  132.                     String pathConfig = config.get(type);
  133.                     String content = null;
  134.                     if(pathConfig != null) {
  135.                         File hazelcastConfigFile = new File(pathConfig);
  136.                         if(!hazelcastConfigFile.exists()) {
  137.                             //consento di definire la proprietà senza che sia presente il file
  138.                             //throw new Exception("Hazelcast file config ["+hazelcastConfigFile.getAbsolutePath()+"] not exists");
  139.                         }
  140.                         else {
  141.                             if(!hazelcastConfigFile.canRead()) {
  142.                                 throw new Exception("Hazelcast (type:"+type+") file config ["+hazelcastConfigFile.getAbsolutePath()+"] cannot read");
  143.                             }
  144.                             content = FileSystemUtilities.readFile(hazelcastConfigFile);
  145.                         }
  146.                     }
  147.                     if(content==null) {
  148.                         // default
  149.                         String name = "";
  150.                         switch (type) {
  151.                         case HAZELCAST_MAP:
  152.                             name = "govway.hazelcast-map.yaml";
  153.                             break;
  154.                         case HAZELCAST_NEAR_CACHE:
  155.                             name = "govway.hazelcast-near-cache.yaml";
  156.                             break;
  157.                         case HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP:
  158.                             name = "govway.hazelcast-near-cache-unsafe-sync-map.yaml";
  159.                             break;
  160.                         case HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP:
  161.                             name = "govway.hazelcast-near-cache-unsafe-async-map.yaml";
  162.                             break;
  163.                         case HAZELCAST_LOCAL_CACHE:
  164.                             name = "govway.hazelcast-local-cache.yaml";
  165.                             break;
  166.                         case HAZELCAST_REPLICATED_MAP:
  167.                             name= "govway.hazelcast-replicated-map.yaml";
  168.                             break;
  169.                         case HAZELCAST_ATOMIC_LONG:
  170.                             name = "govway.hazelcast-atomic-long-counters.yaml";
  171.                             break;
  172.                         case HAZELCAST_ATOMIC_LONG_ASYNC:
  173.                             name = "govway.hazelcast-atomic-long-async-counters.yaml";
  174.                             break;
  175.                         case HAZELCAST_PNCOUNTER:
  176.                             name = "govway.hazelcast-pn-counters.yaml";
  177.                             break;
  178.                         default:
  179.                             throw new Exception("Hazelcast type '"+type+"' unsupported");
  180.                         }
  181.                         content = Utilities.getAsString(HazelcastManager.class.getResourceAsStream("/"+name),Charset.UTF_8.getValue());
  182.                     }
  183.                     if(content==null) {
  184.                         throw new Exception("Hazelcast (type:"+type+") config undefined");
  185.                     }
  186.                     else {
  187.                         HazelcastManager.staticMapConfig.put(type, content);
  188.                     }
  189.                 }
  190.             }

  192.         }
  193.     }
  194.     
  195.     
  196.     public static List<PolicyGroupByActiveThreadsType> getTipiGestoriHazelcastAttivi() throws PolicyException{
  197.         if(staticMapInstance==null){
  198.             throw new PolicyException("Nessun gestore Hazelcast inizializzato");
  199.         }
  200.         List<PolicyGroupByActiveThreadsType> l = new ArrayList<PolicyGroupByActiveThreadsType>();
  201.         l.addAll(staticMapInstance.keySet());
  202.         return l;
  203.     }
  204.     
  205.     public static boolean isAttivo(PolicyGroupByActiveThreadsType type) {
  206.         if(staticMapInstance==null){
  207.             return false;
  208.         }
  209.         return staticMapInstance.containsKey(type);
  210.     }
  211.     
  212.     public static HazelcastInstance getInstance(PolicyGroupByActiveThreadsType type) throws PolicyException{
  213.         if(staticMapInstance==null){
  214.             throw new PolicyException("Nessun gestore Hazelcast inizializzato");
  215.         }
  216.         HazelcastInstance gestore = staticMapInstance.get(type);
  217.         if(gestore==null) {
  218.             HazelcastManager.initialize(type);
  219.             gestore = staticMapInstance.get(type);
  220.         }
  221.         if(gestore==null) {
  222.             throw new PolicyException("Gestore Hazelcast '"+type+"' non inizializzato ??");
  223.         }
  224.         return gestore;
  225.     }
  226.     
  227.     private static synchronized void initialize(PolicyGroupByActiveThreadsType type) throws PolicyException{
  228.         if(!HazelcastManager.staticMapInstance.containsKey(type)) {
  229.             
  230.             info("Inizializzazione Gestore Hazelcast '"+type+"' ...");
  231.             
  232.             HazelcastManager.staticMapInstance.put(type, newInstance(type));
  233.             
  234.             info("Inizializzazione Gestore Hazelcast '"+type+"' effettuata con successo");
  235.             
  236.         }
  237.     }   
  238.     
  239.     private static synchronized HazelcastInstance newInstance(PolicyGroupByActiveThreadsType type) throws PolicyException {
  240.         
  241.         String content = HazelcastManager.staticMapConfig.get(type);
  242.         if(content==null) {
  243.             throw new PolicyException("Hazelcast config undefined for type '"+type+"'");
  244.         }
  245.         
  246.         String groupId = null;
  247.         switch (type) {
  248.         case HAZELCAST_MAP:
  249.             groupId = HazelcastManager.groupId+"-map";
  250.             break;
  251.         case HAZELCAST_NEAR_CACHE:
  252.             groupId = HazelcastManager.groupId+"-near-cache";
  253.             break;
  254.         case HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP:
  255.             groupId = HazelcastManager.groupId+"-near-cache-unsafe-sync-map";
  256.             break;
  257.         case HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP:
  258.             groupId = HazelcastManager.groupId+"-near-cache-unsafe-async-map";
  259.             break;
  260.         case HAZELCAST_LOCAL_CACHE:
  261.             groupId = HazelcastManager.groupId+"-local-cache";
  262.             break;
  263.         case HAZELCAST_REPLICATED_MAP:
  264.             groupId = HazelcastManager.groupId+"-replicated-map"; 
  265.             break;
  266.         case HAZELCAST_PNCOUNTER:
  267.             groupId = HazelcastManager.groupId+"-pncounter";
  268.             break;
  269.         case HAZELCAST_ATOMIC_LONG:
  270.             groupId = HazelcastManager.groupId+"-atomic-long";
  271.             break;
  272.         case HAZELCAST_ATOMIC_LONG_ASYNC:
  273.             groupId = HazelcastManager.groupId+"-atomic-long-async";
  274.             break;
  275.         default:
  276.             throw new PolicyException("Hazelcast type '"+type+"' unsupported");
  277.         }
  278.         
  279.         content = content.replace("cluster-name:", "cluster-name: "+groupId+"\n#cluster-name:");
  280.         
  281.         debug("Inizializzo hazelcast con la seguente configurazione (cluster-id"+groupId+"): " + content);
  282.         
  283.         InMemoryYamlConfig hazelcastConfig = new InMemoryYamlConfig(content);
  284.         hazelcastConfig.setClusterName(groupId);
  285.         setNetwork(hazelcastConfig, content, groupId);
  286.         
  287.         HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(hazelcastConfig);
  288.         if(hazelcast==null) {
  289.             throw new PolicyException("Hazelcast init failed");
  290.         }
  291.     
  292.         return hazelcast;
  293.     }
  294.     
  295.     private static void setNetwork(InMemoryYamlConfig hazelcastConfig, String hazelcastConfigContent, String groupId) throws PolicyException {
  296.         
  297.         Config sharedConfig = null;
  298.         if(HazelcastManager.shareConfigFile!=null) {
  299.             try {
  300.                 // La valido ma poi la ricostruiro' tutte le volte per poi sostituire la porta
  301.                 try(FileInputStream fin = new FileInputStream(HazelcastManager.shareConfigFile)){
  302.                     YamlConfigBuilder builder = new  YamlConfigBuilder(fin);
  303.                     sharedConfig = builder.build();
  304.                 }
  305.             }catch(Throwable t) {
  306.                 // e' gia' stato validato in fase di inizializzazione. Un errore qua non dovrebbe succedere
  307.                 throw new PolicyException("Configuration '"+shareConfigFile.getAbsolutePath()+"' is not valid yaml config (YamlConfigBuilder): "+t.getMessage(),t);
  308.             }
  309.         }
  310.         
  311.         if(sharedConfig!=null && sharedConfig.getNetworkConfig()!=null) {
  312.             NetworkConfig ncShared = sharedConfig.getNetworkConfig();
  313.             NetworkConfig ncInstance = hazelcastConfig.getNetworkConfig();
  314.             Integer portHazelcastConfigInstance = null;
  315.             if(ncInstance==null) {
  316.                 // non dovrebbe mai esserlo, essendo definita una porta per ogni tipo di istanza
  317.                 ncInstance = new NetworkConfig();
  318.                 hazelcastConfig.setNetworkConfig(ncInstance);
  319.             }
  320.             else {
  321.                 portHazelcastConfigInstance = hazelcastConfig.getNetworkConfig().getPort();
  322.             }
  323.             
  324.             
  325.             JsonNode instanceNode = null;
  326.             try {
  327.                 instanceNode = yamlUtils.getAsNode(hazelcastConfigContent);
  328.             }catch(Throwable t) {
  329.                 throw new PolicyException("Configuration '"+groupId+"' is not valid yaml config:\n"+hazelcastConfigContent);
  330.             }
  331.             
  332.             // overrides the public address of a member
  333.             if(ncShared.getPublicAddress()!=null) {
  334.                 boolean definedInstance = isDefined("public-address", yamlUtils, engine, instanceNode);
  335.                 if(!definedInstance) {
  336.                     ncInstance.setPublicAddress(ncShared.getPublicAddress());
  337.                     debug("(cluster-id"+groupId+") override public-address: " + ncInstance.getPublicAddress());
  338.                 }
  339.             }
  340.             
  341.             // overrides only defined outbound ports
  342.             if( (ncShared.getOutboundPorts()!=null && !ncShared.getOutboundPorts().isEmpty())
  343.                     ||
  344.                 (ncShared.getOutboundPortDefinitions()!=null && !ncShared.getOutboundPortDefinitions().isEmpty())) {
  345.                 boolean definedInstance = isDefined("outbound-ports", yamlUtils, engine, instanceNode);
  346.                 if(!definedInstance) {
  347.                     if(ncShared.getOutboundPorts()!=null && !ncShared.getOutboundPorts().isEmpty()){
  348.                         ncInstance.setOutboundPorts(ncShared.getOutboundPorts());
  349.                         debug("(cluster-id"+groupId+") override outbound-ports: " + ncInstance.getOutboundPorts());
  350.                     }
  351.                     if((ncShared.getOutboundPortDefinitions()!=null && !ncShared.getOutboundPortDefinitions().isEmpty())) {
  352.                         ncInstance.setOutboundPortDefinitions(ncShared.getOutboundPortDefinitions());
  353.                         debug("(cluster-id"+groupId+") override outbound-ports (definitions): " + ncInstance.getOutboundPortDefinitions());
  354.                     }
  355.                 }
  356.             }
  357.             
  358.             // If you set the reuse-address element to true, the TIME_WAIT state is ignored and you can bind the member to the same port again
  359.             boolean definedShared = isDefined("reuse-address", yamlUtils, engine, HazelcastManager.sharedConfigNode);
  360.             if(definedShared) {
  361.                 boolean definedInstance = isDefined("reuse-address", yamlUtils, engine, instanceNode);
  362.                 if(!definedInstance) {
  363.                     ncInstance.setReuseAddress(ncShared.isReuseAddress());
  364.                     debug("(cluster-id"+groupId+") override reuse-address: " + ncInstance.isReuseAddress());
  365.                 }
  366.             }
  367.             
  368.             // the ports that Hazelcast uses to communicate between cluster members
  369.             //ncShared.getPort();
  370.             //ncShared.getPortCount();
  371.             //ncShared.isPortAutoIncrement();
  372.             // L'unico elemento che viene ignorato se presente è il 'port'.
  373.             // Anche se definito verrà ignorato poichè ogni singola configurazione utilizzata in GovWay richiede una porta dedicata.
  374.             // Per modificarla si deve agire nel file govway.hazelcast-*.yaml presente all'interno dell'archivio govway.ear, 
  375.             // modificandolo direttamente dentro l'archivio o riportandolo nella directory di configurazione esterna.

  377.             // override join
  378.             if(ncShared.getJoin()!=null) {
  379.                 boolean definedInstance = isDefined("join", yamlUtils, engine, instanceNode);
  380.                 if(!definedInstance) {
  381.                     ncInstance.setJoin(ncShared.getJoin());
  382.                     if(ncInstance.getJoin().getTcpIpConfig()!=null) {
  383.                         if(portHazelcastConfigInstance!=null && portHazelcastConfigInstance.intValue()>0) {
  384.                             if(ncInstance.getJoin().getTcpIpConfig().getMembers()!=null && !ncInstance.getJoin().getTcpIpConfig().getMembers().isEmpty()) {
  385.                                 // Se vengono usate le porte, devo clonare la lista e sistemarla con la porta usata sull'attuale istanza
  386.                                 List<String> newList = new ArrayList<>();
  387.                                 for (String member : ncInstance.getJoin().getTcpIpConfig().getMembers()) {
  388.                                     try {
  389.                                         if(member.contains(GOVWAY_INSTANCE_PORT)) {
  390.                                             newList.add(member.replace(GOVWAY_INSTANCE_PORT, portHazelcastConfigInstance.intValue()+""));
  391.                                         }
  392.                                         else if(member.contains(GOVWAY_INSTANCE_PORT.toLowerCase())) {
  393.                                             newList.add(member.replace(GOVWAY_INSTANCE_PORT.toLowerCase(), portHazelcastConfigInstance.intValue()+""));
  394.                                         }
  395.                                         else {
  396.                                             newList.add(member);
  397.                                         }
  398.                                         /*
  399.                                         int indexOfFirst = member.indexOf(":");
  400.                                         if(indexOfFirst>0 && indexOfFirst!=(member.length()-1)) {
  401.                                             int indexOfSecondIpv6 = member.indexOf(":",(indexOfFirst+1));
  402.                                             if(indexOfSecondIpv6<0) {
  403.                                                 usePortIpv4=true;
  404.                                             }
  405.                                         }
  406.                                         if(usePortIpv4) {
  407.                                             String [] split = member.split(":");
  408.                                             String newIp = split[0] + ":" + portHazelcastConfigInstance.intValue();
  409.                                             newList.add(newIp);
  410.                                         }
  411.                                         else {
  412.                                             newList.add(member);
  413.                                         }*/
  414.                                     }catch(Throwable t) {
  415.                                         error("(cluster-id"+groupId+") tpcip analisi member '"+member+"' fallita: " +t.getMessage(),t);
  416.                                         //newList.add(member);
  417.                                     }
  418.                                 }
  419.                                 ncInstance.getJoin().getTcpIpConfig().setMembers(newList);
  420.                             }
  421.                         }
  422.                     }
  423.                     debug("(cluster-id"+groupId+") override join: " + ncInstance.getJoin());
  424.                 }
  425.             }
  426.             
  427.             // override interface
  428.             if(ncShared.getInterfaces()!=null && ncShared.getInterfaces().isEnabled()) {
  429.                 boolean definedInstance = isDefined("interfaces", yamlUtils, engine, instanceNode);
  430.                 if(!definedInstance) {
  431.                     ncInstance.setInterfaces(ncShared.getInterfaces());
  432.                     debug("(cluster-id"+groupId+") override interfaces: " + ncInstance.getInterfaces());
  433.                 }
  434.             }

  436.             
  437.             // override altre configurazioni avanzate
  438.             // example yaml: https://github.com/hazelcast/hazelcast/blob/master/hazelcast/src/test/java/com/hazelcast/config/YamlConfigBuilderTest.java
  439.             if(ncShared.getIcmpFailureDetectorConfig()!=null && ncShared.getIcmpFailureDetectorConfig().isEnabled()) {
  440.                 boolean definedInstance = isDefined("failure-detector", yamlUtils, engine, instanceNode);
  441.                 if(!definedInstance) {
  442.                     ncInstance.setIcmpFailureDetectorConfig(ncShared.getIcmpFailureDetectorConfig());
  443.                     debug("(cluster-id"+groupId+") override failure-detector icmp: " + ncInstance.getIcmpFailureDetectorConfig());
  444.                 }
  445.             }
  446.             if(ncShared.getMemberAddressProviderConfig()!=null && ncShared.getMemberAddressProviderConfig().isEnabled()) {
  447.                 boolean definedInstance = isDefined("member-address-provider", yamlUtils, engine, instanceNode);
  448.                 if(!definedInstance) {
  449.                     ncInstance.setMemberAddressProviderConfig(ncShared.getMemberAddressProviderConfig());
  450.                     debug("(cluster-id"+groupId+") override member-address-provider: " + ncInstance.getMemberAddressProviderConfig());
  451.                 }
  452.             }
  453.             if(ncShared.getMemcacheProtocolConfig()!=null && ncShared.getMemcacheProtocolConfig().isEnabled()) {
  454.                 boolean definedInstance = isDefined("memcache-protocol", yamlUtils, engine, instanceNode);
  455.                 if(!definedInstance) {
  456.                     ncInstance.setMemcacheProtocolConfig(ncShared.getMemcacheProtocolConfig());
  457.                     debug("(cluster-id"+groupId+") override memcache-protocol: " + ncInstance.getMemcacheProtocolConfig());
  458.                 }
  459.             }
  460.             if(ncShared.getRestApiConfig()!=null && ncShared.getRestApiConfig().isEnabled()) {
  461.                 boolean definedInstance = isDefined("rest-api", yamlUtils, engine, instanceNode);
  462.                 if(!definedInstance) {
  463.                     ncInstance.setRestApiConfig(ncShared.getRestApiConfig());
  464.                     debug("(cluster-id"+groupId+") override rest-api: " + ncInstance.getRestApiConfig());
  465.                 }
  466.             }
  467.             if(ncShared.getSocketInterceptorConfig()!=null && ncShared.getSocketInterceptorConfig().getClassName()!=null) {
  468.                 boolean definedInstance = isDefined("socket-interceptor", yamlUtils, engine, instanceNode);
  469.                 if(!definedInstance) {
  470.                     ncInstance.setSocketInterceptorConfig(ncShared.getSocketInterceptorConfig());
  471.                     debug("(cluster-id"+groupId+") override socket-interceptor: " + ncInstance.getSocketInterceptorConfig());
  472.                 }
  473.             }
  474.             if(ncShared.getSSLConfig()!=null && ncShared.getSSLConfig().isEnabled()) {
  475.                 boolean definedInstance = isDefined("ssl", yamlUtils, engine, instanceNode);
  476.                 if(!definedInstance) {
  477.                     ncInstance.setSSLConfig(ncShared.getSSLConfig());
  478.                     debug("(cluster-id"+groupId+") override ssl: " + ncInstance.getSSLConfig());
  479.                 }
  480.             }
  481.             /* Deprecata 
  482.             if(ncShared.getSymmetricEncryptionConfig()!=null && ncShared.getSymmetricEncryptionConfig().isEnabled()) {
  483.                 boolean definedInstance = isDefined("symmetric-encryption", yamlUtils, engine, node);
  484.                 if(!definedInstance) {
  485.                     ncInstance.setSymmetricEncryptionConfig(ncShared.getSymmetricEncryptionConfig());
  486.                     debug("(cluster-id"+groupId+") override symmetric-encryption: " + ncInstance.getSymmetricEncryptionConfig());
  487.                 }
  488.             }
  489.             */
  490.     
  491.         }
  492.     }
  493.     
  494.     private static boolean isDefined(String pattern, YAMLUtils yamlUtils, JsonPathExpressionEngine engine, JsonNode node) throws PolicyException {
  495.         String prefixPattern = "$.hazelcast.network.";
  496.         try {
  497.             JsonNode result = engine.getJsonNodeMatchPattern(node, prefixPattern+pattern);
  498.             return result!=null;
  499.         }catch(JsonPathNotFoundException notFound) {
  500.             return false;
  501.         }catch(Throwable t) {
  502.             throw new PolicyException(t.getMessage(),t);
  503.         }
  504.     }
  505.     
  506.     private static void debug(String msg) {
  507.         if(HazelcastManager.log!=null) {
  508.             HazelcastManager.log.debug(msg);
  509.         }
  510.         if(HazelcastManager.logStartup!=null) {
  511.             HazelcastManager.logStartup.debug(msg);
  512.         }
  513.     }
  514.     private static void info(String msg) {
  515.         if(HazelcastManager.log!=null) {
  516.             HazelcastManager.log.info(msg);
  517.         }
  518.         if(HazelcastManager.logStartup!=null) {
  519.             HazelcastManager.logStartup.info(msg);
  520.         }
  521.     }
  522.     private static void error(String msg, Throwable e) {
  523.         if(HazelcastManager.log!=null) {
  524.             HazelcastManager.log.error(msg,e);
  525.         }
  526.         if(HazelcastManager.logStartup!=null) {
  527.             HazelcastManager.logStartup.error(msg,e);
  528.         }
  529.     }
  530.     
  531.     public static synchronized void close() {
  532.         if(HazelcastManager.staticMapInstance!=null && !HazelcastManager.staticMapInstance.isEmpty()) {
  533.             for (PolicyGroupByActiveThreadsType type : HazelcastManager.staticMapInstance.keySet()) {
  534.                 HazelcastInstance hazelcast = HazelcastManager.staticMapInstance.get(type);
  535.                 try {
  536.                     hazelcast.shutdown();
  537.                 }catch(Throwable t) {
  538.                     HazelcastManager.log.debug("Hazelcast '"+type+"' shutdown failed: " + t.getMessage(),t);
  539.                 }
  540.             }
  541.         }
  542.     }
  543.     

  545. }
Created with JaCoCo 0.8.8.202204050719