/*
* Launches against the agent& main
*/
public void testAgentAndMain() throws Exception {
Project project = workspace.getProject("p1");
Run bndrun = new Run(workspace, project.getBase(), project.getFile("one.bndrun"));
bndrun.setProperty("-runpath", "biz.aQute.remote.launcher");
bndrun.setProperty("-runbundles", "bsn-1,bsn-2");
bndrun.setProperty("-runremote", "agent,main;agent=1090");
final RemoteProjectLauncherPlugin pl =
(RemoteProjectLauncherPlugin) bndrun.getProjectLauncher();
pl.prepare();
List<? extends RunSession> sessions = pl.getRunSessions();
assertEquals(2, sessions.size());
RunSession agent = sessions.get(0);
RunSession main = sessions.get(1);
CountDownLatch agentLatch = launch(agent);
CountDownLatch mainLatch = launch(main);
agent.waitTillStarted(1000);
main.waitTillStarted(1000);
Thread.sleep(500);
agent.cancel();
main.cancel();
agentLatch.await();
mainLatch.await();
assertEquals(-3, agent.getExitCode());
assertEquals(-3, main.getExitCode());
bndrun.close();
}
private ConditionalPermissionInfo setConditionalPermissionInfo(
String name, ConditionInfo[] conds, PermissionInfo[] perms, boolean firstTry) {
ConditionalPermissionUpdate update = newConditionalPermissionUpdate();
List rows = update.getConditionalPermissionInfos();
ConditionalPermissionInfo newInfo =
newConditionalPermissionInfo(name, conds, perms, ConditionalPermissionInfo.ALLOW);
int index = -1;
if (name != null) {
for (int i = 0; i < rows.size() && index < 0; i++) {
ConditionalPermissionInfo info = (ConditionalPermissionInfo) rows.get(i);
if (name.equals(info.getName())) {
index = i;
}
}
}
if (index < 0) {
// must always add to the beginning (bug 303930)
rows.add(0, newInfo);
index = 0;
} else {
rows.set(index, newInfo);
}
synchronized (lock) {
if (!update.commit()) {
if (firstTry)
// try again
setConditionalPermissionInfo(name, conds, perms, false);
}
return condAdminTable.getRow(index);
}
}
public static BundleWiringDTO[] newArrayBundleWiringDTO(BundleRevisions revisions) {
if (revisions == null) {
return null;
}
List<BundleRevision> revs = revisions.getRevisions();
final int size = revs.size();
List<BundleWiringDTO> dtos = new ArrayList<BundleWiringDTO>(size);
for (int i = 0; i < size; i++) {
BundleWiring wiring = revs.get(i).getWiring();
if (wiring != null) {
dtos.add(
new DTOBuilder().getBundleWiringDTO(wiring)); // use new DTOBuilder for each wiring dto
}
}
return dtos.toArray(new BundleWiringDTO[dtos.size()]);
}
void trimList(List list, int max) {
synchronized (list) {
while (list.size() > max) {
list.remove(0);
}
}
}
@Test
public void testResolveSingletonInSameRegions() {
List<BundleCapability> collisionCandidates = new ArrayList<BundleCapability>();
collisionCandidates.add(bundleCapability(BUNDLE_B));
collisionCandidates.add(bundleCapability(BUNDLE_C));
collisionCandidates.add(bundleCapability(BUNDLE_D));
this.resolverHook.filterSingletonCollisions(bundleCapability(BUNDLE_A), collisionCandidates);
assertEquals("Wrong number of collitions", 0, collisionCandidates.size());
}
private List<CapabilityDTO> getListCapabilityDTO(List<BundleCapability> caps) {
if (caps == null) {
return null;
}
List<CapabilityDTO> dtos = newList(caps.size());
for (BundleCapability cap : caps) {
dtos.add(getCapabilityDTO(cap));
}
return dtos;
}
private List<WireDTO> getListBundleWireDTO(List<BundleWire> wires) {
if (wires == null) {
return null;
}
List<WireDTO> dtos = newList(wires.size());
for (BundleWire wire : wires) {
dtos.add(getBundleWireDTO(wire));
}
return dtos;
}
private List<RequirementRefDTO> getListRequirementRefDTO(List<BundleRequirement> reqs) {
if (reqs == null) {
return null;
}
List<RequirementRefDTO> dtos = newList(reqs.size());
for (BundleRequirement req : reqs) {
dtos.add(getRequirementRefDTO(req));
}
return dtos;
}
public static ServiceReferenceDTO[] newArrayServiceReferenceDTO(
ServiceReference<?>[] references) {
final int length = (references == null) ? 0 : references.length;
List<ServiceReferenceDTO> refDTOs = new ArrayList<ServiceReferenceDTO>(length);
for (int i = 0; i < length; i++) {
ServiceReferenceDTO dto = getServiceReferenceDTO(references[i]);
if (dto != null) {
refDTOs.add(dto);
}
}
return refDTOs.toArray(new ServiceReferenceDTO[refDTOs.size()]);
}
public static BundleRevisionDTO[] newArrayBundleRevisionDTO(BundleRevisions revisions) {
if (revisions == null) {
return null;
}
List<BundleRevision> revs = revisions.getRevisions();
final int size = revs.size();
BundleRevisionDTO[] dtos = new BundleRevisionDTO[size];
for (int i = 0; i < size; i++) {
dtos[i] = new DTOBuilder().getBundleRevisionDTO(revs.get(i));
}
return dtos;
}
@Test
public void testResolveSingletonInDifferentRegions() throws BundleException {
region(REGION_A).addBundle(bundle(BUNDLE_X));
BundleCapability collision = bundleCapability(BUNDLE_X);
List<BundleCapability> collisionCandidates = new ArrayList<BundleCapability>();
collisionCandidates.add(collision);
collisionCandidates.add(bundleCapability(BUNDLE_B));
collisionCandidates.add(bundleCapability(BUNDLE_C));
collisionCandidates.add(bundleCapability(BUNDLE_D));
this.resolverHook.filterSingletonCollisions(bundleCapability(BUNDLE_A), collisionCandidates);
assertEquals("Wrong number of collitions", 1, collisionCandidates.size());
collisionCandidates.contains(collision);
}
/**
* Tracks and injects APSServiceTracker directly or as wrapped service instance using the tracker
* to call the service depending on the field type.
*
* @param field The field to inject.
* @param managedClass Used to lookup or create an instance of this class to inject into.
* @param context The bundle context.
*/
protected void handleServiceInjections(Field field, Class managedClass, BundleContext context) {
OSGiService service = field.getAnnotation(OSGiService.class);
if (service != null) {
String trackerKey = field.getType().getName() + service.additionalSearchCriteria();
APSServiceTracker tracker = this.trackers.get(trackerKey);
if (tracker == null) {
tracker =
new APSServiceTracker<>(
context, field.getType(), service.additionalSearchCriteria(), service.timeout());
this.trackers.put(trackerKey, tracker);
}
tracker.start();
List<Object> managedInstances = getManagedInstances(managedClass);
for (Object managedInstance : managedInstances) {
if (field.getType().equals(APSServiceTracker.class)) {
injectObject(managedInstance, tracker, field);
} else {
injectObject(managedInstance, tracker.getWrappedService(), field);
}
}
if (service.required() && this.supportsRequired) {
Tuple4<APSServiceTracker, Class, Boolean, List<ServiceRegistration>> requiredService =
new Tuple4<>(
tracker,
managedClass,
false,
(List<ServiceRegistration>) new LinkedList<ServiceRegistration>());
this.requiredServices.add(requiredService);
}
this.activatorLogger.info(
"Injected tracked service '"
+ field.getType().getName()
+ (service.additionalSearchCriteria().length() > 0
? " " + service.additionalSearchCriteria()
: "")
+ "' "
+ "into '"
+ managedClass.getName()
+ "."
+ field.getName()
+ "' for bundle: "
+ context.getBundle().getSymbolicName()
+ " for "
+ managedInstances.size()
+ " instance(s)!");
}
}
/*
* Launches against the agent
*/
public void testSimpleLauncher() throws Exception {
Project project = workspace.getProject("p1");
Run bndrun = new Run(workspace, project.getBase(), project.getFile("one.bndrun"));
bndrun.setProperty("-runpath", "biz.aQute.remote.launcher");
bndrun.setProperty("-runbundles", "bsn-1,bsn-2");
bndrun.setProperty("-runremote", "test");
final RemoteProjectLauncherPlugin pl =
(RemoteProjectLauncherPlugin) bndrun.getProjectLauncher();
pl.prepare();
final CountDownLatch latch = new CountDownLatch(1);
final AtomicInteger exitCode = new AtomicInteger(-1);
List<? extends RunSession> sessions = pl.getRunSessions();
assertEquals(1, sessions.size());
final RunSession session = sessions.get(0);
Thread t =
new Thread("test-launch") {
public void run() {
try {
exitCode.set(session.launch());
} catch (Exception e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}
};
t.start();
Thread.sleep(500);
for (Bundle b : context.getBundles()) {
System.out.println(b.getLocation());
}
assertEquals(4, context.getBundles().length);
String p1 = t1.getAbsolutePath();
System.out.println(p1);
assertNotNull(context.getBundle(p1));
assertNotNull(context.getBundle(t2.getAbsolutePath()));
pl.cancel();
latch.await();
assertEquals(-3, exitCode.get());
bndrun.close();
}
public void testBasic() throws BundleException, InvalidSyntaxException, InterruptedException {
// get the system region
Region systemRegion = digraph.getRegion(0);
// create a disconnected test region
Region testRegion = digraph.createRegion(getName());
List<Bundle> bundles = new ArrayList<Bundle>();
// Install all test bundles
Bundle pp1, cp2, sc1;
bundles.add(pp1 = bundleInstaller.installBundle(PP1, testRegion));
// should be able to start pp1 because it depends on nothing
pp1.start();
// do a sanity check that we have no services available in the isolated region
assertNull("Found some services.", pp1.getBundleContext().getAllServiceReferences(null, null));
assertEquals("Found extra bundles in region", 1, pp1.getBundleContext().getBundles().length);
pp1.stop();
bundles.add(bundleInstaller.installBundle(SP1, testRegion));
bundles.add(bundleInstaller.installBundle(CP1, testRegion));
bundles.add(bundleInstaller.installBundle(PP2, testRegion));
bundles.add(bundleInstaller.installBundle(SP2, testRegion));
bundles.add(cp2 = bundleInstaller.installBundle(CP2, testRegion));
bundles.add(bundleInstaller.installBundle(PC1, testRegion));
bundles.add(bundleInstaller.installBundle(BC1, testRegion));
bundles.add(sc1 = bundleInstaller.installBundle(SC1, testRegion));
bundles.add(bundleInstaller.installBundle(CC1, testRegion));
// Import the system bundle from the systemRegion
digraph.connect(testRegion, digraph.createRegionFilterBuilder().allow(RegionFilter.VISIBLE_BUNDLE_NAMESPACE, "(id=0)").build(), systemRegion);
// must import Boolean services into systemRegion to test
digraph.connect(systemRegion, digraph.createRegionFilterBuilder().allow(RegionFilter.VISIBLE_SERVICE_NAMESPACE, "(objectClass=java.lang.Boolean)").build(), testRegion);
bundleInstaller.resolveBundles(bundles.toArray(new Bundle[bundles.size()]));
for (Bundle bundle : bundles) {
assertEquals("Bundle did not resolve: " + bundle.getSymbolicName(), Bundle.RESOLVED, bundle.getState());
bundle.start();
}
BundleContext context = getContext();
ServiceTracker<Boolean, Boolean> cp2Tracker = new ServiceTracker<Boolean, Boolean>(context, context.createFilter("(&(objectClass=java.lang.Boolean)(bundle.id=" + cp2.getBundleId() + "))"), null);
ServiceTracker<Boolean, Boolean> sc1Tracker = new ServiceTracker<Boolean, Boolean>(context, context.createFilter("(&(objectClass=java.lang.Boolean)(bundle.id=" + sc1.getBundleId() + "))"), null);
cp2Tracker.open();
sc1Tracker.open();
assertNotNull("The cp2 bundle never found the service.", cp2Tracker.waitForService(2000));
assertNotNull("The sc1 bundle never found the service.", sc1Tracker.waitForService(2000));
cp2Tracker.close();
sc1Tracker.close();
}
@Test
public void testResolveSingletonConnectedRegions()
throws BundleException, InvalidSyntaxException {
RegionFilter filter = createBundleFilter(BUNDLE_B, BUNDLE_VERSION);
region(REGION_A).connectRegion(region(REGION_B), filter);
region(REGION_A).addBundle(bundle(BUNDLE_X));
BundleCapability collisionX = bundleCapability(BUNDLE_X);
BundleCapability collisionB = bundleCapability(BUNDLE_B);
List<BundleCapability> collisionCandidates = new ArrayList<BundleCapability>();
collisionCandidates.add(collisionX);
collisionCandidates.add(collisionB);
collisionCandidates.add(bundleCapability(BUNDLE_C));
collisionCandidates.add(bundleCapability(BUNDLE_D));
this.resolverHook.filterSingletonCollisions(bundleCapability(BUNDLE_A), collisionCandidates);
assertEquals("Wrong number of collitions", 2, collisionCandidates.size());
collisionCandidates.contains(collisionX);
collisionCandidates.contains(collisionB);
}
private static Object mapValue(Object v) {
if ((v == null)
|| v instanceof Number
|| v instanceof Boolean
|| v instanceof Character
|| v instanceof String
|| v instanceof DTO) {
return v;
}
if (v instanceof Map) {
Map<?, ?> m = (Map<?, ?>) v;
Map<Object, Object> map = newMap(m.size());
for (Map.Entry<?, ?> e : m.entrySet()) {
map.put(mapValue(e.getKey()), mapValue(e.getValue()));
}
return map;
}
if (v instanceof List) {
List<?> c = (List<?>) v;
List<Object> list = newList(c.size());
for (Object o : c) {
list.add(mapValue(o));
}
return list;
}
if (v instanceof Set) {
Set<?> c = (Set<?>) v;
Set<Object> set = newSet(c.size());
for (Object o : c) {
set.add(mapValue(o));
}
return set;
}
if (v.getClass().isArray()) {
final int length = Array.getLength(v);
final Class<?> componentType = mapComponentType(v.getClass().getComponentType());
Object array = Array.newInstance(componentType, length);
for (int i = 0; i < length; i++) {
Array.set(array, i, mapValue(Array.get(v, i)));
}
return array;
}
return String.valueOf(v);
}
boolean commit(List rows, long updateStamp) {
checkAllPermission();
synchronized (lock) {
if (updateStamp != timeStamp) return false;
SecurityRow[] newRows = new SecurityRow[rows.size()];
Collection names = new ArrayList();
for (int i = 0; i < newRows.length; i++) {
Object rowObj = rows.get(i);
if (!(rowObj instanceof ConditionalPermissionInfo))
throw new IllegalStateException(
"Invalid type \""
+ rowObj.getClass().getName()
+ "\" at row: "
+ i); //$NON-NLS-1$//$NON-NLS-2$
ConditionalPermissionInfo infoBaseRow = (ConditionalPermissionInfo) rowObj;
String name = infoBaseRow.getName();
if (name == null) name = generateName();
if (names.contains(name))
throw new IllegalStateException(
"Duplicate name \"" + name + "\" at row: " + i); // $NON-NLS-1$//$NON-NLS-2$
newRows[i] =
new SecurityRow(
this,
name,
infoBaseRow.getConditionInfos(),
infoBaseRow.getPermissionInfos(),
infoBaseRow.getAccessDecision());
}
condAdminTable = new SecurityTable(this, newRows);
try {
permissionStorage.saveConditionalPermissionInfos(condAdminTable.getEncodedRows());
} catch (IOException e) {
// TODO log
e.printStackTrace();
}
timeStamp += 1;
return true;
}
}
/**
* Gets the <tt>Content</tt>s of this <tt>Conference</tt>.
*
* @return the <tt>Content</tt>s of this <tt>Conference</tt>
*/
public Content[] getContents() {
synchronized (contents) {
return contents.toArray(new Content[contents.size()]);
}
}