darwinia-shadow 0.2.5

The shadow service for relayers and verify workers to retrieve header data and generate proof.
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

package shadow

import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strconv"
	"strings"
)

// Lock enum
type Lock string

const (
	PROOF_LOCK Lock = "proof.lock"
	EPOCH_LOCK Lock = "epoch.lock"
)

func (l *Lock) toString() string {
	return string(*l)
}

func (c *Config) checkLockExists(filename string, epoch uint64) (bool, error) {
	// Read the content of the lock
	content, err := ioutil.ReadFile(filename)
	if err != nil {
		return false, err
	}

	// Get file content
	text := string(content)
	epochString := strconv.Itoa(int(epoch))
	epochs := strings.Split(text, ",")

	// Check if element exists
	for _, e := range epochs {
		if e == epochString {
			return true, nil
		}
	}

	/// Append new lock
	f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return false, err
	}
	defer f.Close()
	if _, err := f.WriteString(fmt.Sprintf(",%d", epoch)); err != nil {
		return false, err
	}

	return false, nil
}

// Create lock
func (c *Config) CreateLock(lock Lock, epoch uint64) error {
	p := filepath.Join(c.Root, lock.toString())
	if _, err := os.Stat(p); os.IsNotExist(err) {
		_, err = os.Create(p)
		if err != nil {
			return err
		}

		err = ioutil.WriteFile(p, []byte(fmt.Sprintf("%d", epoch)), 0600)
		if err != nil {
			return err
		}

	} else {
		exists, err := c.checkLockExists(p, epoch)
		if err != nil {
			return err
		}

		if exists {
			return errors.New("The target ethash epoch is in process, shadow service is busy")
		}
	}

	return nil
}

// Remove lock
func (c *Config) RemoveLock(lock Lock, epoch uint64) error {
	p := filepath.Join(c.Root, lock.toString())
	if _, err := os.Stat(p); os.IsNotExist(err) {
		return nil
	}

	// Get content
	content, err := ioutil.ReadFile(p)
	if err != nil {
		return err
	}

	epochs := strings.Split(string(content), ",")
	if len(epochs) < 1 {
		err = os.Remove(p)
		if err != nil {
			return err
		}
	}

	// Compare epoch
	epochString := strconv.Itoa(int(epoch))
	newEpochs := []string{}
	for _, e := range epochs {
		if e != epochString {
			newEpochs = append(newEpochs, fmt.Sprintf(",%s", epochString))
		}
	}

	// Update lock file
	err = ioutil.WriteFile(p, []byte(strings.Join(newEpochs, ",")), 0600)
	if err != nil {
		return err
	}

	return nil
}