]> Cypherpunks.ru repositories - goredo.git/blob - main.go
Symlinks -cleanup friendliness
[goredo.git] / main.go
1 /*
2 goredo -- redo implementation on pure Go
3 Copyright (C) 2020 Sergey Matveev <stargrave@stargrave.org>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, version 3 of the License.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18 package main
19
20 import (
21         "crypto/rand"
22         "flag"
23         "fmt"
24         "io"
25         "io/ioutil"
26         "log"
27         "os"
28         "path"
29         "path/filepath"
30         "strconv"
31         "strings"
32
33         "go.cypherpunks.ru/recfile"
34         "golang.org/x/sys/unix"
35 )
36
37 var (
38         Cwd       string
39         BuildUUID string
40 )
41
42 func mustSetenv(key, value string) {
43         if err := os.Setenv(key, value); err != nil {
44                 panic(err)
45         }
46 }
47
48 func mustParseFd(v, name string) *os.File {
49         ptr, err := strconv.ParseUint(v, 10, 64)
50         if err != nil {
51                 panic(err)
52         }
53         fd := os.NewFile(uintptr(ptr), name)
54         if fd == nil {
55                 panic("can not parse fd: " + name)
56         }
57         return fd
58 }
59
60 func main() {
61         version := flag.Bool("version", false, "print version")
62         warranty := flag.Bool("warranty", false, "print warranty information")
63         symlinks := flag.Bool("symlinks", false, "create necessary symlinks in current direcotyr")
64
65         flag.Usage = usage
66         flag.Parse()
67         if *warranty {
68                 fmt.Println(Warranty)
69                 return
70         }
71         if *version {
72                 fmt.Println(versionGet())
73                 return
74         }
75         if *symlinks {
76                 rc := 0
77                 for _, cmdName := range []string{
78                         "redo",
79                         "redo-always",
80                         "redo-cleanup",
81                         "redo-dot",
82                         "redo-ifchange",
83                         "redo-ifcreate",
84                         "redo-log",
85                         "redo-stamp",
86                         "redo-whichdo",
87                 } {
88                         fmt.Println(os.Args[0], "<-", cmdName)
89                         if err := os.Symlink(os.Args[0], cmdName); err != nil {
90                                 rc = 1
91                                 log.Println(err)
92                         }
93                 }
94                 os.Exit(rc)
95         }
96         log.SetFlags(0)
97
98         var err error
99         Cwd, err = unix.Getwd()
100         if err != nil {
101                 panic(err)
102         }
103
104         NoColor = os.Getenv(EnvNoColor) != ""
105         NoSync = os.Getenv(EnvNoSync) == "1"
106
107         TopDir = os.Getenv(EnvTopDir)
108         if TopDir == "" {
109                 TopDir = "/"
110         } else {
111                 TopDir, err = filepath.Abs(TopDir)
112                 if err != nil {
113                         panic(err)
114                 }
115         }
116
117         if *flagStderrKeep {
118                 mustSetenv(EnvStderrKeep, "1")
119         }
120         if *flagStderrSilent {
121                 mustSetenv(EnvStderrSilent, "1")
122         }
123         if *flagDebug {
124                 mustSetenv(EnvDebug, "1")
125         }
126         if *flagLogWait {
127                 mustSetenv(EnvLogWait, "1")
128         }
129         if *flagLogLock {
130                 mustSetenv(EnvLogLock, "1")
131         }
132         if *flagLogPid {
133                 mustSetenv(EnvLogPid, "1")
134         }
135         if *flagLogJS {
136                 mustSetenv(EnvLogJS, "1")
137         }
138         StderrKeep = os.Getenv(EnvStderrKeep) == "1"
139         StderrSilent = os.Getenv(EnvStderrSilent) == "1"
140         Debug = os.Getenv(EnvDebug) == "1"
141         LogWait = os.Getenv(EnvLogWait) == "1"
142         LogLock = os.Getenv(EnvLogLock) == "1"
143         LogJS = os.Getenv(EnvLogJS) == "1"
144         if Debug || os.Getenv(EnvLogPid) == "1" {
145                 MyPid = os.Getpid()
146         }
147         var traced bool
148         if *flagTraceAll {
149                 mustSetenv(EnvTrace, "1")
150         }
151         if *flagTrace {
152                 traced = true
153         } else {
154                 traced = os.Getenv(EnvTrace) == "1"
155         }
156
157         // Those are internal envs
158         StderrPrefix = os.Getenv(EnvStderrPrefix)
159         if v := os.Getenv(EnvLevel); v != "" {
160                 Level, err = strconv.Atoi(v)
161                 if err != nil {
162                         panic(err)
163                 }
164                 if Level < 0 {
165                         panic("negative " + EnvLevel)
166                 }
167         }
168         var fdDep *os.File
169         if v := os.Getenv(EnvDepFd); v != "" {
170                 fdDep = mustParseFd(v, EnvDepFd)
171         }
172         BuildUUID = os.Getenv(EnvBuildUUID)
173         if BuildUUID == "" {
174                 raw := new([16]byte)
175                 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
176                         panic(err)
177                 }
178                 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
179                 BuildUUID = fmt.Sprintf(
180                         "%x-%x-%x-%x-%x",
181                         raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
182                 )
183         }
184         statusInit()
185
186         tgts := flag.Args()
187         if len(tgts) == 0 {
188                 tgts = []string{"all"}
189         }
190         ok := true
191         err = nil
192         cmdName := path.Base(os.Args[0])
193         trace(CDebug, "[%s] run: %s %s [%s]", BuildUUID, cmdName, tgts, Cwd)
194
195 CmdSwitch:
196         switch cmdName {
197         case "redo":
198                 for _, tgt := range tgts {
199                         ok, err = ifchange([]string{tgt}, true, traced)
200                         if err != nil || !ok {
201                                 break
202                         }
203                 }
204         case "redo-ifchange":
205                 ok, err = ifchange(tgts, false, traced)
206                 writeDeps(fdDep, tgts)
207         case "redo-ifcreate":
208                 if fdDep == nil {
209                         log.Fatalln("no", EnvDepFd)
210                 }
211                 for _, tgt := range tgts {
212                         err = ifcreate(fdDep, tgt)
213                         if err != nil {
214                                 break
215                         }
216                 }
217         case "redo-always":
218                 if fdDep == nil {
219                         log.Fatalln("no", EnvDepFd)
220                 }
221                 err = always(fdDep)
222         case "redo-cleanup":
223                 for _, what := range tgts {
224                         err = cleanupWalker(Cwd, what)
225                         if err != nil {
226                                 break
227                         }
228                 }
229         case "redo-dot":
230                 err = dotPrint(tgts)
231         case "redo-stamp":
232                 if fdDep == nil {
233                         log.Fatalln("no", EnvDepFd)
234                 }
235                 err = stamp(fdDep, os.Stdin)
236         case "redo-log":
237                 if len(tgts) != 1 {
238                         log.Fatalln("single target expected")
239                 }
240                 d, t := cwdAndTgt(tgts[0])
241                 var fd *os.File
242                 fd, err = os.Open(path.Join(d, RedoDir, t+LogSuffix))
243                 if err != nil {
244                         break
245                 }
246                 _, err = io.Copy(os.Stdout, fd)
247         case "redo-whichdo":
248                 if len(tgts) != 1 {
249                         log.Fatalln("single target expected")
250                 }
251                 var fdTmp *os.File
252                 fdTmp, err = ioutil.TempFile("", "")
253                 if err != nil {
254                         break
255                 }
256                 os.Remove(fdTmp.Name())
257                 cwd, tgt := cwdAndTgt(tgts[0])
258                 doFile, upLevels, err := findDo(fdTmp, cwd, tgt)
259                 if err != nil {
260                         break
261                 }
262                 _, err = fdTmp.Seek(0, 0)
263                 if err != nil {
264                         break
265                 }
266                 r := recfile.NewReader(fdTmp)
267                 for {
268                         m, err := r.NextMap()
269                         if err != nil {
270                                 if err == io.EOF {
271                                         break
272                                 }
273                                 break CmdSwitch
274                         }
275                         fmt.Println(cwdMustRel(cwd, m["Target"]))
276                 }
277                 if doFile == "" {
278                         ok = false
279                 } else {
280                         fmt.Println(path.Join(strings.Repeat("..", upLevels), doFile))
281                 }
282         default:
283                 log.Fatalln("unknown command", cmdName)
284         }
285         if err != nil {
286                 log.Println(err)
287         }
288         rc := 0
289         if !ok || err != nil {
290                 rc = 1
291         }
292         trace(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)
293         os.Exit(rc)
294 }