一种基于docker的分布式编译打包系统及方法
技术领域
1.本发明属于开发环境技术领域，涉及开发环境技术，具体是一块基于docker的分布式编译打包算法。
背景技术：
2.随着互联网高速迅速发展，软件产品迭代周期越来越快，如何加强不同技术栈研发人员之间的协作，缩短产品、测试到运维的交付周期，提升研发效率并保障质量，是互联网企业核心竞争力，然而，面对大规模的编译打包任务，单机性能成为瓶颈日渐突出，无法满足大规模、耗资源的打包任务，传统做法是提升机器内存和cpu核数，来提升单机任务处理能力，但这并没有从根本解决大规模编译打包的单机瓶颈问题。，为此，我们提出一块基于docker的分布式编译打包算法。
技术实现要素：
3.发明目的：为突破单机性能瓶颈的限制，本发明提供一种基于docker的分布式编译打包系统及方法。
4.技术方案：为实现上述目的，本发明采用的技术方案为：一种基于docker的分布式编译打包系统，包括一个以上的节点和调度中心，所述调度中心与节点连接，所述调度中心包括流水线与构建时间关系建立模块、最小排队等待时间的节点计算模块，所述节点包括下一次任务需要排队等待时间计算模块，其中：所述流水线与构建时间关系建立模块根据接收的流水线任务，计算每条流水线平均构建时间，建立流水线与构建时间关系。
5.所述下一次任务需要排队等待时间计算模块用于根据流水线与构建时间关系独立计算所在节点下一次任务需要排队等待时间。
6.所述节点发送下一次任务排队等待时间到调度中心。
7.所述最小排队等待时间的节点计算模块用于通过节点等待时间计算出最小排队等待时间的节点。
8.所述调度中心保存中每个节点排队等待时间。调度中心调度最小等待时间的节点去执行流水线构建任务。
9.优选的：所述下一次任务需要排队等待时间计算模块设置排队数量阈值，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。判断空位数量和流水线中的
节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
10.优选的：所述最小排队等待时间的节点计算模块获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
11.一种基于docker的分布式编译打包方法，包括以下步骤：步骤1，计算每条流水线平均构建时间，在数据库建立流水线与构建时间关系。
12.步骤2，每个节点根据流水线与构建时间关系独立计算下一次任务需要排队等待时间。
13.步骤3，每个节点发送下一次任务排队等待时间到调度中心。
14.步骤4，调度中心保存步骤3中每个节点排队等待时间。
15.步骤5，调度中心通过节点等待时间计算出最小排队等待时间的节点。
16.步骤6，调度中心调度最小等待时间的节点去执行流水线构建任务。
17.优选的：调度中心分配被计算出的节点去执行流水线构建任务。
18.优选的：步骤2中计算下一次任务需要排队等待时间的方法，包括以下步骤：步骤21，设置排队数量阈值。
19.步骤22，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。
20.步骤23，判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。
21.步骤24，将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。
22.步骤25，判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。
23.步骤26，判断空位数量和流水线中的节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
24.优选的：步骤5中调度中心通过节点等待时间计算出最小排队等待时间的节点的方法：步骤51，获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。
25.步骤52，如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判
断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
26.本发明相比现有技术，具有以下有益效果：本发明首先计算每条流水线平均构建时间，在数据库建立流水线与构建时间关系，计算每个节点独立下一次任务需要排队等待时间，每个节点发送下一次任务排队等待时间到调度中心，调度中心保存每个节点发送下一次任务排队等待时间，每个节点排队等待时间，调度中心通过节点等待时间计算出最小等待时间的节点，调度中心调度最小等待时间的节点去执行流水线构建任务，通过调度中心分配最少等待时间的任务节点，来执行流水线任务，充分利用多个任务节点资源，突破传统的单机性能瓶颈的限制。
附图说明
27.图1为本发明实施例流程图。
具体实施方式
28.下面结合附图和具体实施例，进一步阐明本发明，应理解这些实例仅用于说明本发明而不用于限制本发明的范围，在阅读了本发明之后，本领域技术人员对本发明的各种等价形式的修改均落于本技术所附权利要求所限定的范围。
29.一种基于docker的分布式编译打包系统，如图1所示，包括一个以上的节点和调度中心，所述调度中心与节点连接，所述调度中心包括流水线与构建时间关系建立模块、最小排队等待时间的节点计算模块，所述节点包括下一次任务需要排队等待时间计算模块，其中：所述流水线与构建时间关系建立模块根据接收的流水线任务，计算每条流水线平均构建时间，建立流水线与构建时间关系。
30.所述下一次任务需要排队等待时间计算模块用于根据流水线与构建时间关系独立计算所在节点下一次任务需要排队等待时间。
31.所述下一次任务需要排队等待时间计算模块设置排队数量阈值，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。判断空位数量和流水线中的节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
32.所述节点发送下一次任务排队等待时间到调度中心。
33.所述最小排队等待时间的节点计算模块用于通过节点等待时间计算出最小排队等待时间的节点。
34.所述最小排队等待时间的节点计算模块获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
35.所述调度中心保存中每个节点排队等待时间。调度中心调度最小等待时间的节点去执行流水线构建任务。
36.一种基于docker的分布式编译打包方法，如图1所示，包括以下步骤：步骤1，计算每条流水线平均构建时间，在数据库建立流水线与构建时间关系。
37.步骤2，每个节点根据流水线与构建时间关系独立计算下一次任务需要排队等待时间。
38.计算下一次任务需要排队等待时间的方法，包括以下步骤：步骤21，设置排队数量阈值。
39.步骤22，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。
40.步骤23，判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。
41.步骤24，将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。
42.步骤25，判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。
43.步骤26，判断空位数量和流水线中的节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
44.代码如下：type pipelinetime struct {
ꢀꢀꢀ
index, id, time uint
ꢀꢀꢀ
peers []pipelinetime}type nodewait struct {
ꢀꢀꢀ
limit uint
ꢀꢀꢀ
times map[uint]uint
ꢀꢀꢀ
ids []uint
ꢀꢀꢀ
size uint}func newnodewait(limit uint, ids []uint, times map[uint]uint) *nodewait {
ꢀꢀꢀ
size := len(ids)
ꢀꢀꢀ
return &nodewait{limit,times, ids, uint(size)}}func (nw *nodewait) sum() uint {
ꢀꢀꢀ
if nw.size 《 nw.limit {
ꢀꢀꢀꢀꢀꢀꢀ
return 0
ꢀꢀꢀ
}
ꢀꢀꢀ
return nw.sum(nw.ids[:nw.limit])}func (nw *nodewait) sum(ids []uint) uint {
ꢀꢀꢀ
var p pipelinetime
ꢀꢀꢀ
nw.each(ids, func(index int, id, time uint) {
ꢀꢀꢀꢀꢀꢀꢀ
v := pipelinetime{uint(index), id, time, []pipelinetime{}}
ꢀꢀꢀꢀꢀꢀꢀ
if 0 == index || time 《 p.time {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
p = v
ꢀꢀꢀꢀꢀꢀꢀ
} else if time == p.time {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
p.peers = append(p.peers, v)
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
})
ꢀꢀꢀ
nw.each(ids, func(index int, id, time uint) {
ꢀꢀꢀꢀꢀꢀꢀ
// 抵消
ꢀꢀꢀꢀꢀꢀꢀ
if time 》 p.time {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
nw.times[id] = time
ꢀ‑ꢀ
p.time
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
})
ꢀꢀꢀ
// 累计时长
ꢀꢀꢀ
wait := p.time
ꢀꢀꢀ
if nw.limit 《 nw.size {
ꢀꢀꢀꢀꢀꢀꢀ
ids[p.index] = nw.ids[nw.limit]
ꢀꢀꢀꢀꢀꢀꢀ
// 剩余
ꢀꢀꢀꢀꢀꢀꢀ
diff := nw.size
ꢀ‑ꢀ
nw.limit
ꢀ‑ꢀ1ꢀꢀꢀꢀꢀꢀꢀ
if num := uint(len(p.peers)); num 《= diff {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
var i uint = 0
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
for i=0; i《num; i {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
nw.limit
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
ids[p.peers[i].index] = nw.ids[nw.limit]
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀ
} else {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
// 空位多于流水线
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
goto end
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀ
nw.limit
ꢀꢀꢀꢀꢀꢀꢀ
wait = nw.sum(ids)
ꢀꢀꢀ
}
ꢀꢀꢀ
end:
ꢀꢀꢀ
return wait}// 遍历func (nw *nodewait) each(ids []uint, f func(index int, id, time uint)) {
ꢀꢀꢀ
for i, id := range ids {
ꢀꢀꢀꢀꢀꢀꢀ
if f != nil {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
f(i, id, nw.duration(id))
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
}}// 用时func (nw *nodewait) duration(id uint) uint {
ꢀꢀꢀ
var t uint = 600
ꢀꢀꢀ
if v, ok := nw.times[id]; ok {
ꢀꢀꢀꢀꢀꢀꢀ
t = v
ꢀꢀꢀ
}
ꢀꢀꢀ
return t}其中，func表示语言关键字，表示声明一个方法，newnodewait()表示调用名为newnodewait的方法，*nodewait表示返回类型为*nodewait，return表示返回值，sum()表示调用名为sum的方法, uint表示返回类型为uint，为算法计算的结果。
[0045]
步骤3，每个节点发送下一次任务排队等待时间到调度中心。
[0046]
步骤4，调度中心保存步骤3中每个节点排队等待时间。
[0047]
步骤5，调度中心通过节点等待时间计算出最小排队等待时间的节点。
[0048]
调度中心通过节点等待时间计算出最小排队等待时间的节点的方法：步骤51，获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。
[0049]
步骤52，如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
[0050]
代码如下：
func electnode() *mem.nodestat {
ꢀꢀꢀ
// 在线节点
ꢀꢀꢀ
nodes := nodeids()
ꢀꢀꢀ
// 节点时间统计
ꢀꢀꢀ
stat := mem.snapshot()
ꢀꢀꢀ
var elected *mem.nodestat
ꢀꢀꢀ
for _, node := range nodes {
ꢀꢀꢀꢀꢀꢀꢀ
if v, ok := stat[node]; ok {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if elected == nil {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
elected = v
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
continue
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if v.wait 《= elected.wait {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
elected = v
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀ
} else {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
elected = v
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
break
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
}
ꢀꢀꢀ
return elected}其中，func表示语言关键字，表示声明一个方法，electnode()表示为此方法的名称，*mem.nodestat表示返回类型为*mem.nodestat，nodes表示 读取在线节点数组的变量，stat表示读取全部在线节点的等待时间字典的变量，elected表示定义一个类型为*mem.nodestat的语言变量，计算出最少等待时间的节点后，分配到步骤6中的去执行流水线任务。
[0051]
步骤6，调度中心调度最小等待时间的节点去执行流水线构建任务。调度中心分配被计算出的节点去执行流水线构建任务。
[0052]
本发明调度中心通过节点的最小等待时间为因子，计算最佳节点来执行流水线任务，让每个节点资源都可以充分利用，避免大规模的编译打包，单机性能瓶颈问题，本发明能够解决规模化打包带来的挑战。
[0053]
以上所述仅是本发明的优选实施方式，应当指出：对于本技术领域的普通技术人员来说，在不脱离本发明原理的前提下，还可以做出若干改进和润饰，这些改进和润饰也应视为本发明的保护范围。
技术领域
1.本发明属于开发环境技术领域，涉及开发环境技术，具体是一块基于docker的分布式编译打包算法。
背景技术：
2.随着互联网高速迅速发展，软件产品迭代周期越来越快，如何加强不同技术栈研发人员之间的协作，缩短产品、测试到运维的交付周期，提升研发效率并保障质量，是互联网企业核心竞争力，然而，面对大规模的编译打包任务，单机性能成为瓶颈日渐突出，无法满足大规模、耗资源的打包任务，传统做法是提升机器内存和cpu核数，来提升单机任务处理能力，但这并没有从根本解决大规模编译打包的单机瓶颈问题。，为此，我们提出一块基于docker的分布式编译打包算法。
技术实现要素：
3.发明目的：为突破单机性能瓶颈的限制，本发明提供一种基于docker的分布式编译打包系统及方法。
4.技术方案：为实现上述目的，本发明采用的技术方案为：一种基于docker的分布式编译打包系统，包括一个以上的节点和调度中心，所述调度中心与节点连接，所述调度中心包括流水线与构建时间关系建立模块、最小排队等待时间的节点计算模块，所述节点包括下一次任务需要排队等待时间计算模块，其中：所述流水线与构建时间关系建立模块根据接收的流水线任务，计算每条流水线平均构建时间，建立流水线与构建时间关系。
5.所述下一次任务需要排队等待时间计算模块用于根据流水线与构建时间关系独立计算所在节点下一次任务需要排队等待时间。
6.所述节点发送下一次任务排队等待时间到调度中心。
7.所述最小排队等待时间的节点计算模块用于通过节点等待时间计算出最小排队等待时间的节点。
8.所述调度中心保存中每个节点排队等待时间。调度中心调度最小等待时间的节点去执行流水线构建任务。
9.优选的：所述下一次任务需要排队等待时间计算模块设置排队数量阈值，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。判断空位数量和流水线中的
节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
10.优选的：所述最小排队等待时间的节点计算模块获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
11.一种基于docker的分布式编译打包方法，包括以下步骤：步骤1，计算每条流水线平均构建时间，在数据库建立流水线与构建时间关系。
12.步骤2，每个节点根据流水线与构建时间关系独立计算下一次任务需要排队等待时间。
13.步骤3，每个节点发送下一次任务排队等待时间到调度中心。
14.步骤4，调度中心保存步骤3中每个节点排队等待时间。
15.步骤5，调度中心通过节点等待时间计算出最小排队等待时间的节点。
16.步骤6，调度中心调度最小等待时间的节点去执行流水线构建任务。
17.优选的：调度中心分配被计算出的节点去执行流水线构建任务。
18.优选的：步骤2中计算下一次任务需要排队等待时间的方法，包括以下步骤：步骤21，设置排队数量阈值。
19.步骤22，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。
20.步骤23，判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。
21.步骤24，将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。
22.步骤25，判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。
23.步骤26，判断空位数量和流水线中的节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
24.优选的：步骤5中调度中心通过节点等待时间计算出最小排队等待时间的节点的方法：步骤51，获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。
25.步骤52，如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判
断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
26.本发明相比现有技术，具有以下有益效果：本发明首先计算每条流水线平均构建时间，在数据库建立流水线与构建时间关系，计算每个节点独立下一次任务需要排队等待时间，每个节点发送下一次任务排队等待时间到调度中心，调度中心保存每个节点发送下一次任务排队等待时间，每个节点排队等待时间，调度中心通过节点等待时间计算出最小等待时间的节点，调度中心调度最小等待时间的节点去执行流水线构建任务，通过调度中心分配最少等待时间的任务节点，来执行流水线任务，充分利用多个任务节点资源，突破传统的单机性能瓶颈的限制。
附图说明
27.图1为本发明实施例流程图。
具体实施方式
28.下面结合附图和具体实施例，进一步阐明本发明，应理解这些实例仅用于说明本发明而不用于限制本发明的范围，在阅读了本发明之后，本领域技术人员对本发明的各种等价形式的修改均落于本技术所附权利要求所限定的范围。
29.一种基于docker的分布式编译打包系统，如图1所示，包括一个以上的节点和调度中心，所述调度中心与节点连接，所述调度中心包括流水线与构建时间关系建立模块、最小排队等待时间的节点计算模块，所述节点包括下一次任务需要排队等待时间计算模块，其中：所述流水线与构建时间关系建立模块根据接收的流水线任务，计算每条流水线平均构建时间，建立流水线与构建时间关系。
30.所述下一次任务需要排队等待时间计算模块用于根据流水线与构建时间关系独立计算所在节点下一次任务需要排队等待时间。
31.所述下一次任务需要排队等待时间计算模块设置排队数量阈值，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。判断空位数量和流水线中的节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
32.所述节点发送下一次任务排队等待时间到调度中心。
33.所述最小排队等待时间的节点计算模块用于通过节点等待时间计算出最小排队等待时间的节点。
34.所述最小排队等待时间的节点计算模块获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
35.所述调度中心保存中每个节点排队等待时间。调度中心调度最小等待时间的节点去执行流水线构建任务。
36.一种基于docker的分布式编译打包方法，如图1所示，包括以下步骤：步骤1，计算每条流水线平均构建时间，在数据库建立流水线与构建时间关系。
37.步骤2，每个节点根据流水线与构建时间关系独立计算下一次任务需要排队等待时间。
38.计算下一次任务需要排队等待时间的方法，包括以下步骤：步骤21，设置排队数量阈值。
39.步骤22，判断当前排队数量是否高于排队数量阈值，若没高于，就进行排队。若高于，对队列中的每一个节点计算需要排队的时间。
40.步骤23，判断任务序号和当前节点总共排队时间，若任务序号不是第一个，且当前节点总共排队时间等于流水线时间，将当前节点加入流水线。若任务序号是第一个，或者当前节点总共排队时间小于流水线时间，就将当前节点作为流水线的首个节点。
41.步骤24，将所有节点流水线工作时间抵消，排队等待时间等于整个流水线工作完成时间。
42.步骤25，判断流水线的排队是否排满，若排队没排满，则返回整个流水线工作完成时间作为排队等待时间。若排队排满，把流水线最后一个节点赋予给当前节点，计算空位数量。
43.步骤26，判断空位数量和流水线中的节点哪个更多，如果空位数量大于流水线中的节点数量，则返回步骤22。如果空位数量不大于新的流水线中的节点数量，就递归计算后面的排队时间在加上当前需要排队的时间作为排队等待时间。
44.代码如下：type pipelinetime struct {
ꢀꢀꢀ
index, id, time uint
ꢀꢀꢀ
peers []pipelinetime}type nodewait struct {
ꢀꢀꢀ
limit uint
ꢀꢀꢀ
times map[uint]uint
ꢀꢀꢀ
ids []uint
ꢀꢀꢀ
size uint}func newnodewait(limit uint, ids []uint, times map[uint]uint) *nodewait {
ꢀꢀꢀ
size := len(ids)
ꢀꢀꢀ
return &nodewait{limit,times, ids, uint(size)}}func (nw *nodewait) sum() uint {
ꢀꢀꢀ
if nw.size 《 nw.limit {
ꢀꢀꢀꢀꢀꢀꢀ
return 0
ꢀꢀꢀ
}
ꢀꢀꢀ
return nw.sum(nw.ids[:nw.limit])}func (nw *nodewait) sum(ids []uint) uint {
ꢀꢀꢀ
var p pipelinetime
ꢀꢀꢀ
nw.each(ids, func(index int, id, time uint) {
ꢀꢀꢀꢀꢀꢀꢀ
v := pipelinetime{uint(index), id, time, []pipelinetime{}}
ꢀꢀꢀꢀꢀꢀꢀ
if 0 == index || time 《 p.time {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
p = v
ꢀꢀꢀꢀꢀꢀꢀ
} else if time == p.time {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
p.peers = append(p.peers, v)
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
})
ꢀꢀꢀ
nw.each(ids, func(index int, id, time uint) {
ꢀꢀꢀꢀꢀꢀꢀ
// 抵消
ꢀꢀꢀꢀꢀꢀꢀ
if time 》 p.time {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
nw.times[id] = time
ꢀ‑ꢀ
p.time
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
})
ꢀꢀꢀ
// 累计时长
ꢀꢀꢀ
wait := p.time
ꢀꢀꢀ
if nw.limit 《 nw.size {
ꢀꢀꢀꢀꢀꢀꢀ
ids[p.index] = nw.ids[nw.limit]
ꢀꢀꢀꢀꢀꢀꢀ
// 剩余
ꢀꢀꢀꢀꢀꢀꢀ
diff := nw.size
ꢀ‑ꢀ
nw.limit
ꢀ‑ꢀ1ꢀꢀꢀꢀꢀꢀꢀ
if num := uint(len(p.peers)); num 《= diff {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
var i uint = 0
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
for i=0; i《num; i {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
nw.limit
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
ids[p.peers[i].index] = nw.ids[nw.limit]
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀ
} else {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
// 空位多于流水线
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
goto end
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀ
nw.limit
ꢀꢀꢀꢀꢀꢀꢀ
wait = nw.sum(ids)
ꢀꢀꢀ
}
ꢀꢀꢀ
end:
ꢀꢀꢀ
return wait}// 遍历func (nw *nodewait) each(ids []uint, f func(index int, id, time uint)) {
ꢀꢀꢀ
for i, id := range ids {
ꢀꢀꢀꢀꢀꢀꢀ
if f != nil {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
f(i, id, nw.duration(id))
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
}}// 用时func (nw *nodewait) duration(id uint) uint {
ꢀꢀꢀ
var t uint = 600
ꢀꢀꢀ
if v, ok := nw.times[id]; ok {
ꢀꢀꢀꢀꢀꢀꢀ
t = v
ꢀꢀꢀ
}
ꢀꢀꢀ
return t}其中，func表示语言关键字，表示声明一个方法，newnodewait()表示调用名为newnodewait的方法，*nodewait表示返回类型为*nodewait，return表示返回值，sum()表示调用名为sum的方法, uint表示返回类型为uint，为算法计算的结果。
[0045]
步骤3，每个节点发送下一次任务排队等待时间到调度中心。
[0046]
步骤4，调度中心保存步骤3中每个节点排队等待时间。
[0047]
步骤5，调度中心通过节点等待时间计算出最小排队等待时间的节点。
[0048]
调度中心通过节点等待时间计算出最小排队等待时间的节点的方法：步骤51，获取所有节点。获取当前内存中运行的所有节点。遍历所有节点选择最少等待时间的节点。
[0049]
步骤52，如果当前的节点是最少排队等待时间的节点，且候选节点为空，则将当前的节点作为候选节点。如果当前的节点是最少排队等待时间的节点，且候选节点不为空，判断当前节点和候选节点哪个的排队等待时间更短，如果当前节点排队等待时间比候选节点的排队等待时间短，则将当前节点作为候选节点。
[0050]
代码如下：
func electnode() *mem.nodestat {
ꢀꢀꢀ
// 在线节点
ꢀꢀꢀ
nodes := nodeids()
ꢀꢀꢀ
// 节点时间统计
ꢀꢀꢀ
stat := mem.snapshot()
ꢀꢀꢀ
var elected *mem.nodestat
ꢀꢀꢀ
for _, node := range nodes {
ꢀꢀꢀꢀꢀꢀꢀ
if v, ok := stat[node]; ok {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if elected == nil {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
elected = v
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
continue
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if v.wait 《= elected.wait {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
elected = v
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀ
} else {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
elected = v
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
break
ꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀ
}
ꢀꢀꢀ
return elected}其中，func表示语言关键字，表示声明一个方法，electnode()表示为此方法的名称，*mem.nodestat表示返回类型为*mem.nodestat，nodes表示 读取在线节点数组的变量，stat表示读取全部在线节点的等待时间字典的变量，elected表示定义一个类型为*mem.nodestat的语言变量，计算出最少等待时间的节点后，分配到步骤6中的去执行流水线任务。
[0051]
步骤6，调度中心调度最小等待时间的节点去执行流水线构建任务。调度中心分配被计算出的节点去执行流水线构建任务。
[0052]
本发明调度中心通过节点的最小等待时间为因子，计算最佳节点来执行流水线任务，让每个节点资源都可以充分利用，避免大规模的编译打包，单机性能瓶颈问题，本发明能够解决规模化打包带来的挑战。
[0053]
以上所述仅是本发明的优选实施方式，应当指出：对于本技术领域的普通技术人员来说，在不脱离本发明原理的前提下，还可以做出若干改进和润饰，这些改进和润饰也应视为本发明的保护范围。
再多了解一些
本文用于企业家、创业者技术爱好者查询，结果仅供参考。
