protected void onEntityAdded()

in core/src/main/java/org/apache/brooklyn/entity/group/GroupsChangePolicy.java [138:242]
87 lines of code
8 McCabe index (conditional complexity)

    protected void onEntityAdded(Entity member) {
        super.onEntityAdded(member);
        ManagementContext mgmt = getManagementContext();

        getMaps(LOCATIONS).forEach(
                stringObjectMap -> {
                    try {
                        String type = (String) stringObjectMap.get(TYPE);

                        Maybe<RegisteredType> item = RegisteredTypes.tryValidate(mgmt.getTypeRegistry().get(type), RegisteredTypeLoadingContexts.spec(BrooklynObjectType.LOCATION.getInterfaceType()));
                        LocationSpec locationSpec;

                        if (!item.isNull()) {
                            locationSpec = mgmt.getTypeRegistry().createSpec(item.get(), null, (Class<LocationSpec<Location>>) BrooklynObjectType.LOCATION.getSpecType());
                        } else {
                            locationSpec = LocationSpec.create(ImmutableMap.of(), (Class<Location>)
                                    RegisteredTypes.getClassLoadingContext(member).tryLoadClass(type).get());
                        }

                        // NOTE, it is important to resolve all DSL expressions in the context of the member, e.g.
                        // retrieving member specific properties like IP address or credentials.
                        ExecutionContext memberExecutionContext = ((EntityInternal) member).getExecutionContext();
                        Map<String, Object> brooklynConfig = ((Map<String, Object>) stringObjectMap.get(BROOKLYN_CONFIG));
                        ConfigBag configBag = ConfigBag.newInstance(brooklynConfig);
                        brooklynConfig.forEach((key, value) -> {
                            Object resolvedValueFromMember = EntityInitializers.resolve(configBag, ConfigKeys.newConfigKey(Object.class, key), memberExecutionContext);
                            locationSpec.configure(key, resolvedValueFromMember);
                        });

                        AbstractTypePlanTransformer.checkSecuritySensitiveFields(locationSpec);
                        Location location = ((EntityInternal) member).getManagementContext().getLocationManager().createLocation(locationSpec);

                        LOG.info("Applying location '{}' to member '{}'", location, member);
                        ((EntityInternal) member).addLocations(ImmutableList.of(location));
                    } catch (Throwable e) {
                        throw Exceptions.propagate(e);
                    }
                }
        );

        getMaps(INITIALIZERS).forEach(
                stringObjectMap -> {
                    try {
                        String type = (String) stringObjectMap.get(TYPE);

                        BrooklynClassLoadingContext loader = member != null ? RegisteredTypes.getClassLoadingContext(member) : null;
                        TypeToken<? extends EntityInitializer> typeToken = getType(loader, type);
                        Maybe<? extends EntityInitializer> entityInitializerMaybe = BeanWithTypeUtils.tryConvertOrAbsentUsingContext(Maybe.of(stringObjectMap), typeToken);
                        if (entityInitializerMaybe.isPresent()) {
                            EntityInitializer initializer = entityInitializerMaybe.get();
                            LOG.info("Applying initializer '{}' to member '{}'", initializer, member);
                            initializer.apply((EntityInternal) member);
                        } else {
                            LOG.debug("Unable to initialize {} due to {}", type, Maybe.getException(entityInitializerMaybe), Maybe.getException(entityInitializerMaybe));
                        }
                    } catch (Throwable e) {
                        throw Exceptions.propagate(e);
                    }
                }
        );

        getMaps(POLICIES).forEach(
                stringObjectMap -> {
                    String type = (String) stringObjectMap.get(TYPE);

                    Maybe<RegisteredType> item = RegisteredTypes.tryValidate(mgmt.getTypeRegistry().get(type), RegisteredTypeLoadingContexts.spec(BrooklynObjectType.POLICY.getInterfaceType()));
                    PolicySpec policySpec;

                    if (!item.isNull()) {
                        policySpec = mgmt.getTypeRegistry().createSpec(item.get(), null, (Class<PolicySpec<Policy>>) BrooklynObjectType.POLICY.getSpecType());
                    } else {
                        policySpec = PolicySpec.create(ImmutableMap.of(), (Class<Policy>) RegisteredTypes.getClassLoadingContext(entity).tryLoadClass(type).get());
                    }
                    policySpec.configure((Map<String, Object>) stringObjectMap.get(BROOKLYN_CONFIG));

                    AbstractTypePlanTransformer.checkSecuritySensitiveFields(policySpec);
                    LOG.info("Adding policy '{}' to member '{}'", policySpec, member);
                    member.policies().add(policySpec);
                }
        );

        getMaps(ENRICHERS).forEach(
                stringObjectMap -> {
                    String type = (String) stringObjectMap.get(TYPE);
                    Maybe<RegisteredType> item = RegisteredTypes.tryValidate(mgmt.getTypeRegistry().get(type), RegisteredTypeLoadingContexts.spec(BrooklynObjectType.ENRICHER.getInterfaceType()));
                    EnricherSpec enricherSpec;

                    if (!item.isNull()) {
                        enricherSpec = mgmt.getTypeRegistry().createSpec(item.get(), null, (Class<EnricherSpec<Enricher>>) BrooklynObjectType.ENRICHER.getSpecType());
                    } else {
                        enricherSpec = EnricherSpec.create(ImmutableMap.of(), (Class<Enricher>) RegisteredTypes.getClassLoadingContext(entity).tryLoadClass(type).get());
                    }
                    enricherSpec.configure((Map<String, Object>) stringObjectMap.get(BROOKLYN_CONFIG));

                    AbstractTypePlanTransformer.checkSecuritySensitiveFields(enricherSpec);
                    LOG.info("Adding enricher '{}' to member '{}'", enricherSpec, member);
                    member.enrichers().add(enricherSpec);
                }
        );

        config().get(INVOKE).forEach(effName -> {
            LOG.info("Invoking effector '{}' on member '{}'", effName, member);
            member.invoke( ((EntityInternal)member).getEffector(effName), MutableMap.of() );
        });
    }