CN105260203B

CN105260203B - 一种基于模型的Hadoop部署以及配置方法

Info

Publication number: CN105260203B
Application number: CN201510620902.XA
Authority: CN
Inventors: 陈星�; 郭文忠; 黄益成
Original assignee: Fuzhou University
Current assignee: Fuzhou University
Priority date: 2015-09-25
Filing date: 2015-09-25
Publication date: 2017-11-17
Anticipated expiration: 2035-09-25
Also published as: CN105260203A

Abstract

本发明涉及一种基于模型的Hadoop部署以及配置方法，将服务模型以及云模型作为Hadoop集群的自动化部署以及配置规则引擎的输入；对Hadoop集群的自动化部署以及配置规则进行设定；根据Hadoop集群的自动化部署以及配置规则，结合服务模型以及云模型，生成Hadoop集群的自动化部署以及配置方案，根据该方案，调用API在基础设施上部署Hadoop集群，得到更新后的服务模型以及部署模型。本发明所提出的一种基于模型的Hadoop部署以及配置方法，简化了部署和配置过程，提高了Hadoop部署和配置的效率。

Description

一种基于模型的Hadoop部署以及配置方法

技术领域

本发明涉及Hadoop生态系统软件部署与配置，特别是一种基于模型的Hadoop部署以及配置方法。

背景技术

Hadoop是一个开源的分布式数据处理软件框架。它以一种可靠的、有效的和容易扩展的方式处理数据。在使用实践中，管理员需要根据不同的管理需求以不同的方式部署和配置Hadoop集群，这是一个使用Hadoop服务的主要障碍。这个障碍主要可以分为两部分：

一方面，Hadoop服务非常多样，比如HDFS、Map-Reduce、Hbase、Hive、Yarn、Flume、Spark、Storm、Zookeeper等等。每个服务都有它自己不同于其他服务的管理接口。管理员必须熟悉这些接口才能部署和配置这些服务，这就增加了集群结构的复杂性。

另一方面，虽然已经有一些管理工具能帮助管理员自动化的构造Hadoop集群，但是它们通常都只提供了一个固定的部署方案。为了满足不同的管理需求，则需要大量的手工实现来调整和扩展部署和配置的过程。

发明内容

本发明的目的在于提供一种基于模型的Hadoop部署以及配置方法，以克服现有技术中存在的缺陷。

为实现上述目的，本发明的技术方案是：一种基于模型的Hadoop部署以及配置方法，按照如下步骤实现：

步骤S1：将用以描述用户需要的服务模型以及用以描述计算资源的云模型作为一Hadoop集群的自动化部署以及配置规则引擎的输入；

步骤S2：对Hadoop集群的自动化部署以及配置规则进行设定，并作为可重用资源进行固化；

步骤S3：根据所述Hadoop集群的自动化部署以及配置规则，结合所述服务模型以及所述云模型，生成Hadoop集群的自动化部署以及配置方案；

步骤S4：根据所述Hadoop集群的自动化部署以及配置方案，调用API在基础设施上部署Hadoop集群，得到更新后的、用以描述Hadoop集群服务层实时状态信息的服务模型以及用以描述Hadoop集群部署结果与实时状态信息的部署模型。

在本发明一实施例中，在所述步骤S2中，所述Hadoop集群的自动化部署以及配置规则包括：不同类型的机型在所有使用的计算节点个数中占用的个数、不同的角色占有的计算节点的范围、不同角色间以及组件与不同类型计算节点间的依赖关系、不同服务组件间的互斥关系以及所选服务的参数配置。

在本发明一实施例中，在所述步骤S3中，通过如下步骤生成所述Hadoop集群的自动化部署以及配置方案：

步骤S31：初始化所述Hadoop集群的自动化部署以及配置规则，从所述Hadoop集群的自动化部署以及配置规则中去除所述服务模型中不包括的Hadoop服务；

步骤S32：获取计算节点列表；从所述云模型中，获取若干个由所述服务模型中Cluster元素的AllHostNum属性限定的计算节点列表HostList；

步骤S33：处理角色之间的依赖关系；

步骤S34：处理角色之间的互斥关系；

步骤S35：处理每个角色的数量限制；

步骤S36：处理服务参数配置；

步骤S37：输出最终的所有角色的计算节点列表以及参数配置列表；

步骤S38：算法结束。

在本发明一实施例中，所述角色为Hadoop服务组件。

在本发明一实施例中，在所述步骤S33中，还包括如下步骤：

步骤S331：处理所述角色与所述计算节点列表中计算节点类型之间的依赖；

步骤S332：处理所述角色之间的依赖；

步骤S333：将剩下的且不存在依赖关系的角色的计算节点列表初始化为HostList。

在本发明一实施例中，在所述步骤S34中，还包括如下步骤：

步骤S341：获取存在互斥关系角色的交集节点；

步骤S342：获取每个角色的数量限制，包括最小限定值以及最大限定值；

步骤S343：分别去除每个角色的交集节点，且当去除后节点的个数小于每个角色对应的最小限定值时，用交集节点补足；

步骤S344：按照每个角色对应的最小限定值以及最大限定值差额的比例分配交集节点中的剩余节点。

在本发明一实施例中，在所述步骤S35中，循环检查每个角色对应的节点列表，根据所述Hadoop集群的自动化部署以及配置规则中设定的数量的限制，包括最小限定值以及最大限定值，判断每个角色对应的节点列表长度与该角色对应的最小限定值以及最大限定值之间的关系；若角色对应的列表长度小于角色的最小限定值，则报错，转至所述步骤S38，算法结束；若角色对应的列表长度大于角色的最大限定值，则去除超过最大限定值的节点个数，使得该列表的列表长度等于最大限定值。

在本发明一实施例中，在所述步骤S36中，为每个角色维护一个参数配置列表RoleConfList，将所述Hadoop集群的自动化部署以及配置规则中设定的参数配置存放至对应角色的参数配置列表中。

相较于现有技术，本发明具有以下有益效果：本发明所提出的一种基于模型的Hadoop部署以及配置方法，根据当前Hadoop部署和配置的领域知识，提出了Hadoop软件体系机构的统一模型，在这个统一模型的基础上，进一步提出了一个可以定义一系列规则的规则引擎，通过这个规则引擎领域专家可以很好的描述他们的Hadoop部署和配置的解决方案，从而这些专家们给出的部署和配置需要遵循的规则将可以被视为可重用的资源，管理员可以用复用这些规则，驱动规则引擎，从而根据不同的需求自动部署和配置他们的Hadoop集群。为管理者提供了一种简单且功能强大的Hadoop集群构建方式，该方法极大地简化了部署和配置过程，提高了Hadoop部署和配置的效率。

附图说明

图1为本发明中基于模型的Hadoop部署以及配置方法中服务模型的模型图。

图2为本发明中基于模型的Hadoop部署以及配置方法中部署模型的模型图。

图3为本发明中基于模型的Hadoop部署以及配置方法中云环境中不同主机类型的资源配置图。

图4为本发明中基于模型的Hadoop部署以及配置方法中云模型的模型图。

图5为本发明中基于模型的Hadoop部署以及配置方法的流程图。

图6为本发明一实施例中基于“Spark-On-YARN”规则方案的部署以及配置模型图。

具体实施方式

下面结合附图，对本发明的技术方案进行具体说明。

为了在体系结构层管理Hadoop集群，首先定义一组Hadoop软件体系的统一模型，包括服务模型，部署模型和云模型。服务模型提供了Hadoop服务的统一视图，管理员可以在服务模型里定义需求的Hadoop服务和它们的配置，比如HDFS、Map-Rudece、HIVE等；部署模型提供了Hadoop集群部署单元的统一视图，从该视图里可以清楚地看到某个Hadoop服务的各个组件分别部署在哪些计算节点上；云模型则提供了云中可用的计算资源的统一视图。

服务模型中描述了许多不同的Hadoop服务。如图1所示，可以看到服务模型中的各个元素： Accounts元素代表了一个管理员账户列表，并且其下包含了描述了管理员基本信息的Account元素；Account元素下面又包括了一个Clusters元素列表；Clusters元素下面包含了一个描述基本集群信息的Cluster元素列表；其中，Cluster元素的Solution属性定义了该集群的部署解决方案的选择，AllHostNum属性则定义了将会用于部署Hadoop集群的计算节点的数量；从Cluster元素往下是功能元素，功能元素包括DataStore,ResourceManager, DataAcquisition, DataSychronism等；每个功能元素又包括多个服务元素，比如有 HDFS、YARN、flume、Spark等。

管理员可以在正式开始部署Hadoop集群之前，对服务模型进行定义或设定，该服务模型反应了用户需要部署哪些Hadoop的服务。定义服务模型并成功通过本发明提供的方法在基础设施中部署和配置真实的Hadoop集群后，服务模型将会被更新，并实时反应运行时的Hadoop集群中各种服务的各种信息。

与服务模型不同，部署模型并不是由用户提供的，而是在利用本发明的方法自动完成Hadoop集群的部署和配置时，得到的一个模型。该部署模型能够真实反映系统中Hadoop每个服务的各个组件的数量，以及部署在各个计算节点上的具体情况。例如，HDFS服务包含了三个组件，分别是HDFSNameNode、HDFSSecondaryNameNode和HDFSDataNode，他们分布在不同的计算节点上，并且HDFSNameNode、HDFSSecondaryNameNode均有且只有一个，而HDFSDataNode有多个。部署模型图如图2所示。

与服务模型和部署模型都不同，云模型既不是用户定义的，也不是部署任务完成后得到的，而是一开始就有的。它反映了云环境中可用的计算资源。在本实施例的云模型中，包含了6种不同类型的计算节点，他们分别具有不同的计算资源。这6种机型分别是：Small、Medium、 Large、High-Memory、High-Storage 和High-CPU。详细的资源配置如图3所示，模型图如图4所示。

在上述Hadoop软件体系结构统一模型概念的基础上，本发明提出一种基于模型的Hadoop部署以及配置方法，通过结合上述的模型就能够实现Hadoop集群的自动化部署和配置，如图5所示，具体按照如下步骤实现：

进一步的，在本实施例中，作为输入的服务模型只是在服务层描述了需要部署的Hadoop服务（HDFS、Map-Reduce、Hive等）以及需要用到的计算资源（通过AllHostNum计算节点数量），而具体的部署和配置细节，如计算节点用什么资源配置的机型、HDFS部署在哪几个节点上、HDFS的组件数量有多少等，则需要通过规则引擎来解决。在规则引擎中，用一个XML文件来定义具体的部署和配置需要遵循的规则，并且当规则定义完成时，将可以作为一个可重用的资源固化下来，以供具有相同需求的用户重复利用。在本实施例中，角色为Hadoop服务组件。

如下程序所示，在所述步骤S2中，所述Hadoop集群的自动化部署以及配置规则包括：

（1）不同类型的机型在所有使用的计算节点个数中占用的个数；如下程序所示，在该方案中，small机型使用的个数为总个数减1个，medium机型使用的个数为1个。

（2）不同的角色占有的计算节点的范围；如下程序所示，在该方案中，HDFS_DATANODE部署的计算节点的个数范围为至少2个，至多为所有节点。

（3）不同角色间以及组件与不同类型计算节点间的依赖关系；如下程序所示，在该方案中，HDFS_NAMENODE必须部署在medium类型的计算节点中，YARN_RESOURCE_MANAGER必须和HDFS_NAMENODE部署在相同的节点之上。

（4）不同服务组件间的互斥关系；如下程序所示，在该方案中，HDFS_NAMENODE和HDFS_DATANODE不能部署在相同的节点之上。

（5）所选服务的参数配置；如下程序所示，在该方案中，HDFS_DATANODE存储数据的本地文件系统目录为 “/dfs/dn”。

具体规则定义程序如下所示：

<Rules>

<Hosts>

<High-CPU Number="0"></High-CPU>

<High-Memory Number="0"></High-Memory>

<High-Storage Number="0"></High-Storage></Hosts>

<HDFS_NAMENODE MinNumber="1" MaxNumber="1"></HDFS_NAMENODE>

<HDFS_DATANODE MinNumber="2" MaxNumber="AllHostsNum"></HDFS_DATANODE>

<HDFS_SECONDARY_NAMENODE MinNumber="1" MaxNumber="1"></HDFS_SECONDARY_NAMENODE>

<HDFS_BALANCER MinNumber="1" MaxNumber="1"></HDFS_BALANCER>

<YARN_RESOURCE_MANAGER MinNumber="1" MaxNumber="1"></YARN_RESOURCE_MANAGER>

<YARN_NODE_MANAGER MinNumber="2" MaxNumber="AllHostsNum"></YARN_NODE_MANAGER>

<YARN_JOB_HISTORY MinNumber="1" MaxNumber="1"></YARN_JOB_HISTORY>

</Dependencies>

<Exclusive-relations>

<Exclusive-relation RoleA="HDFSDataNode" RoleB="HDFSNameNode"></Exclusive-relation>

<Exclusive-relation RoleA="YARNResourceManager" RoleB="HDFSNameNode"></Exclusive-relation>

<Exclusive-relation RoleA="YARNNodeManager" RoleB="YARNResourceManager"></Exclusive-relation>

</Exclusive-relations>

<Configuration ServiceName="HDFS"

</Configuration>

</Configurations>

</Rules>

进一步的，在本实施例中，在所述步骤S3中，通过如下步骤生成所述Hadoop集群的自动化部署以及配置方案：

步骤S32：获取计算节点列表；从所述云模型中，获取若干个由所述服务模型中Cluster元素的AllHostNum属性限定的计算节点列表HostList；这些节点需要满足规则中定义的关于不同机型所占数量的限制。

步骤S33：处理角色之间的依赖关系；在本实施例中，

步骤S34：处理角色之间的互斥关系；

步骤S35：处理每个角色的数量限制；

步骤S36：处理服务参数配置；

步骤S38：算法结束。

进一步的，在所述步骤S33中，还包括如下步骤：

步骤S331：处理所述角色与所述计算节点列表中计算节点类型之间的依赖；在本实施例中，用RoleAList表示将要部署角色A的计算节点列表。例如，角色A与medium机型存在依赖，要求部署在medium机型上，则经过处理使得∀ ComputingNode∈RoleAList，ComputingNode∈HostList && ComputingNode.type=medium。

步骤S332：处理所述角色之间的依赖；如角色A和角色B需要部署在相同节点上，则经过处理使得RoleAList=RoleBList。

步骤S333：处理完这两种依赖后，将剩下的且不存在依赖关系的角色的计算节点列表初始化为HostList，以便接下来的处理。

进一步的，在本实施例中，在所述步骤S34中，如当角色A和角色B间存在互斥关系，即不能部署在相同的节点时，需要对RoleAList和RoleBList交集的部分进行处理，在处理交集的这部分节点时，根据每个角色的数量限制（最小限定值min和最大限定值max），优先满足角色个数的最小限定值，具体还包括如下步骤：

步骤S341：获取存在互斥关系角色的交集节点；

步骤S343：分别去除每个角色的交集节点，且当去除后节点的个数小于每个角色对应的最小限定值时，用交集节点补足；在本实施例中，也即当某个角色去除交集部分剩下的个数小于最小限定值时，用交集部分的节点补足；

步骤S344：按照每个角色对应的最小限定值以及最大限定值差额的比例分配交集节点中的剩余节点；在本实施例中，交集补充完角色A和B使得它们都满足最小限定值时，剩下的节点根据角色A和B最大限定值和最小限定值差额的比例进行分别，即角色A占剩下交集节点的(maxA-minA)/(maxA-minA+ maxB-minB)，角色B占剩下交集节点的1-(maxA-minA)/(maxA-minA+ maxB-minB)。

进一步的，在本实施例中，在所述步骤S35中，每个角色都已经有属于自己的一个节点列表RoleList，循环检查每个角色对应的节点列表，根据所述Hadoop集群的自动化部署以及配置规则中设定的数量的限制，包括最小限定值以及最大限定值，判断每个角色对应的节点列表长度与该角色对应的最小限定值以及最大限定值之间的关系；若角色对应的列表长度小于角色的最小限定值，则报错，转至所述步骤S38，算法结束；若角色对应的列表长度大于角色的最大限定值，则去除超过最大限定值的节点个数，使得该列表的列表长度等于最大限定值。

进一步的，在本实施例中，在所述步骤S36中，为每个角色维护一个参数配置列表RoleConfList，将所述Hadoop集群的自动化部署以及配置规则中设定的参数配置存放至对应角色的参数配置列表中。

为了让本领域技术人员进一步了解本发明所提出的一种基于模型的Hadoop部署以及配置方法，下面具体结合一Hadoop自动化部署以及配置实例进行说明。

在本实施例中，部署的服务包括HDFS，YARN和Spark，其中Spark是运行在YARN之上的服务。如图6所示，首先通过服务模型描述了部署的需求，在该模型图中，定义了要部署的Hadoop服务包括HDFS，YARN和Spark，规定了要用来部署Hadoop集群的节点数量为20个，以及集群的名字为“TestCluster”。最后选择了规则引擎中的规则方案为“Spark-On-YARN”，该方案已经事先被定义好了，所以已经是Cluster元素的Solution属性中的一个可选项。

把定义好的服务模型和已经存在的云模型导入规则引擎，通过步骤S3提供的规则引擎算法的驱动，该Hadoop集群就在基础设施中被部署和配置完成了。如图6以及如下规则引擎程序所示，获得了一个更新过的描述系统中集群的服务层真实状态的服务模型，以及一个描述每个服务在各个节点的部署细节的部署模型。从新的服务模型可以看到，所有元素的属性已经被各个运行时的真实信息所填充，例如，HDFS服务的DFSRemained属性已经从“null”变成了“6991.56G”，而Spark服务的ClusterName属性则从“null”变成了“TestCluster”。

部署模型展示了Hadoop集群在各个节点的部署结果。在这个模型中，能看到不同的角色部署在哪些节点上。例如，从该部署模型中可以了解到HDFSNameNode被部署在了IP地址为“192.168.3.11”的Large-1主机上，并且该角色的health状态为“Good”。

至此，已经成功实现了该实例的部署和配置，在本实施例中，耗时9分钟。根据部署经验，对于熟练掌握Hadoop部署和配置的技术人员来说，手工部署和配置大约耗时5-8小时，而对于Hadoop新手来说，则大约需要耗时3-5天，进一步体现了本方法的可行性和有效性。

规则引擎程序如下：

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import com.cloudera.api.ClouderaManagerClientBuilder;

import com.cloudera.api.DataView;

import com.cloudera.api.model.ApiHost;

import com.cloudera.api.model.ApiHostList;

import com.cloudera.api.v7.RootResourceV7;

import com.google.gson.Gson;

import Tools.Calculator;

importcn.edu.fzu.cloud.passcloud.VMOperation;

publicclass GenerateDeployResult {

Document document;

Element RulesEle, NumberOfRolesEle, HostsEle, DpsEle, ExclusEle,ConfigsEle;

// HashMap<String, ArrayList<String>> HostsList = new HashMap<String, ArrayList<String>>();

ArrayList<String> HostsList = new ArrayList<String>();

int AllHostNum;

ArrayList<String> SmallVMList, MediumVMList, LargeVMList,HighCPUVMList,HighMemoryVMList, HighStorageVMList;

HashMap<String,ArrayList<String>> RoleHostsMap=new HashMap<String, ArrayList<String>>();

HashMap<String,HashMap<String,String>> ConfigsMap = new HashMap<String, HashMap<String,String>>();

HashMap<String,Object> result = new HashMap<String,Object>();

public GenerateDeployResult(int AllHostNum, Document doc) {

this.document = doc;

this.AllHostNum = AllHostNum;

this.RulesEle = document.getRootElement();

this.HostsEle = (Element) RulesEle.element("Hosts");

this.NumberOfRolesEle = (Element) RulesEle.element("NumberOfRoles");

this.DpsEle = (Element) RulesEle.element("Dependencies");

this.ExclusEle = (Element) RulesEle.element("Exclusive-relations");

this.ConfigsEle = (Element) RulesEle.element("Configurations");

}

public HashMap<String,Object> Generate(){

this.DealHosts();

this.DealDependencies();

this.DealExclusives();

this.DealNumberOfRoles();

this.DealConfigurations();

this.result.put("RoleHostsMap",RoleHostsMap);

this.result.put("ConfigsMap",ConfigsMap);

this.result.put("HostsList",HostsList);

System.out.println("The Deployment Result is :");

System.out.println(new Gson().toJson(result));

return result;

}

publicvoid DealHosts() {

SmallVMList = getVMTypeListByCM("small", getHostNum("small"));

MediumVMList = getVMTypeListByCM("medium", getHostNum("medium"));

LargeVMList = getVMTypeListByCM("large", getHostNum("large"));

HighCPUVMList = getVMTypeListByCM("high-cpu", getHostNum("high-cpu"));

HighMemoryVMList = getVMTypeListByCM("high-memory",getHostNum("high-memory"));

HighStorageVMList = getVMTypeListByCM("high-storage",getHostNum("high-storage"));

HostsList.addAll(SmallVMList);

HostsList.addAll(MediumVMList);

HostsList.addAll(LargeVMList);

HostsList.addAll(HighCPUVMList);

HostsList.addAll(HighMemoryVMList);

HostsList.addAll(HighStorageVMList);

System.out.println("The hosts list are :");

System.out.println(SmallVMList+"\n"+MediumVMList+"\n"+LargeVMList+"\n"+HighCPUVMList+"\n"+HighMemoryVMList+"\n"+HighStorageVMList);

}

privateint getHostNum(String HostType) {

float num = 0;

String numStr = HostsEle.element(HostType).attribute("Number")

.getText();

numStr = numStr.replaceAll("AllHostsNum", "" +this.AllHostNum);

// //System.out.println(numStr);

num = (float) new Calculator().calculate(numStr);

// //System.out.println(num);

return (int) num;

}

private ArrayList<String> getVMTypeListByCM(String type, intdemandNum) {

int num=0;

ArrayList<String> VMList = new ArrayList<String>();

RootResourceV7 apiRoot = new ClouderaManagerClientBuilder()

.withHost("192.168.6.3")

.withUsernamePassword("admin", "admin")

.build().getRootV7();

ApiHostList hosts = apiRoot.getHostsResource().readHosts(DataView.FULL);

// System.out.println(new Gson().toJson(hosts));

for(ApiHost host : hosts.getHosts()){

if(host.getRoleRefs().size()==0&&host.getHostname().toLowerCase().contains(type)){

System.out.println(host.getIpAddress()+" don't havecluster now");

num++;

VMList.add(host.getIpAddress());

}

if(num>=demandNum)break;

}

return VMList;

}

publicvoid DealDependencies() {

List<Element> HostDps = DpsEle.elements("HostDependency");

for (Element HostDp : HostDps) {

RoleHostsMap.put(HostDp.attribute("Dependent").getText(),getVMTypeListByCM(HostDp.attribute("Target").getText(), getHostNum(HostDp.attribute("Target").getText())));

}

//System.out.println("After deal HostDependencies, theRoleHostsMap is :");

//System.out.println(RoleHostsMap);

List<Element> RoleDps = DpsEle.elements("RoleDependency");

for (Element RoleDp : RoleDps) {

if(!RoleHostsMap.containsKey(RoleDp.attribute("Target").getText())){

ArrayList<String> tmp=new ArrayList<String>();

tmp.addAll(HostsList);

RoleHostsMap.put(RoleDp.attribute("Dependent").getText(),tmp);

RoleHostsMap.put(RoleDp.attribute("Target").getText(),tmp);

}else{

ArrayList<String> tmp=RoleHostsMap.get(RoleDp.attribute("Target").getText());

RoleHostsMap.put(RoleDp.attribute("Dependent").getText(),tmp);

}

//System.out.println("After deal RoleDependencies, theRoleHostsMap is :");

//System.out.println(RoleHostsMap);

}

publicvoid DealExclusives(){

InitialRemainingRoles();

String RoleA,RoleB;

int AMin,AMax,BMin,BMax,AHave,BHave,ABHave;

for(Element Exclu : (List<Element>) ExclusEle.elements()){

ArrayList<String> AHostList=new ArrayList<String>(),BHostList=new ArrayList<String>(),ABHostList=new ArrayList<String>(),TmpHostList=new ArrayList<String>();

int gapA=0,gapB = 0,addToA=0,addToB=0;

RoleA =Exclu.attributeValue("RoleA");

RoleB =Exclu.attributeValue("RoleB");

//System.out.println("RoleA is "+RoleA);

//System.out.println("RoleB is "+RoleB);

AMin= (int) new Calculator().calculate(this.NumberOfRolesEle.element(RoleA).attributeValue("MinNumber").replaceAll("AllHostsNum",""+this.AllHostNum));

AMax= (int) new Calculator().calculate(this.NumberOfRolesEle.element(RoleA).attributeValue("MaxNumber").replaceAll("AllHostsNum",""+this.AllHostNum));

BMin= (int) new Calculator().calculate(this.NumberOfRolesEle.element(RoleB).attributeValue("MinNumber").replaceAll("AllHostsNum",""+this.AllHostNum));

BMax= (int) new Calculator().calculate(this.NumberOfRolesEle.element(RoleB).attributeValue("MaxNumber").replaceAll("AllHostsNum",""+this.AllHostNum));

AHostList=RoleHostsMap.get(RoleA);

BHostList=RoleHostsMap.get(RoleB);

ABHostList.addAll(AHostList);

ABHostList.retainAll(BHostList);

ABHave = ABHostList.size();

AHave = AHostList.size();

BHave = BHostList.size();

System.out.println(RoleA);

System.out.println(RoleB);

System.out.println("A : "+AHostList);

System.out.println("B : "+BHostList);

System.out.println(AHave);

System.out.println(BHave);

System.out.println(ABHave);

// 把roleA和roleB各分成3种情况，“①《min《=②《=max《③”，即除去交集部分，已经拥有的节点数量在①、②、③的哪个位置，通过组合可以得到如下的几种情况（共3*3=9种，其中5种可以合并为第一种情况）

if(AHave-ABHave-AMax>0 || BHave-ABHave-BMax>0){

if(!(AHave-ABHave-AMax>0)){

BHostList.removeAll(ABHostList);

}elseif(!(BHave-ABHave-BMax>0)){

AHostList.removeAll(ABHostList);

}else{

AHostList.removeAll(ABHostList);

BHostList.removeAll(ABHostList);

}

}elseif(AHave-ABHave-AMin<0 && BHave-ABHave-BMin<0){

if((AHave+BHave-AMin-BMin-ABHave)<0){

try {

thrownew Exception("Error, the number of hostsis not enough.\n The error is found when deal Exclusive-Relation between "+RoleA+" and "+RoleB);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.exit(0);

}

gapA=AMax-(AHave-ABHave);

gapB=BMax-(BHave-ABHave);

addToA=(AHave+BHave-AMin-BMin-ABHave)*(AMax-AMin)/((AMax-AMin)+(BMax-BMin))+(AMin-(AHave-ABHave));

addToB=ABHave-addToA;

}elseif(!(AHave-ABHave-AMin<0) && BHave-ABHave-BMin<0){

if((BHave-BMin)<0){

try {

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.exit(0);

}

gapA=AMax-(AHave-ABHave);

gapB=BMax-(BHave-ABHave);

addToA=(BHave-BMin)*gapA/(gapA+(BMax-BMin));

addToB=ABHave-addToA;

}elseif(AHave-ABHave-AMin<0 && !(BHave-ABHave-BMin<0)){

if((AHave-AMin)<0){

try {

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.exit(0);

}

gapA=AMax-(AHave-ABHave);

gapB=BMax-(BHave-ABHave);

System.out.println((gapB+(AMax-AMin)));

System.out.println(AMin-(AHave-ABHave));

addToA=(AHave-AMin)*(AMax-AMin)/(gapB+(AMax-AMin))+(AMin-(AHave-ABHave));

addToB=ABHave-addToA;

}else{

gapA=AMax-(AHave-ABHave);

gapB=BMax-(BHave-ABHave);

addToA = ABHave*gapA/(gapA+gapB);

addToB=ABHave-addToA;

}

if(!(AHave-ABHave-AMax>0 || BHave-ABHave-BMax>0)){

TmpHostList.addAll(ABHostList);

AHostList.removeAll(ABHostList);

BHostList.removeAll(ABHostList);

for(int i=0;i<addToA&&i<gapA;i++){

AHostList.add(ABHostList.get(i));

TmpHostList.remove(ABHostList.get(i));

}

for(int i=0;i<addToB&&i<gapB;i++){

BHostList.add(TmpHostList.get(i));

}

System.out.println("A' : "+AHostList);

System.out.println("B' : "+BHostList);

}

privatevoid InitialRemainingRoles(){

for(Element Role : (List<Element>) this.NumberOfRolesEle.elements()){

if(!RoleHostsMap.containsKey(Role.getName())){

ArrayList<String> tmp=new ArrayList<String>();

tmp.addAll(HostsList);

RoleHostsMap.put(Role.getName(), tmp);

}

//System.out.println("After InitialRemainingRoles, theRoleHostsMap is :");

//System.out.println(RoleHostsMap);

}

privatevoid DealNumberOfRoles(){

int Min=0,Max=0;int HostListSize=0;

for(Element NumberOfRoles : (List<Element>) this.NumberOfRolesEle.elements()){

Min=(int) new Calculator().calculate(NumberOfRoles.attributeValue("MinNumber").replaceAll("AllHostsNum",""+this.AllHostNum));

Max=(int) new Calculator().calculate(NumberOfRoles.attributeValue("MaxNumber").replaceAll("AllHostsNum",""+this.AllHostNum));

HostListSize=RoleHostsMap.get(NumberOfRoles.getName()).size();

if(HostListSize>Max){

for(int i=0;i<HostListSize-Max;i++){

RoleHostsMap.get(NumberOfRoles.getName()).remove(0);

}

}elseif(HostListSize<Min){

try {

thrownew Exception("Error, the number of hosts isnot enough.\n The error is found when Deal the Number Of "+NumberOfRoles.getName());

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.exit(0);

}

//System.out.println("After DealNumberOfRoles, theRoleHostsMap is :");

//System.out.println(RoleHostsMap);

}

privatevoid DealConfigurations(){

for(Element ConfigEle : (List<Element>) this.ConfigsEle.elements()){

if(ConfigsMap.containsKey(ConfigEle.attributeValue("ServiceName"))){

ConfigsMap.get(ConfigEle.attributeValue("ServiceName")).put(ConfigEle.attributeValue("Key"), ConfigEle.attributeValue("Value"));

}else{

HashMap<String,String> ServiceConfigs = new HashMap<String, String>();

ServiceConfigs.put(ConfigEle.attributeValue("Key"),ConfigEle.attributeValue("Value"));

ConfigsMap.put(ConfigEle.attributeValue("ServiceName"),ServiceConfigs);

}

//System.out.println(ConfigsMap);

}

publicstaticvoid main(String[] args) {

SAXReader reader = new SAXReader();

Document document=null;

try {

document = reader.read(new File("src/Spark-On-YARN.xml"));

} catch (DocumentException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

GenerateDeployResult test = new GenerateDeployResult(20,document);

test.Generate();

}

以上是本发明的较佳实施例，凡依本发明技术方案所作的改变，所产生的功能作用未超出本发明技术方案的范围时，均属于本发明的保护范围。

Claims

1.一种基于模型的Hadoop部署以及配置方法，其特征在于，按照如下步骤实现：

步骤S4：根据所述Hadoop集群的自动化部署以及配置方案，调用API在基础设施上部署Hadoop集群，得到更新后的、用以描述Hadoop集群服务层实时状态信息的服务模型以及用以描述Hadoop集群部署结果与实时状态信息的部署模型；

在所述步骤S2中，所述Hadoop集群的自动化部署以及配置规则包括：不同类型的机型在所有使用的计算节点个数中占用的个数、不同的角色占有的计算节点的范围、不同角色间以及组件与不同类型计算节点间的依赖关系、不同服务组件间的互斥关系以及所选服务的参数配置；

在所述步骤S3中，通过如下步骤生成所述Hadoop集群的自动化部署以及配置方案：

步骤S33：处理角色之间的依赖关系；

步骤S34：处理角色之间的互斥关系；

步骤S35：处理每个角色的数量限制；

步骤S36：处理服务参数配置；

步骤S38：算法结束。

2.根据权利要求1所述的一种基于模型的Hadoop部署以及配置方法，其特征在于，所述角色为Hadoop服务组件。

3.根据权利要求2所述的一种基于模型的Hadoop部署以及配置方法，其特征在于，在所述步骤S33中，还包括如下步骤：

步骤S332：处理所述角色之间的依赖；

4.根据权利要求2所述的一种基于模型的Hadoop部署以及配置方法，其特征在于，在所述步骤S34中，还包括如下步骤：

步骤S341：获取存在互斥关系角色的交集节点；

5.根据权利要求2所述的一种基于模型的Hadoop部署以及配置方法，其特征在于，在所述步骤S35中，循环检查每个角色对应的节点列表，根据所述Hadoop集群的自动化部署以及配置规则中设定的数量的限制，包括最小限定值以及最大限定值，判断每个角色对应的节点列表长度与该角色对应的最小限定值以及最大限定值之间的关系；若角色对应的列表长度小于角色的最小限定值，则报错，转至所述步骤S38，算法结束；若角色对应的列表长度大于角色的最大限定值，则去除超过最大限定值的节点个数，使得该列表的列表长度等于最大限定值。

6.根据权利要求2所述的一种基于模型的Hadoop部署以及配置方法，其特征在于，在所述步骤S36中，为每个角色维护一个参数配置列表RoleConfList，将所述Hadoop集群的自动化部署以及配置规则中设定的参数配置存放至对应角色的参数配置列表中。