in dsl/camel-xml-io-dsl/src/main/java/org/apache/camel/dsl/xml/io/XmlRoutesBuilderLoader.java [111:338]
public RouteBuilder doLoadRouteBuilder(Resource input) throws Exception {
final Resource resource = resource(input);
XmlStreamInfo xmlInfo = xmlInfo(input);
if (!xmlInfo.isValid()) {
// should be valid, because we checked it before
LOG.warn("Invalid XML document: {}", xmlInfo.getProblem().getMessage());
return null;
}
return new RouteConfigurationBuilder() {
@Override
public void configure() throws Exception {
String resourceLocation = input.getLocation();
try {
switch (xmlInfo.getRootElementName()) {
case "beans", "blueprint", "camel" -> {
BeansDefinition def = camelAppCache.get(resourceLocation);
if (def != null) {
configureCamel(def);
} else {
new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseBeansDefinition()
.ifPresent(this::configureCamel);
}
}
case "dataFormats", "dataFormat" -> new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseDataFormatsDefinition()
.ifPresent(this::addDataFormats);
case "routeTemplate", "routeTemplates" ->
new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseRouteTemplatesDefinition()
.ifPresent(this::addRouteTemplatesCollection);
case "templatedRoutes", "templatedRoute" ->
new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseTemplatedRoutesDefinition()
.ifPresent(this::addTemplatedRoutesCollection);
case "rests", "rest" -> new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseRestsDefinition()
.ifPresent(this::addRests);
case "routes", "route" -> new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseRoutesDefinition()
.ifPresent(this::addRoutes);
default -> {
}
}
} finally {
// knowing this is the last time an XML may have been parsed, we can clear the cache
// (route may get reloaded later)
resourceCache.remove(resourceLocation);
xmlInfoCache.remove(resourceLocation);
camelAppCache.remove(resourceLocation);
preparseDone.remove(resourceLocation);
}
}
@Override
public void configuration() throws Exception {
switch (xmlInfo.getRootElementName()) {
// load any route configuration before that may be nested under camel/spring/blueprint root tag
case "beans", "blueprint", "camel", "routeConfigurations", "routeConfiguration": {
BeansDefinition bp = camelAppCache.get(input.getLocation());
if (bp != null) {
bp.getRouteConfigurations().forEach(rc -> {
rc.setResource(getResource());
List<RouteConfigurationDefinition> list = new ArrayList<>();
list.add(rc);
RouteConfigurationsDefinition def = new RouteConfigurationsDefinition();
def.setResource(getResource());
def.setRouteConfigurations(list);
addConfigurations(def);
});
// remove the configurations we have added
bp.getRouteConfigurations().clear();
}
new XmlModelParser(resource, xmlInfo.getRootElementNamespace())
.parseRouteConfigurationsDefinition()
.ifPresent(this::addConfigurations);
}
}
}
private void configureCamel(BeansDefinition app) {
if (!delayedRegistrations.isEmpty()) {
// some of the beans were not available yet, so we have to try register them now
for (BeanFactoryDefinition<?> def : delayedRegistrations) {
def.setResource(getResource());
registerBeanDefinition(def, false);
}
delayedRegistrations.clear();
}
// we have access to beans and spring beans, but these are already processed
// in preParseRoute() and possibly registered in
// org.apache.camel.main.BaseMainSupport.postProcessCamelRegistry() (if given Main implementation
// decides to do so)
if (app.getRestConfigurations().size() > 1) {
throw new RuntimeException("There should only be one <restConfiguration>");
}
if (app.getRestConfigurations().size() == 1) {
RestConfigurationDefinition config = app.getRestConfigurations().get(0);
try {
config.asRestConfiguration(getCamelContext(), getCamelContext().getRestConfiguration());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if (app.getDataFormats() != null) {
app.getDataFormats().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
DataFormatsDefinition list = new DataFormatsDefinition();
list.setDataFormats(app.getDataFormats());
addDataFormats(list);
}
if (!app.getRests().isEmpty()) {
app.getRests().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
RestsDefinition def = new RestsDefinition();
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
def.setRests(app.getRests());
setRestCollection(def);
}
if (!app.getRouteConfigurations().isEmpty()) {
app.getRouteConfigurations().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
RouteConfigurationsDefinition def = new RouteConfigurationsDefinition();
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
def.setRouteConfigurations(app.getRouteConfigurations());
addConfigurations(def);
}
if (!app.getRouteTemplates().isEmpty()) {
app.getRouteTemplates().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
RouteTemplatesDefinition def = new RouteTemplatesDefinition();
def.setResource(getResource());
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setRouteTemplates(app.getRouteTemplates());
setRouteTemplateCollection(def);
}
if (!app.getTemplatedRoutes().isEmpty()) {
app.getTemplatedRoutes().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
TemplatedRoutesDefinition def = new TemplatedRoutesDefinition();
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
def.setTemplatedRoutes(app.getTemplatedRoutes());
setTemplatedRouteCollection(def);
}
if (!app.getRoutes().isEmpty()) {
app.getRoutes().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
RoutesDefinition def = new RoutesDefinition();
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
def.setRoutes(app.getRoutes());
addRoutes(def);
}
}
private void addTemplatedRoutesCollection(TemplatedRoutesDefinition list) {
for (TemplatedRouteDefinition def : list.getTemplatedRoutes()) {
CamelContextAware.trySetCamelContext(def, getCamelContext());
}
setTemplatedRouteCollection(list);
}
private void addRouteTemplatesCollection(RouteTemplatesDefinition list) {
for (RouteTemplateDefinition def : list.getRouteTemplates()) {
CamelContextAware.trySetCamelContext(def, getCamelContext());
}
setRouteTemplateCollection(list);
}
private void addRests(RestsDefinition list) {
for (RestDefinition def : list.getRests()) {
CamelContextAware.trySetCamelContext(def, getCamelContext());
}
setRestCollection(list);
}
private void addRoutes(RoutesDefinition routes) {
// xml routes must be prepared in the same way java-dsl (via RoutesDefinition)
// so create a copy and use the fluent builder to add the route
for (RouteDefinition route : routes.getRoutes()) {
CamelContextAware.trySetCamelContext(route, getCamelContext());
getRouteCollection().route(route);
}
}
private void addConfigurations(RouteConfigurationsDefinition configurations) {
// xml routes must be prepared in the same way java-dsl (via RouteConfigurationDefinition)
// so create a copy and use the fluent builder to add the route
for (RouteConfigurationDefinition config : configurations.getRouteConfigurations()) {
CamelContextAware.trySetCamelContext(config, getCamelContext());
getRouteConfigurationCollection().routeConfiguration(config);
}
}
private void addDataFormats(DataFormatsDefinition dataFormats) {
Model model = getCamelContext().getCamelContextExtension().getContextPlugin(Model.class);
dataFormats.getDataFormats().forEach(def -> {
CamelContextAware.trySetCamelContext(def, getCamelContext());
def.setResource(getResource());
});
model.setDataFormats(dataFormats.asMap());
}
};
}