pupirka

1
package main
2

3
import (
4
	"fmt"
5
	"gopkg.in/src-d/go-git.v4"
6
	"gopkg.in/src-d/go-git.v4/plumbing"
7
	"gopkg.in/src-d/go-git.v4/plumbing/object"
8
	"gopkg.in/src-d/go-git.v4/plumbing/transport/http"
9
	"time"
10
)
11

12
type GitClient struct {
13
	Folder     string
14
	Repo       string
15
	Token      string
16
	NeedPush   bool
17
	RepoUrl    string
18
	Auth       http.BasicAuth
19
	Branch     plumbing.ReferenceName
20
	Repository *git.Repository
21
}
22

23
var gitClient GitClient
24

25
func RunGlobalPreStart() error {
26

27
	gitClient.Folder = ConfigV.GetString("path.backup")
28
	gitClient.RepoUrl = ConfigV.GetString("git.remote")
29
	if gitClient.CheckRepo() == false {
30
		return nil
31
	}
32
	if gitClient.RepoUrl == "" {
33
		rep, err := git.PlainOpen(gitClient.Folder)
34
		if err != nil {
35
			return err
36
		}
37
		gitClient.Repository = rep
38
		return nil
39
	}
40
	gitClient.Auth = struct{ Username, Password string }{Username: ConfigV.GetString("git.user"), Password: ConfigV.GetString("git.password")}
41
	rep, err := git.PlainClone(gitClient.Folder, false, &git.CloneOptions{
42
		URL:           gitClient.RepoUrl,
43
		Auth:          &gitClient.Auth,
44
		ReferenceName: plumbing.NewBranchReferenceName(ConfigV.GetString("git.branch")),
45
		SingleBranch:  true,
46
	})
47
	if err == git.ErrRepositoryAlreadyExists {
48
		rep, err := git.PlainOpen(gitClient.Folder)
49
		if err != nil {
50
			return err
51
		}
52
		gitClient.Repository = rep
53
		return nil
54
	}
55
	if err != nil {
56
		return err
57
	}
58
	gitClient.Repository = rep
59

60
	return nil
61
}
62

63
func (c *GitClient) AddFile(filename string) error {
64
	if c.CheckRepo() == false {
65
		return nil
66
	}
67
	LogConsole.Infof("Adding File %s to repo", filename)
68
	w, err := c.Repository.Worktree()
69
	if err != nil {
70
		LogConsole.Errorf("Error git get WorkTree: %s", err.Error())
71
		return err
72
	}
73
	_, err = w.Status()
74
	if err != nil {
75
		LogConsole.Errorf("Error git get WorkTree Status: %s", err.Error())
76
		return err
77
	}
78
	if len(filename) > len(c.Folder) {
79
		if filename[:len(c.Folder)] == c.Folder {
80
			filename = filename[len(c.Folder)+1:]
81
		}
82
	}
83
	_, err = w.Add(filename)
84
	if err != nil {
85
		LogConsole.Errorf("Error git WorkTree add file: %s %s", err.Error(), filename)
86
		return err
87
	}
88

89
	commitName := fmt.Sprintf("Added File Automated %s", filename)
90
	commit, err := w.Commit(commitName, &git.CommitOptions{
91
		Author: &object.Signature{
92
			Name:  ConfigV.GetString("git.name"),
93
			Email: ConfigV.GetString("git.user"),
94
			When:  time.Now(),
95
		},
96
	})
97
	_, err = c.Repository.CommitObject(commit)
98
	if err != nil {
99
		LogConsole.Infof("Error git Commit name:%s", commitName)
100
		return err
101
	}
102
	if c.RepoUrl != "" {
103
		c.NeedPush = true
104
	}
105
	return nil
106
}
107
func (c *GitClient) RemoveFile(filename string) error {
108
	if c.CheckRepo() == false {
109
		return nil
110
	}
111
	LogConsole.Infof("Remove File %s to repo", filename)
112
	w, err := c.Repository.Worktree()
113
	if err != nil {
114
		LogConsole.Errorf("Error git get WorkTree: %s", err.Error())
115
		return err
116
	}
117
	_, err = w.Status()
118
	if err != nil {
119
		LogConsole.Errorf("Error git get WorkTree Status: %s", err.Error())
120
		return err
121
	}
122
	if len(filename) > len(c.Folder) {
123
		if filename[:len(c.Folder)] == c.Folder {
124
			filename = filename[len(c.Folder)+1:]
125
		}
126
	}
127
	_, err = w.Remove(filename)
128
	if err != nil {
129
		LogConsole.Errorf("Error git WorkTree add file: %s %s", err.Error(), filename)
130
		return err
131
	}
132
	commitName := fmt.Sprintf("Remove File Automated %s", filename)
133
	commit, err := w.Commit(commitName, &git.CommitOptions{
134
		Author: &object.Signature{
135
			Name:  "Pupirka",
136
			Email: ConfigV.GetString("git.user"),
137
			When:  time.Now(),
138
		},
139
	})
140
	_, err = c.Repository.CommitObject(commit)
141
	if err != nil {
142
		LogConsole.Infof("Error git Commit name:%s", commitName)
143
		return err
144
	}
145
	if c.RepoUrl != "" {
146
		c.NeedPush = true
147
	}
148

149
	return nil
150
}
151

152
func (c *GitClient) CheckPush() error {
153
	if c.CheckRepo() == false {
154
		return nil
155
	}
156
	if c.NeedPush {
157
		return c.Push()
158
	}
159
	return nil
160
}
161

162
func (c *GitClient) Push() error {
163
	if c.CheckRepo() == false {
164
		return nil
165
	}
166

167
	err := c.Repository.Push(&git.PushOptions{
168
		Auth: &c.Auth,
169
	})
170
	if err == git.NoErrAlreadyUpToDate {
171
		return nil
172
	}
173
	if err != nil {
174
		LogConsole.Warn(err.Error())
175
		return err
176
	}
177
	LogConsole.Infof("git Push remote: %s", c.RepoUrl)
178
	c.NeedPush = false
179
	return nil
180
}
181

182
func (c *GitClient) SetCommit(filename string) error {
183
	if c.CheckRepo() == false {
184
		return nil
185
	}
186
	LogConsole.Infof("Change File %s to repo", filename)
187
	w, err := c.Repository.Worktree()
188
	if err != nil {
189
		LogConsole.Error(fmt.Sprintf("Error git get WorkTree: %s", err.Error()))
190
		return err
191
	}
192

193
	_, err = w.Status()
194
	if err != nil {
195
		LogConsole.Error(fmt.Sprintf("Error git get WorkTree Status: %s", err.Error()))
196
		return err
197
	}
198
	if len(filename) > len(c.Folder) {
199
		if filename[:len(c.Folder)] == c.Folder {
200
			filename = filename[len(c.Folder)+1:]
201
		}
202
	}
203
	_, err = w.Add(filename)
204
	if err != nil {
205
		LogConsole.Error(fmt.Sprintf("Error git WorkTree add file: %s %s", err.Error(), filename))
206
		return err
207
	}
208
	commitName := fmt.Sprintf("Change File %s", filename)
209
	commit, err := w.Commit(commitName, &git.CommitOptions{
210
		Author: &object.Signature{
211
			Name:  ConfigV.GetString("git.user"),
212
			Email: ConfigV.GetString("git.email"),
213
			When:  time.Now(),
214
		},
215
	})
216
	_, err = c.Repository.CommitObject(commit)
217
	if err != nil {
218
		LogConsole.Error(fmt.Sprintf("Error git Commit name:%s", commitName))
219
		return err
220
	}
221
	c.NeedPush = true
222
	return nil
223
}
224

225
func (c *GitClient) CheckRepo() bool {
226
	if c.RepoUrl == "" {
227
		return false
228
	}
229
	return true
230
}
231