/*
* 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 org.apache.felix.cm.integration;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Dictionary;
import junit.framework.TestCase;
import org.apache.felix.cm.integration.helper.ConfigureThread;
import org.apache.felix.cm.integration.helper.ManagedServiceFactoryThread;
import org.apache.felix.cm.integration.helper.ManagedServiceThread;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.ops4j.pax.exam.junit.JUnit4TestRunner;
/**
* The <code>ConfigUpdateStressTest</code> class tests the issues related to
* concurrency between configuration update (Configuration.update(Dictionary))
* and ManagedService[Factory] registration.
* <p>
* @see <a href="https://issues.apache.org/jira/browse/FELIX-1545">FELIX-1545</a>
*/
@RunWith(JUnit4TestRunner.class)
public class ConfigUpdateStressTest extends ConfigurationTestBase
{
@Test
public void test_ManagedService_race_condition_test()
{
int counterMax = 30;
int failures = 0;
for ( int counter = 0; counter < counterMax; counter++ )
{
try
{
single_test_ManagedService_race_condition_test( counter );
}
catch ( Throwable ae )
{
System.out.println( "single_test_ManagedService_race_condition_test#" + counter + " failed: " + ae );
ae.printStackTrace( System.out );
failures++;
}
}
// fail the test if there is at least one failure
if ( failures != 0 )
{
TestCase.fail( failures + "/" + counterMax + " iterations failed" );
}
}
@Test
public void test_ManagedServiceFactory_race_condition_test()
{
int counterMax = 30;
int failures = 0;
for ( int counter = 0; counter < counterMax; counter++ )
{
try
{
single_test_ManagedServiceFactory_race_condition_test( counter );
}
catch ( Throwable ae )
{
System.out.println( "single_test_ManagedServiceFactory_race_condition_test#" + counter + " failed: "
+ ae );
ae.printStackTrace( System.out );
failures++;
}
}
// fail the test if there is at least one failure
if ( failures != 0 )
{
TestCase.fail( failures + "/" + counterMax + " iterations failed" );
}
}
// runs a single test to encounter the race condition between ManagedService
// registration and Configuration.update(Dictionary)
// This test creates/updates configuration and registers a ManagedService
// almost at the same time. The ManagedService must receive the
// configuration
// properties exactly once.
private void single_test_ManagedService_race_condition_test( final int counter ) throws IOException,
InterruptedException
{
final String pid = "single_test_ManagedService_race_condition_test." + counter;
final ConfigureThread ct = new ConfigureThread( getConfigurationAdmin(), pid, false );
final ManagedServiceThread mt = new ManagedServiceThread( bundleContext, pid );
try
{
// start threads -- both are waiting to be triggered
ct.start();
mt.start();
// trigger for action
ct.trigger();
mt.trigger();
// wait for threads to terminate
ct.join();
mt.join();
// wait for all tasks to terminate
delay();
final boolean isConfigured = mt.isConfigured();
final ArrayList<Dictionary> configs = mt.getConfigs();
// terminate mt to ensure no further config updates
mt.cleanup();
TestCase.assertTrue( "Last update call must have been with configuration", isConfigured);
if ( configs.size() == 0 )
{
TestCase.fail( "No configuration provided to ManagedService at all" );
}
else if ( configs.size() == 2 )
{
final Dictionary props0 = configs.get( 0 );
final Dictionary props1 = configs.get( 1 );
TestCase.assertNull( "Expected first (of two) updates without configuration", props0 );
TestCase.assertNotNull( "Expected second (of two) updates with configuration", props1 );
}
else if ( configs.size() == 1 )
{
final Dictionary props = configs.get( 0 );
TestCase.assertNotNull( "Expected non-null configuration: " + props, props );
}
else
{
TestCase.fail( "Unexpectedly got " + configs.size() + " updated" );
}
}
finally
{
mt.cleanup();
ct.cleanup();
}
}
// runs a single test to encounter the race condition between
// ManagedServiceFactory registration and Configuration.update(Dictionary)
// This test creates/updates configuration and registers a
// ManagedServiceFactory almost at the same time. The ManagedServiceFactory
// must receive the configuration properties exactly once.
private void single_test_ManagedServiceFactory_race_condition_test( final int counter ) throws IOException,
InterruptedException
{
final String factoryPid = "single_test_ManagedServiceFactory_race_condition_test." + counter;
final ConfigureThread ct = new ConfigureThread( getConfigurationAdmin(), factoryPid, true );
final ManagedServiceFactoryThread mt = new ManagedServiceFactoryThread( bundleContext, factoryPid );
try
{
// start threads -- both are waiting to be triggered
ct.start();
mt.start();
// trigger for action
ct.trigger();
mt.trigger();
// wait for threads to terminate
ct.join();
mt.join();
// wait for all tasks to terminate
delay();
final boolean isConfigured = mt.isConfigured();
final ArrayList<Dictionary> configs = mt.getConfigs();
// terminate mt to ensure no further config updates
mt.cleanup();
TestCase.assertTrue( "Last update call must have been with configuration", isConfigured);
if ( configs.size() == 0 )
{
TestCase.fail( "No configuration provided to ManagedServiceFactory at all" );
}
else if ( configs.size() == 1 )
{
final Dictionary props = configs.get( 0 );
TestCase.assertNotNull( "Expected non-null configuration: " + props, props );
}
else
{
TestCase.fail( "Unexpectedly got " + configs.size() + " updated" );
}
}
finally
{
mt.cleanup();
ct.cleanup();
}
}
}