/** * Create an application context from a parent producer and an id. * * @param deployState the global deploy state for this model * @param parent the parent to be used for the config model * @param producerId the id to be used for the config model * @return a model context that can be passed to a model */ public static ConfigModelContext create(DeployState deployState, VespaModel vespaModel, ConfigModelRepoAdder configModelRepoAdder, AbstractConfigProducer parent, String producerId) { return new ConfigModelContext(ApplicationType.DEFAULT, deployState, vespaModel, configModelRepoAdder, parent, producerId); }
/** Create a new context with a different config model producer id */ public ConfigModelContext withId(String producerId) { return ConfigModelContext.create(deployState, vespaModel, configModelRepoAdder, parent, producerId); }
@Override public void doBuild(AdminModel model, Element adminElement, ConfigModelContext modelContext) { AbstractConfigProducer parent = modelContext.getParentProducer(); ModelContext.Properties properties = modelContext.getDeployState().getProperties(); DomAdminV2Builder domBuilder = new DomAdminV2Builder(modelContext.getApplicationType(), modelContext.getDeployState().getFileRegistry(), properties.multitenant(), properties.configServerSpecs()); model.admin = domBuilder.build(modelContext.getDeployState(), parent, adminElement); // TODO: Is required since other models depend on admin. if (parent instanceof ApplicationConfigProducerRoot) { ((ApplicationConfigProducerRoot)parent).setupAdmin(model.admin); } } }
public DomAdminV4Builder(ConfigModelContext context, boolean multitenant, List<ConfigServerSpec> configServerSpecs, Collection<ContainerModel> containerModels) { super(context.getApplicationType(), context.getDeployState().getFileRegistry(), multitenant, configServerSpecs); this.containerModels = containerModels; this.context = context; }
private ContainerCluster createContainerCluster(Element spec, ConfigModelContext modelContext) { return new VespaDomBuilder.DomConfigProducerBuilder<ContainerCluster>() { @Override protected ContainerCluster doBuild(DeployState deployState, AbstractConfigProducer ancestor, Element producerSpec) { return new ContainerCluster(ancestor, modelContext.getProducerId(), modelContext.getProducerId(), deployState); } }.build(modelContext.getDeployState(), modelContext.getParentProducer(), spec); }
@Override public MODEL build(ConfigModelInstanceFactory<MODEL> factory, Element spec, ConfigModelContext context) { VespaDomBuilder.DomSimpleConfigProducerBuilder builder = new VespaDomBuilder.DomSimpleConfigProducerBuilder(context.getProducerId()); AbstractConfigProducer producer = builder.build(context.getDeployState(), context.getParentProducer(), spec); return super.build(factory, spec, context.withParent(producer)); }
if (parent == null) parent = new SimpleConfigProducer(root, ContainerModel.DOCPROC_RESERVED_NAME); ContainerCluster indexingCluster = new ContainerCluster(parent, "cluster." + indexerName, indexerName, modelContext.getDeployState()); ContainerModel indexingClusterModel = new ContainerModel(modelContext.withParent(parent).withId(indexingCluster.getSubId())); indexingClusterModel.setCluster(indexingCluster); modelContext.getConfigModelRepoAdder().add(indexingClusterModel); content.ownedIndexingCluster = Optional.of(indexingCluster); String containerName = String.valueOf(searchNode.getDistributionKey()); Container docprocService = new Container(indexingCluster, containerName, index, modelContext.getDeployState().isHosted()); index++; docprocService.setBasePort(host.nextAvailableBaseport(docprocService.getPortCount())); docprocService.setHostResource(host); docprocService.initService(modelContext.getDeployLogger()); nodes.add(docprocService); processedHosts.add(host);
private List<Container> createNodesFromNodeType(ContainerCluster cluster, Element nodesElement, ConfigModelContext context) { NodeType type = NodeType.valueOf(nodesElement.getAttribute("type")); ClusterSpec clusterSpec = ClusterSpec.request(ClusterSpec.Type.container, ClusterSpec.Id.from(cluster.getName()), context.getDeployState().getWantedNodeVespaVersion(), false, Collections.emptySet()); Map<HostResource, ClusterMembership> hosts = cluster.getRoot().getHostSystem().allocateHosts(clusterSpec, Capacity.fromRequiredNodeType(type), 1, log); return createNodesFromHosts(context.getDeployLogger(), hosts, cluster); }
/** Returns a requirement from <code>count</code> dedicated nodes in one group */ public static NodesSpecification dedicated(int count, ConfigModelContext context) { return new NodesSpecification(true, count, 1, context.getDeployState().getWantedNodeVespaVersion(), false, ! context.getDeployState().getProperties().isBootstrap(), false, Optional.empty(), Optional.empty()); }
private Collection<HostResource> allocateHosts(HostSystem hostSystem, String clusterId, NodesSpecification nodesSpecification) { return nodesSpecification.provision(hostSystem, ClusterSpec.Type.admin, ClusterSpec.Id.from(clusterId), context.getDeployLogger()).keySet(); }
@Override public void doBuild(ContainerModel model, Element spec, ConfigModelContext modelContext) { ConfigserverCluster cluster = new ConfigserverCluster(modelContext.getParentProducer(), "configserver", options); super.doBuild(model, spec, modelContext.withParent(cluster)); cluster.setContainerCluster(model.getCluster()); }
@Override public void doBuild(ContainerModel model, Element spec, ConfigModelContext modelContext) { app = modelContext.getApplicationPackage(); checkVersion(spec); this.log = modelContext.getDeployLogger(); ContainerCluster cluster = createContainerCluster(spec, modelContext); addClusterContent(cluster, spec, modelContext); addBundlesForPlatformComponents(cluster); cluster.setRpcServerEnabled(rpcServerEnabled); cluster.setHttpServerEnabled(httpServerEnabled); model.setCluster(cluster); }
/** * Constructs a new config model given a context. * * @param modelContext The model context. */ public ConfigModel(ConfigModelContext modelContext) { super(); this.id = modelContext.getProducerId(); }
private void addModelEvaluation(Element spec, ContainerCluster cluster, ConfigModelContext context) { Element modelEvaluationElement = XML.getChild(spec, "model-evaluation"); if (modelEvaluationElement == null) return; RankProfileList profiles = context.vespaModel() != null ? context.vespaModel().rankProfileList() : RankProfileList.empty; cluster.setModelEvaluation(new ContainerModelEvaluation(cluster, profiles)); }
@Override public void doBuild(Content content, Element xml, ConfigModelContext modelContext) { Admin admin = content.adminModel != null ? content.adminModel.getAdmin() : null; // This is null in tests only content.cluster = new ContentCluster.Builder(admin).build(content.containers, modelContext, xml); buildIndexingClusters(content, modelContext, (ApplicationConfigProducerRoot)modelContext.getParentProducer()); }
@Override public void doBuild(Routing plugin, Element spec, ConfigModelContext modelContext) { ApplicationSpec app = null; RoutingSpec routing = null; if (spec != null) { app = new ApplicationSpec(); for (Element node : Xml.mergeElems(spec, "services", modelContext.getApplicationPackage(), ApplicationPackage.ROUTINGTABLES_DIR)) { addServices(app, node); } routing = new RoutingSpec(); for (Element node : Xml.mergeElems(spec, "routingtable", modelContext.getApplicationPackage(), ApplicationPackage.ROUTINGTABLES_DIR)) { addRoutingTable(routing, node); } } plugin.setExplicitApplicationSpec(app); plugin.setExplicitRoutingSpec(routing); }
@SuppressWarnings({ "UnusedDeclaration"}) // Created by reflection in ConfigModelRepo public Content(ConfigModelContext modelContext, AdminModel adminModel, Collection<ContainerModel> containers) { super(modelContext); modelContext.getParentProducer().getRoot(); isHosted = modelContext.getDeployState().isHosted(); this.adminModel = adminModel; this.containers = containers; }
if (nodesElement.isPresent() && nodesElement.get().getStringAttribute("count") != null ) // request these nodes nodeRequirement = Optional.of(NodesSpecification.from(nodesElement.get(), context)); else if (! nodesElement.isPresent() && subGroups.isEmpty() && context.getDeployState().isHosted()) // request one node nodeRequirement = Optional.of(NodesSpecification.nonDedicated(1, context)); else // Nodes or groups explicitly listed, and/opr not hosted - resolve in GroupBuilder nodeRequirement = Optional.empty(); return new GroupBuilder(group, subGroups, explicitNodes, nodeRequirement, context.getDeployLogger());
/** Returns a requirement from <code>count</code> nondedicated nodes in one group */ public static NodesSpecification nonDedicated(int count, ConfigModelContext context) { return new NodesSpecification(false, count, 1, context.getDeployState().getWantedNodeVespaVersion(), false, ! context.getDeployState().getProperties().isBootstrap(), false, Optional.empty(), Optional.empty()); }
private NodesSpecification createNodesSpecificationForLogserver() { // TODO: Enable for main system as well DeployState deployState = context.getDeployState(); if (deployState.getProperties().useDedicatedNodeForLogserver() && context.getApplicationType() == ConfigModelContext.ApplicationType.DEFAULT && deployState.isHosted()) return NodesSpecification.dedicated(1, context); else return NodesSpecification.nonDedicated(1, context); }