com.ctrip.framework.apollo.model.ConfigChangeEvent Java Examples

@Test
public void testApolloConfigChangeListenerWithYamlFile() throws Exception {
  String someKey = "someKey";
  String someValue = "someValue";
  String anotherValue = "anotherValue";

  YamlConfigFile configFile = prepareYamlConfigFile(APPLICATION_YAML_NAMESPACE,
      readYamlContentAsConfigFileProperties("case9.yml"));

  TestApolloConfigChangeListenerWithYamlFile bean = getBean(TestApolloConfigChangeListenerWithYamlFile.class, AppConfig9.class);

  Config yamlConfig = bean.getYamlConfig();
  SettableFuture<ConfigChangeEvent> future = bean.getConfigChangeEventFuture();

  assertEquals(someValue, yamlConfig.getProperty(someKey, null));
  assertFalse(future.isDone());

  configFile.onRepositoryChange(APPLICATION_YAML_NAMESPACE, readYamlContentAsConfigFileProperties("case9-new.yml"));

  ConfigChangeEvent configChangeEvent = future.get(100, TimeUnit.MILLISECONDS);
  ConfigChange change = configChangeEvent.getChange(someKey);
  assertEquals(someValue, change.getOldValue());
  assertEquals(anotherValue, change.getNewValue());

  assertEquals(anotherValue, yamlConfig.getProperty(someKey, null));
}
 

@Test
public void testDeleteSamePropertyTwice() throws Exception {
  Config otherConfig = ConfigService.getConfig(anotherNamespace);

  final Semaphore changes = new Semaphore(0);

  otherConfig.addChangeListener(new ConfigChangeListener() {
    @Override
    public void onChange(ConfigChangeEvent changeEvent) {
      changes.release();
    }
  });

  assertEquals("otherValue6", otherConfig.getProperty("key6", null));

  embeddedApollo.deleteProperty(anotherNamespace, "key6");
  embeddedApollo.deleteProperty(anotherNamespace, "key6");

  assertTrue(changes.tryAcquire(5, TimeUnit.SECONDS));
  assertNull(otherConfig.getProperty("key6", null));
  assertEquals(0, changes.availablePermits());
}
 

@Test
public void testUpdateSamePropertyTwice() throws Exception {
  String someNewValue = "someNewValue";

  Config otherConfig = ConfigService.getConfig(anotherNamespace);

  final Semaphore changes = new Semaphore(0);

  otherConfig.addChangeListener(new ConfigChangeListener() {
    @Override
    public void onChange(ConfigChangeEvent changeEvent) {
      changes.release();
    }
  });

  assertEquals("otherValue3", otherConfig.getProperty("key3", null));

  embeddedApollo.addOrModifyProperty(anotherNamespace, "key3", someNewValue);
  embeddedApollo.addOrModifyProperty(anotherNamespace, "key3", someNewValue);

  assertTrue(changes.tryAcquire(5, TimeUnit.SECONDS));
  assertEquals(someNewValue, otherConfig.getProperty("key3", null));
  assertEquals(0, changes.availablePermits());
}
 

private void refreshZuulProperties(ConfigChangeEvent changeEvent) {
  logger.info("Refreshing zuul properties!");

  /**
   * rebind configuration beans, e.g. ZuulProperties
   * @see org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder#onApplicationEvent
   */
  this.applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));

  /**
   * refresh routes
   * @see org.springframework.cloud.netflix.zuul.ZuulServerAutoConfiguration.ZuulRefreshListener#onApplicationEvent
   */
  this.applicationContext.publishEvent(new RoutesRefreshedEvent(routeLocator));

  logger.info("Zuul properties refreshed!");
}
 

private void refreshZuulProperties(ConfigChangeEvent changeEvent) {
    logger.info("Refreshing zuul properties!");

    /**
     * rebind configuration beans, e.g. ZuulProperties
     * @see org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder#onApplicationEvent
     */
    this.applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));

    /**
     * refresh routes
     * @see org.springframework.cloud.netflix.zuul.ZuulServerAutoConfiguration.ZuulRefreshListener#onApplicationEvent
     */
    this.applicationContext.publishEvent(new RoutesRefreshedEvent(routeLocator));

    logger.info("Zuul properties refreshed!");
}
 

@Override
public void onChange(ConfigChangeEvent changeEvent) {
  Set<String> keys = changeEvent.changedKeys();
  if (CollectionUtils.isEmpty(keys)) {
    return;
  }
  for (String key : keys) {
    // 1. check whether the changed key is relevant
    Collection<SpringValue> targetValues = springValueRegistry.get(beanFactory, key);
    if (targetValues == null || targetValues.isEmpty()) {
      continue;
    }

    // 2. update the value
    for (SpringValue val : targetValues) {
      updateSpringValue(val);
    }
  }
}
 

protected void fireConfigChange(final ConfigChangeEvent changeEvent) {
  for (final ConfigChangeListener listener : m_listeners) {
    // check whether the listener is interested in this change event
    if (!isConfigChangeListenerInterested(listener, changeEvent)) {
      continue;
    }
    m_executorService.submit(new Runnable() {
      @Override
      public void run() {
        String listenerName = listener.getClass().getName();
        Transaction transaction = Tracer.newTransaction("Apollo.ConfigChangeListener", listenerName);
        try {
          listener.onChange(changeEvent);
          transaction.setStatus(Transaction.SUCCESS);
        } catch (Throwable ex) {
          transaction.setStatus(ex);
          Tracer.logError(ex);
          logger.error("Failed to invoke config change listener {}", listenerName, ex);
        } finally {
          transaction.complete();
        }
      }
    });
  }
}
 

@Override
public synchronized void onRepositoryChange(String namespace, Properties newProperties) {
  if (newProperties.equals(m_configProperties)) {
    return;
  }
  Properties newConfigProperties = propertiesFactory.getPropertiesInstance();
  newConfigProperties.putAll(newProperties);

  List<ConfigChange> changes = calcPropertyChanges(namespace, m_configProperties, newConfigProperties);
  Map<String, ConfigChange> changeMap = Maps.uniqueIndex(changes,
      new Function<ConfigChange, String>() {
        @Override
        public String apply(ConfigChange input) {
          return input.getPropertyName();
        }
      });

  updateConfig(newConfigProperties, m_configRepository.getSourceType());
  clearConfigCache();

  this.fireConfigChange(new ConfigChangeEvent(m_namespace, changeMap));

  Tracer.logEvent("Apollo.Client.ConfigChanges", m_namespace);
}
 

public SimpleApolloConfigDemo() {
  ConfigChangeListener changeListener = new ConfigChangeListener() {
    @Override
    public void onChange(ConfigChangeEvent changeEvent) {
      logger.info("Changes for namespace {}", changeEvent.getNamespace());
      for (String key : changeEvent.changedKeys()) {
        ConfigChange change = changeEvent.getChange(key);
        logger.info("Change - key: {}, oldValue: {}, newValue: {}, changeType: {}",
            change.getPropertyName(), change.getOldValue(), change.getNewValue(),
            change.getChangeType());
      }
    }
  };
  config = ConfigService.getAppConfig();
  config.addChangeListener(changeListener);
}
 

@Override
public synchronized void onRepositoryChange(String namespace, Properties newProperties) {
  if (newProperties.equals(m_configProperties.get())) {
    return;
  }

  ConfigSourceType sourceType = m_configRepository.getSourceType();
  Properties newConfigProperties = propertiesFactory.getPropertiesInstance();
  newConfigProperties.putAll(newProperties);

  Map<String, ConfigChange> actualChanges = updateAndCalcConfigChanges(newConfigProperties, sourceType);

  //check double checked result
  if (actualChanges.isEmpty()) {
    return;
  }

  this.fireConfigChange(new ConfigChangeEvent(m_namespace, actualChanges));

  Tracer.logEvent("Apollo.Client.ConfigChanges", m_namespace);
}
 

@Test
@DirtiesContext
public void testListenerTriggeredByDel()
    throws InterruptedException, ExecutionException, TimeoutException {
  embeddedApollo.deleteProperty(otherNamespace, "key1");
  ConfigChangeEvent changeEvent = testBean.futureData.get(5000, TimeUnit.MILLISECONDS);
  assertEquals(otherNamespace, changeEvent.getNamespace());
  assertEquals(PropertyChangeType.DELETED, changeEvent.getChange("key1").getChangeType());
}
 

@Test
@DirtiesContext
public void shouldNotifyOnInterestedPatterns() throws Exception {
  embeddedApollo.addOrModifyProperty(otherNamespace, "server.port", "8080");
  embeddedApollo.addOrModifyProperty(otherNamespace, "server.path", "/apollo");
  embeddedApollo.addOrModifyProperty(otherNamespace, "spring.application.name", "whatever");
  ConfigChangeEvent changeEvent = testInterestedKeyPrefixesBean.futureData.get(5000, TimeUnit.MILLISECONDS);
  assertEquals(otherNamespace, changeEvent.getNamespace());
  assertEquals("8080", changeEvent.getChange("server.port").getNewValue());
  assertEquals("/apollo", changeEvent.getChange("server.path").getNewValue());
}
 

@ApolloConfigChangeListener(interestedKeyPrefixes = PREFIX)
public void onChange(ConfigChangeEvent changeEvent) {
  logger.info("Refreshing Zuul rateLimit Properties");

  this.applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));

  logger.info("Zuul rateLimit Properties refreshed!");
}
 

@Test
@DirtiesContext
public void testListenerTriggeredByAdd() throws InterruptedException, ExecutionException, TimeoutException {
  embeddedApollo.addOrModifyProperty(otherNamespace, "someKey", "someValue");
  ConfigChangeEvent changeEvent = testBean.futureData.get(5000, TimeUnit.MILLISECONDS);
  assertEquals(otherNamespace, changeEvent.getNamespace());
  assertEquals("someValue", changeEvent.getChange("someKey").getNewValue());
}
 

@ApolloConfigChangeListener(ConfigConsts.NAMESPACE_APPLICATION)
public void onChange(ConfigChangeEvent changeEvent) {
    logger.info("before refresh");
    for (String changedKey : changeEvent.changedKeys()) {
        logger.info("===============================================================");
        logger.info("changedKey:{} value:{}", changedKey, changeEvent.getChange(changedKey));
        ConfigChange configChange = changeEvent.getChange(changedKey);
        configChange.getOldValue();
    }
    refreshScope.refreshAll();
    logger.info("after refresh");
}
 

@ApolloConfigChangeListener(value = {ConfigConsts.NAMESPACE_APPLICATION, "TEST1.apollo", "application.yaml"},
    interestedKeyPrefixes = {"redis.cache."})
public void onChange(ConfigChangeEvent changeEvent) {
  logger.info("before refresh {}", sampleRedisConfig.toString());
  refreshScope.refresh("sampleRedisConfig");
  logger.info("after refresh {}", sampleRedisConfig.toString());
}
 

private void initializeConfigChangeListener() {
    configChangeListener = new ConfigChangeListener() {
        @Override
        public void onChange(ConfigChangeEvent changeEvent) {
            ConfigChange change = changeEvent.getChange(ruleKey);
            //change is never null because the listener will only notify for this key
            if (change != null) {
                RecordLog.info("[ApolloDataSource] Received config changes: " + change.toString());
            }
            loadAndUpdateRules();
        }
    };
    config.addChangeListener(configChangeListener, Sets.newHashSet(ruleKey));
}
 

@Test
public void assertAddChangeListener() throws Exception {
    final SettableFuture<ConfigChangeEvent> future = SettableFuture.create();
    ConfigChangeListener listener = future::set;
    configWrapper.addChangeListener(listener, Collections.singleton("test.children.2"));
    embeddedApollo.addOrModifyProperty("orchestration", "test.children.2", "value3");
    ConfigChangeEvent changeEvent = future.get(5, TimeUnit.SECONDS);
    assertTrue(changeEvent.isChanged("test.children.2"));
    assertThat(changeEvent.getChange("test.children.2").getOldValue(), is("value2"));
    assertThat(changeEvent.getChange("test.children.2").getNewValue(), is("value3"));
    assertThat(changeEvent.getChange("test.children.2").getChangeType(), is(PropertyChangeType.MODIFIED));
}
 

@Override
public void onChange(ConfigChangeEvent changeEvent) {
    Set<String> keys = changeEvent.changedKeys();
    for (String key : keys) {
        ConfigChange change = changeEvent.getChange(key);
        if (change == null) {
            continue;
        }

        String oldValue = change.getOldValue();
        String newValue = change.getNewValue();
        configListener.onChange(key, oldValue, newValue);
    }
}
 

private void initializeConfigChangeListener() {
    configChangeListener = new ConfigChangeListener() {
        @Override
        public void onChange(ConfigChangeEvent changeEvent) {
            ConfigChange change = changeEvent.getChange(ruleKey);
            //change is never null because the listener will only notify for this key
            if (change != null) {
                RecordLog.info("[ApolloDataSource] Received config changes: " + change.toString());
            }
            loadAndUpdateRules();
        }
    };
    config.addChangeListener(configChangeListener, Sets.newHashSet(ruleKey));
}
 

@Test
public void assertAddChangeListenerWithInterestedKeyPrefixes() throws Exception {
    final SettableFuture<ConfigChangeEvent> future = SettableFuture.create();
    ConfigChangeListener listener = future::set;
    configWrapper.addChangeListener(listener, Collections.singleton("test.children.1"), Collections.singleton("test.children.2"));
    embeddedApollo.addOrModifyProperty("orchestration", "test.children.2.1", "value4");
    ConfigChangeEvent changeEvent = future.get(5, TimeUnit.SECONDS);
    assertTrue(changeEvent.isChanged("test.children.2.1"));
    assertThat(changeEvent.getChange("test.children.2.1").getNewValue(), is("value4"));
    assertThat(changeEvent.getChange("test.children.2.1").getChangeType(), is(PropertyChangeType.ADDED));
}
 

@ApolloConfigChangeListener
    public void onChange(ConfigChangeEvent changeEvent) {
        refreshZuulProperties(changeEvent);
//        boolean zuulPropertiesChanged = false;
//        for (String changedKey : changeEvent.changedKeys()) {
//            if (changedKey.startsWith("zuul.")||changedKey.startsWith("link.") || changedKey.contains(".ribbon.listOfServers")) {
//                zuulPropertiesChanged = true;
//                break;
//            }
//        }
//
//        if (zuulPropertiesChanged) {
//            refreshZuulProperties(changeEvent);
//        }
    }
 

private boolean isConfigChangeListenerInterested(ConfigChangeListener configChangeListener, ConfigChangeEvent configChangeEvent) {
  Set<String> interestedKeys = m_interestedKeys.get(configChangeListener);
  Set<String> interestedKeyPrefixes = m_interestedKeyPrefixes.get(configChangeListener);

  if ((interestedKeys == null || interestedKeys.isEmpty())
      && (interestedKeyPrefixes == null || interestedKeyPrefixes.isEmpty())) {
    return true; // no interested keys means interested in all keys
  }

  if (interestedKeys != null) {
    for (String interestedKey : interestedKeys) {
      if (configChangeEvent.isChanged(interestedKey)) {
        return true;
      }
    }
  }

  if (interestedKeyPrefixes != null) {
    for (String prefix : interestedKeyPrefixes) {
      for (final String changedKey : configChangeEvent.changedKeys()) {
        if (changedKey.startsWith(prefix)) {
          return true;
        }
      }
    }
  }

  return false;
}
 

@Test
public void testLongPollRefresh() throws Exception {
  final String someKey = "someKey";
  final String someValue = "someValue";
  final String anotherValue = "anotherValue";
  long someNotificationId = 1;

  long pollTimeoutInMS = 50;
  Map<String, String> configurations = Maps.newHashMap();
  configurations.put(someKey, someValue);
  ApolloConfig apolloConfig = assembleApolloConfig(configurations);
  ContextHandler configHandler = mockConfigServerHandler(HttpServletResponse.SC_OK, apolloConfig);
  ContextHandler pollHandler =
      mockPollNotificationHandler(pollTimeoutInMS, HttpServletResponse.SC_OK,
          Lists.newArrayList(
              new ApolloConfigNotification(apolloConfig.getNamespaceName(), someNotificationId)),
          false);

  startServerWithHandlers(configHandler, pollHandler);

  Config config = ConfigService.getAppConfig();
  assertEquals(someValue, config.getProperty(someKey, null));

  final SettableFuture<Boolean> longPollFinished = SettableFuture.create();

  config.addChangeListener(new ConfigChangeListener() {
    @Override
    public void onChange(ConfigChangeEvent changeEvent) {
      longPollFinished.set(true);
    }
  });

  apolloConfig.getConfigurations().put(someKey, anotherValue);

  longPollFinished.get(pollTimeoutInMS * 20, TimeUnit.MILLISECONDS);

  assertEquals(anotherValue, config.getProperty(someKey, null));
}
 

@Override
public void onChange(ConfigChangeEvent changeEvent) {
    Set<String> keys = changeEvent.changedKeys();
    for (String key : keys) {
        ConfigChange change = changeEvent.getChange(key);
        if (change == null) {
            continue;
        }

        String oldValue = change.getOldValue();
        String newValue = change.getNewValue();
        configListener.onChange(key, oldValue, newValue);
    }
}
 

@ApolloConfigChangeListener
private void someOnChange(ConfigChangeEvent changeEvent) {
  this.someChangeEvent = changeEvent;
}
 

public ConfigChangeEvent getChangeEvent2() {
  return changeEvent2;
}
 

@ApolloConfigChangeListener(interestedKeys = {"someKey"})
private void someOnChange(ConfigChangeEvent changeEvent) {}
 

public ConfigChangeEvent getSomeChangeEvent() {
  return someChangeEvent;
}
 

public ConfigChangeEvent getChangeEvent3() {
  return changeEvent3;
}