/
signer.go
131 lines (113 loc) · 2.41 KB
/
signer.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package main
import (
"sort"
"strconv"
"strings"
"sync"
)
func ExecutePipeline(jobs ...job) {
in := make(chan interface{}, 100)
out := make(chan interface{}, 100)
wg := &sync.WaitGroup{}
for _, job := range jobs {
wg.Add(1)
go worker(wg, job, in, out)
in = out
out = make(chan interface{}, 100)
}
wg.Wait()
}
func worker(waiter *sync.WaitGroup, j job, in, out chan interface{}) {
defer waiter.Done()
defer close(out)
j(in, out)
}
func SingleHash(in, out chan interface{}) {
var mu sync.Mutex
wgSingleHash := &sync.WaitGroup{}
for input := range in {
wgSingleHash.Add(1)
go func(in interface{}) {
defer wgSingleHash.Done()
value, ok := in.(int)
if !ok {
panic("sh: failed type assertion")
}
data := strconv.Itoa(value)
mu.Lock()
md5hash := DataSignerMd5(data)
mu.Unlock()
mData := map[string]string{
"data": data,
"md5hash": md5hash,
}
nmData := make(map[string]string, 2)
wg := &sync.WaitGroup{}
for k := range mData {
wg.Add(1)
go func(key string) {
defer wg.Done()
hash := DataSignerCrc32(mData[key])
mu.Lock()
nmData[key] = hash
mu.Unlock()
}(k)
}
wg.Wait()
result := nmData["data"] + "~" + nmData["md5hash"]
out <- result
}(input)
}
wgSingleHash.Wait()
}
func MultiHash(in, out chan interface{}) {
wgMultiHash := &sync.WaitGroup{}
for input := range in {
wgMultiHash.Add(1)
go func(in interface{}) {
defer wgMultiHash.Done()
data, ok := in.(string)
if !ok {
panic("mh: failed type assertion")
}
wg := &sync.WaitGroup{}
mu := &sync.Mutex{}
mData := make(map[int]string, 6)
for th := 0; th < 6; th++ {
wg.Add(1)
go func(mData map[int]string, th int, data string) {
defer wg.Done()
hash := DataSignerCrc32(strconv.Itoa(th) + data)
mu.Lock()
mData[th] = hash
mu.Unlock()
}(mData, th, data)
}
wg.Wait()
keys := make([]int, 0, len(mData))
for k, _ := range mData {
keys = append(keys, k)
}
sort.Ints(keys)
var result string
for k := range keys {
result += mData[k]
}
out <- result
}(input)
}
wgMultiHash.Wait()
}
func CombineResults(in, out chan interface{}) {
var hashes []string
for input := range in {
data, ok := input.(string)
if !ok {
panic("cr: failed type assertion")
}
hashes = append(hashes, data)
}
sort.Strings(hashes)
result := strings.Join(hashes, "_")
out <- result
}