| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package flex.messaging.config; |
| |
| import flex.messaging.LocalizedException; |
| |
| import java.util.*; |
| |
| public abstract class ConfigurationConfirmation { |
| private IdentityHashMap knownObjects; |
| |
| public ConfigurationConfirmation() { |
| } |
| |
| private void init() { |
| knownObjects = new IdentityHashMap(64); |
| } |
| |
| public abstract MessagingConfiguration getExpectedConfiguration(); |
| |
| public abstract LocalizedException getExpectedException(); |
| |
| public boolean isNegativeTest() { |
| return false; |
| } |
| |
| public boolean matches(MessagingConfiguration config) { |
| init(); |
| |
| try { |
| return configMatch(config, getExpectedConfiguration()); |
| } catch (Exception ex) { |
| return false; |
| } |
| } |
| |
| public boolean negativeMatches(LocalizedException ex) { |
| |
| init(); |
| |
| String message1 = ex.getMessage(); |
| String message2 = getExpectedException().getMessage(); |
| |
| if (message1 == null && message2 == null) { |
| return true; |
| } |
| |
| if (message1 == null || message2 == null) { |
| return false; |
| } |
| |
| return message1.equalsIgnoreCase(message2); |
| } |
| |
| |
| public boolean configMatch(MessagingConfiguration c1, MessagingConfiguration c2) { |
| if (c1 == null && c2 == null) { |
| return true; |
| } |
| |
| if (c1 == null || c2 == null) { |
| return fail("Services sections didn't match: {0} != {1}", new Object[]{c1, c2}); |
| } |
| |
| // Services |
| List s1 = c1.getAllServiceSettings(); |
| List s2 = c2.getAllServiceSettings(); |
| if (!servicesMatch(s1, s2)) { |
| return false; |
| } |
| |
| // Security |
| SecuritySettings sec1 = c1.getSecuritySettings(); |
| SecuritySettings sec2 = c2.getSecuritySettings(); |
| return securityMatch(sec1, sec2); |
| } |
| |
| private boolean securityMatch(SecuritySettings sec1, SecuritySettings sec2) { |
| Collection<SecurityConstraint> constraintSet1 = sec1.getConstraints(); |
| for (SecurityConstraint sc1 : constraintSet1) { |
| SecurityConstraint sc2 = sec2.getConstraint(sc1.getId()); |
| if (!securityConstraintsMatch(sc1, sc2)) |
| return false; |
| } |
| return true; |
| } |
| |
| |
| protected boolean servicesMatch(List s1, List s2) { |
| if (s1 == null && s2 == null) |
| return true; |
| |
| if (s1 == null || s2 == null) |
| return fail("Services sections didn't match: {0} != {1}", new Object[]{s1, s2}); |
| |
| if (s1.size() != s2.size()) |
| return fail("Services sections didn't match by size: {0} != {1}", new Object[]{new Integer(s1.size()), new Integer(s2.size())}); |
| |
| for (Object aS1 : s1) { |
| ServiceSettings ss1 = (ServiceSettings) aS1; |
| String key = ss1.getId(); |
| |
| ServiceSettings ss2 = null; |
| for (Object aS2 : s2) { |
| ServiceSettings element = (ServiceSettings) aS2; |
| if (element.getId().equals(key)) { |
| ss2 = element; |
| break; |
| } |
| } |
| |
| if (!serviceSettingsMatch(ss1, ss2)) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| protected boolean serviceSettingsMatch(ServiceSettings ss1, ServiceSettings ss2) { |
| if (ss1 == null && ss2 == null) { |
| return true; |
| } |
| |
| if (ss1 == null || ss2 == null) { |
| return fail("Service sections didn't match: {0} != {1}", new Object[]{ss1, ss2}); |
| } |
| |
| if (!ss1.getId().equals(ss2.getId())) { |
| return fail("Service ids didn't match: {0} != {1}", new Object[]{ss1.getId(), ss2.getId()}); |
| } |
| |
| if (!ss1.getClassName().equals(ss2.getClassName())) { |
| return fail("Service class names didn't match: {0} != {1}", new Object[]{ss1.getClassName(), ss2.getClassName()}); |
| } |
| |
| // Adapters |
| Map a1 = ss1.getAllAdapterSettings(); |
| Map a2 = ss2.getAllAdapterSettings(); |
| if (!adaptersMatch(a1, a2)) { |
| return false; |
| } |
| |
| // Default Adapters |
| AdapterSettings as1 = ss1.getDefaultAdapter(); |
| AdapterSettings as2 = ss2.getDefaultAdapter(); |
| if (!adapterDefinitionsMatch(as1, as2)) { |
| return false; |
| } |
| |
| |
| // Default Channels |
| List dc1 = ss1.getDefaultChannels(); |
| List dc2 = ss2.getDefaultChannels(); |
| if (dc1.size() != dc2.size()) { |
| return fail("Default channels sections didn't match by size: {0} != {1}", new Object[]{new Integer(dc1.size()), new Integer(dc2.size())}); |
| } |
| |
| for (int i = 0; i < dc1.size(); i++) { |
| ChannelSettings c1 = (ChannelSettings) dc1.get(i); |
| ChannelSettings c2 = (ChannelSettings) dc2.get(i); |
| if (!channelDefinitionsMatch(c1, c2)) { |
| return false; |
| } |
| } |
| |
| // Destinations |
| Map d1 = ss1.getDestinationSettings(); |
| Map d2 = ss2.getDestinationSettings(); |
| return destinationsMatch(d1, d2); |
| } |
| |
| protected boolean adaptersMatch(Map a1, Map a2) { |
| if (a1 == null && a2 == null) { |
| return true; |
| } |
| |
| if (a1 == null || a2 == null) { |
| return fail("Adapters sections didn't match: {0} != {1}", new Object[]{a1, a2}); |
| } |
| |
| if (a1.size() != a2.size()) { |
| return fail("Adapters sections didn't match by size: {0} != {1}", new Object[]{new Integer(a1.size()), new Integer(a2.size())}); |
| } |
| |
| for (Object o : a1.keySet()) { |
| String key = (String) o; |
| |
| AdapterSettings as1 = (AdapterSettings) a1.get(key); |
| AdapterSettings as2 = (AdapterSettings) a2.get(key); |
| if (!adapterDefinitionsMatch(as1, as2)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| protected boolean adapterDefinitionsMatch(AdapterSettings as1, AdapterSettings as2) { |
| if (as1 == null && as2 == null) { |
| return true; |
| } |
| |
| if (as1 == null || as2 == null) { |
| return fail("Adapters didn't match: {0} != {1}", new Object[]{as1, as2}); |
| } |
| |
| if (!as1.getId().equals(as2.getId())) { |
| return fail("Adapter ids didn't match: {0} != {1}", new Object[]{as1.getId(), as2.getId()}); |
| } |
| |
| if (!as1.getClassName().equals(as2.getClassName())) { |
| return fail("Adapter class names didn't match: {0} != {1}", new Object[]{as1.getClassName(), as2.getClassName()}); |
| } |
| |
| if (as1.isDefault() != as2.isDefault()) { |
| return fail("Adapter default attributes didn't match: {0} != {1}", new Object[]{Boolean.valueOf(as1.isDefault()), Boolean.valueOf(as2.isDefault())}); |
| } |
| |
| if (!propertiesMatch(as1.getProperties(), as2.getProperties())) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| protected boolean channelDefinitionsMatch(ChannelSettings c1, ChannelSettings c2) { |
| if (c1 == null && c2 == null) { |
| return true; |
| } |
| |
| if (c1 == null || c2 == null) { |
| return fail("Channels didn't match: {0} != {1}", new Object[]{c1, c2}); |
| } |
| |
| if (!c1.getId().equals(c2.getId())) { |
| return fail("Channel ids didn't match: {0} != {1}", new Object[]{c1.getId(), c2.getId()}); |
| } |
| |
| if (!c1.getEndpointType().equals(c1.getEndpointType())) { |
| return fail("Channel endpoint types didn't match: {0} != {1}", new Object[]{c1.getEndpointType(), c2.getEndpointType()}); |
| } |
| |
| if (!c1.getUri().equals(c2.getUri())) { |
| return fail("Channel endpoint URIs didn't match: {0} != {1}", new Object[]{c1.getUri(), c2.getUri()}); |
| } |
| |
| if (!propertiesMatch(c1.getProperties(), c2.getProperties())) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| protected boolean destinationsMatch(Map d1, Map d2) { |
| if (d1 == null && d2 == null) { |
| return true; |
| } |
| |
| if (d1 == null || d2 == null) { |
| return fail("Destinations sections didn't match: {0} != {1}", new Object[]{d1, d2}); |
| } |
| |
| if (d1.size() != d2.size()) { |
| return fail("Destinations sections didn't match by size: {0} != {1}", new Object[]{new Integer(d1.size()), new Integer(d2.size())}); |
| } |
| |
| for (Object o : d1.keySet()) { |
| String key = (String) o; |
| |
| DestinationSettings ds1 = (DestinationSettings) d1.get(key); |
| DestinationSettings ds2 = (DestinationSettings) d2.get(key); |
| if (!destinationDefinitionsMatch(ds1, ds2)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| protected boolean destinationDefinitionsMatch(DestinationSettings d1, DestinationSettings d2) { |
| if (d1 == null && d2 == null) { |
| return true; |
| } |
| |
| if (d1 == null || d2 == null) { |
| return fail("Destinations didn't match: {0} != {1}", new Object[]{d1, d2}); |
| } |
| |
| if (!d1.getId().equals(d2.getId())) { |
| return fail("Destination ids didn't match: {0} != {1}", new Object[]{d1.getId(), d2.getId()}); |
| } |
| |
| // Properties |
| if (!propertiesMatch(d1.getProperties(), d1.getProperties())) { |
| return false; |
| } |
| |
| // Channels |
| List dc1 = d1.getChannelSettings(); |
| List dc2 = d2.getChannelSettings(); |
| if (dc1.size() != dc2.size()) { |
| return fail("Destination channels sections didn't match by size: {0} != {1}", new Object[]{new Integer(dc1.size()), new Integer(dc2.size())}); |
| } |
| |
| for (int i = 0; i < dc1.size(); i++) { |
| ChannelSettings c1 = (ChannelSettings) dc1.get(i); |
| ChannelSettings c2 = (ChannelSettings) dc2.get(i); |
| if (!channelDefinitionsMatch(c1, c2)) { |
| return false; |
| } |
| } |
| |
| // Security |
| SecurityConstraint sc1 = d1.getConstraint(); |
| SecurityConstraint sc2 = d2.getConstraint(); |
| if (!securityConstraintsMatch(sc1, sc2)) { |
| return false; |
| } |
| |
| // Adapter |
| AdapterSettings as1 = d1.getAdapterSettings(); |
| AdapterSettings as2 = d2.getAdapterSettings(); |
| if (!adapterDefinitionsMatch(as1, as2)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| protected boolean securityConstraintsMatch(SecurityConstraint sc1, SecurityConstraint sc2) { |
| if (sc1 == null && sc2 == null) { |
| return true; |
| } |
| |
| if (sc1 == null || sc2 == null) { |
| return fail("Security constraints didn't match: {0} != {1}", new Object[]{sc1, sc2}); |
| } |
| |
| if (!sc1.getId().equals(sc2.getId())) { |
| return fail("Security constraint ids didn't match: {0} != {1}", new Object[]{sc1.getId(), sc2.getId()}); |
| } |
| |
| if (!sc1.getMethod().equals(sc2.getMethod())) { |
| return fail("Security constraint methods didn't match: {0} != {1}", new Object[]{sc1.getMethod(), sc2.getMethod()}); |
| } |
| |
| // Roles |
| List r1 = sc1.getRoles(); |
| List r2 = sc2.getRoles(); |
| if (r1.size() != r2.size()) { |
| return fail("Security constraint roles sections didn't match by size: {0} != {1}", new Object[]{new Integer(r1.size()), new Integer(r2.size())}); |
| } |
| |
| for (int i = 0; i < r1.size(); i++) { |
| String role1 = (String) r1.get(i); |
| String role2 = (String) r2.get(i); |
| if (!role1.equals(role2)) { |
| return fail("Security constraint roles didn't match: {0} != {1}", new Object[]{role1, role2}); |
| } |
| } |
| |
| return true; |
| } |
| |
| protected boolean propertiesMatch(Map p1, Map p2) { |
| if (p1 == null && p2 == null) { |
| return true; |
| } |
| |
| if (p1 == null || p2 == null) { |
| return fail("Properties didn't match: {0} != {1}", new Object[]{p1, p2}); |
| } |
| |
| if (!mapsMatch(p1, p2)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| protected boolean valuesMatch(Object o1, Object o2) { |
| if (o1 == null && o2 == null) { |
| return true; |
| } |
| |
| if (o1 instanceof Map) { |
| return mapsMatch((Map) o1, (Map) o2); |
| } else if (o1 instanceof List) { |
| return listsMatch((List) o1, (List) o2); |
| } else if (o1 != null) { |
| if (hasComplexChildren(o1)) { |
| // We avoid checking a complex/custom types twice in |
| // case of circular dependencies |
| Object known = knownObjects.get(o1); |
| if (known != null) { |
| return true; |
| } else { |
| knownObjects.put(o1, o2); |
| } |
| } |
| |
| return o1.equals(o2); |
| } |
| |
| return false; |
| } |
| |
| protected boolean stringValuesMatch(String str1, String str2) { |
| if (str1 == null && str2 == null) { |
| return true; |
| } |
| |
| if (str1 != null && !str1.equals(str2)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| protected boolean mapsMatch(Map map1, Map map2) { |
| if (map1.size() != map2.size()) { |
| return false; |
| } |
| |
| // We avoid checking a Map twice in case |
| // of circular dependencies |
| Object known = knownObjects.get(map1); |
| if (known != null) { |
| return true; |
| } else { |
| knownObjects.put(map1, map2); |
| } |
| |
| for (Object next : map1.keySet()) { |
| if (next instanceof String) { |
| String key = (String) next; |
| Object val1 = map1.get(key); |
| Object val2 = map2.get(key); |
| |
| if (!valuesMatch(val1, val2)) |
| return false; |
| } else { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| protected boolean listsMatch(List list1, List list2) { |
| if (list1.size() != list2.size()) { |
| return false; |
| } |
| |
| // We avoid checking a List twice in case |
| // of circular dependencies |
| Object known = knownObjects.get(list1); |
| if (known != null) { |
| return true; |
| } else { |
| knownObjects.put(list1, list2); |
| } |
| |
| for (int i = 0; i < list1.size(); i++) { |
| Object o1 = list1.get(i); |
| Object o2 = list2.get(i); |
| |
| if (!valuesMatch(o1, o2)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| private static boolean hasComplexChildren(Object o) { |
| return !(o instanceof String |
| || o instanceof Boolean |
| || o instanceof Number |
| || o instanceof Character |
| || o instanceof Date); |
| } |
| |
| |
| protected boolean fail(String message) { |
| return fail(message, null); |
| } |
| |
| protected boolean fail(String message, Object[] parameters) { |
| if (!isNegativeTest()) { |
| if (parameters != null) { |
| // replace all of the parameters in the msg string |
| for (int i = 0; i < parameters.length; i++) { |
| String replacement = parameters[i] != null ? parameters[i].toString() : "null"; |
| message = message.replaceAll("\\{" + i + "\\}", replacement); |
| } |
| } |
| |
| System.err.println(message); |
| } |
| |
| return false; |
| } |
| } |