将一片分割成N片

Question

我试图实现一个函数，该函数将TCP端口的一个片段分割为x其他块。这些切片将被发送给将扫描这些端口的工作人员，因此x是由工人的数量设置的。

以下是代码：

// createJobs split portsToScan from a specified protocol into an equal number
// of jobs that will be returned.
func (t *Target) createJobs(proto string) ([]jobMsg, error) {
    // init jobs slice
    jobs := []jobMsg{}

    // check protocol accordance
    if _, ok := t.portsToScan[proto]; !ok {
        return nil, fmt.Errorf("no such protocol %q in current protocol list", proto)
    }

    // if proto is ICMP, we do not need to scan ports
    if proto == "icmp" {
        return []jobMsg{
            jobMsg{ip: t.ip, protocol: proto},
        }, nil
    }

    step := (len(t.portsToScan[proto]) + t.workers - 1) / t.workers

    for i := 0; i < len(t.portsToScan[proto]); i += step {
        batch := t.portsToScan[proto][i:min(i+step, len(t.portsToScan[proto]))]

        jobs = append(jobs, jobMsg{
            ip:       t.ip,
            protocol: proto,
            ports:    batch,
        })
    }

    return jobs, nil
}

下面是相应的单元测试：

func TestTarget_createJobs(t *testing.T) {
    tests := []struct {
        name         string
        pts          map[string][]string
        workersCount int
        wantErr      bool
    }{
        {
            name:         "5-1",
            pts:          map[string][]string{"tcp": []string{"1", "2", "3", "4", "5"}},
            workersCount: 1,
        },
        {
            name:         "5-2",
            pts:          map[string][]string{"tcp": []string{"1", "2", "3", "4", "5"}},
            workersCount: 2,
        },
        {
            name:         "5-3",
            pts:          map[string][]string{"tcp": []string{"1", "2", "3", "4", "5"}},
            workersCount: 3,
        },
        {
            name:         "5-4",
            pts:          map[string][]string{"tcp": []string{"1", "2", "3", "4", "5"}},
            workersCount: 4,
        },
        {
            name:         "5-5",
            pts:          map[string][]string{"tcp": []string{"1", "2", "3", "4", "5"}},
            workersCount: 5,
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            tg := &Target{
                portsToScan: tt.pts,
                workers:     tt.workersCount,
            }
            got, err := tg.createJobs("tcp")
            if (err != nil) != tt.wantErr {
                t.Errorf("Target.createJobs() error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if len(got) != tt.workersCount {
                t.Errorf("Target.createJobs() = %d, wanted %d jobs; joblist %v", len(got), tt.workersCount, got)
            }
        })
    }
}


func min(a, b int) int {
    if a <= b {
        return a
    }
    return b
}

测试的输出给了我这个结果：

--- FAIL: TestTarget_createJobs/5-4 (0.00s)
scan_test.go:309: Target.createJobs() = 3, wanted 4 jobs; joblist [{ 0  tcp [1 2]} { 0  tcp [3 4]} { 0  tcp [5]}]

初始端口列表保存在t.portsToScan[proto]中，工人数量(因此我想要创建的片数)由t.workers设置。

最后，len(jobs)必须与t.workers相等，但我无法找到如何做到这一点。

Answer 1

算法使用step作为批处理的大小：

step := (len(t.portsToScan[proto]) + t.workers - 1) / t.workers

这不是最佳尺寸。例如，如果您有4个端口要扫描和3个工作人员，这将导致step = 2，这意味着您将只有2个作业(2+2=4)。但是，有3批(尺寸为2+1+1=4)会更好(更理想)。

所以批次的大小应该是

defSize := len(t.portsToScan[proto]) / t.workers

这样做的问题是，如果长度不是t.workers的倍数，那么最后一些元素(端口)将不会分配给任何作业。在所有的作业中使用defSize+1将是太多了。

因此，最优的解决方案是在“中间”：一些作业将有defSize端口进行扫描，而有些作业将具有defSize+1。必须有多少人有defSize+1？如果所有人都有defSize的话，失踪的人数也一样多

numBigger := len(t.portsToScan[proto]) - defSize*t.workers

请注意，如果需要扫描的端口比工作人员少，上述计算将产生defSize=0，因此一些工作人员将获得0端口，而一些工作人员将得到1。这是可以的，但您不应该添加带有0端口的作业以进行扫描。

使用此发行版：

defSize := len(t.portsToScan[proto]) / t.workers
numBigger := len(t.portsToScan[proto]) - defSize*t.workers

size := defSize+1
for i, idx := 0, 0; i < t.workers; i++ {
    if i == numBigger {
        size--
        if size == 0 {
            break // 0 ports left to scan
        }
    }
    jobs = append(jobs, jobMsg{
        ip:       t.ip,
        protocol: proto,
        ports:    t.portsToScan[proto][idx : idx+size],
    })
    idx += size
}