fork of https://github.com/sourcegraph/zoekt
0

Configure Feed

Select the types of activity you want to include in your feed.

all: stop using the deprecated package io/ioutil (#360)

+53 -72
+1 -2
build/builder.go
··· 21 21 "flag" 22 22 "fmt" 23 23 "io" 24 - "io/ioutil" 25 24 "log" 26 25 "math" 27 26 "net/url" ··· 960 959 return nil, err 961 960 } 962 961 963 - f, err := ioutil.TempFile(dir, filepath.Base(fn)+".*.tmp") 962 + f, err := os.CreateTemp(dir, filepath.Base(fn)+".*.tmp") 964 963 if err != nil { 965 964 return nil, err 966 965 }
+2 -3
build/ctags.go
··· 17 17 import ( 18 18 "bytes" 19 19 "fmt" 20 - "io/ioutil" 21 20 "os" 22 21 "os/exec" 23 22 "path/filepath" ··· 32 31 if len(inputs) == 0 { 33 32 return nil, nil 34 33 } 35 - dir, err := ioutil.TempDir("", "ctags-input") 34 + dir, err := os.MkdirTemp("", "ctags-input") 36 35 if err != nil { 37 36 return nil, err 38 37 } ··· 53 52 if err := os.MkdirAll(filepath.Dir(full), 0o700); err != nil { 54 53 return nil, err 55 54 } 56 - err := ioutil.WriteFile(full, c, 0o600) 55 + err := os.WriteFile(full, c, 0o600) 57 56 if err != nil { 58 57 return nil, err 59 58 }
+1 -2
build/e2e_test.go
··· 19 19 "context" 20 20 "encoding/json" 21 21 "fmt" 22 - "io/ioutil" 23 22 "log" 24 23 "os" 25 24 "path/filepath" ··· 134 133 t.Fatal(err) 135 134 } 136 135 137 - if err := ioutil.WriteFile(p+".meta", b, 0600); err != nil { 136 + if err := os.WriteFile(p+".meta", b, 0600); err != nil { 138 137 t.Fatal(err) 139 138 } 140 139 }
+3 -4
cmd/zoekt-archive-index/archive.go
··· 7 7 "compress/gzip" 8 8 "fmt" 9 9 "io" 10 - "io/ioutil" 11 10 "net/http" 12 11 "net/url" 13 12 "os" ··· 43 42 } 44 43 45 44 return &File{ 46 - ReadCloser: ioutil.NopCloser(a.tr), 45 + ReadCloser: io.NopCloser(a.tr), 47 46 Name: hdr.Name, 48 47 Size: hdr.Size, 49 48 }, nil ··· 134 133 return nil, err 135 134 } 136 135 if resp.StatusCode < 200 || resp.StatusCode >= 300 { 137 - b, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1024)) 136 + b, err := io.ReadAll(io.LimitReader(resp.Body, 1024)) 138 137 _ = resp.Body.Close() 139 138 if err != nil { 140 139 return nil, err ··· 147 146 } 148 147 return resp.Body, nil 149 148 } else if u == "-" { 150 - return ioutil.NopCloser(os.Stdin), nil 149 + return io.NopCloser(os.Stdin), nil 151 150 } 152 151 153 152 return os.Open(u)
+2 -3
cmd/zoekt-archive-index/e2e_test.go
··· 9 9 "flag" 10 10 "fmt" 11 11 "io" 12 - "io/ioutil" 13 12 "log" 14 13 "os" 15 14 "strings" ··· 24 23 func TestMain(m *testing.M) { 25 24 flag.Parse() 26 25 if !testing.Verbose() { 27 - log.SetOutput(ioutil.Discard) 26 + log.SetOutput(io.Discard) 28 27 } 29 28 os.Exit(m.Run()) 30 29 } ··· 98 97 func testIndexIncrementally(t *testing.T, format string) { 99 98 indexDir := t.TempDir() 100 99 101 - archive, err := ioutil.TempFile("", "TestIndexArg-archive") 100 + archive, err := os.CreateTemp("", "TestIndexArg-archive") 102 101 if err != nil { 103 102 t.Fatalf("TempFile: %v", err) 104 103 }
+1 -2
cmd/zoekt-archive-index/main.go
··· 12 12 "flag" 13 13 "fmt" 14 14 "io" 15 - "io/ioutil" 16 15 "log" 17 16 "net/url" 18 17 "strings" ··· 161 160 add := func(f *File) error { 162 161 defer f.Close() 163 162 164 - contents, err := ioutil.ReadAll(f) 163 + contents, err := io.ReadAll(f) 165 164 if err != nil { 166 165 return err 167 166 }
+1 -2
cmd/zoekt-index/main.go
··· 17 17 import ( 18 18 "flag" 19 19 "fmt" 20 - "io/ioutil" 21 20 "log" 22 21 "os" 23 22 "path/filepath" ··· 137 136 } 138 137 continue 139 138 } 140 - content, err := ioutil.ReadFile(f.name) 139 + content, err := os.ReadFile(f.name) 141 140 if err != nil { 142 141 return err 143 142 }
+3 -3
cmd/zoekt-indexserver/config.go
··· 17 17 import ( 18 18 "bytes" 19 19 "encoding/json" 20 - "io/ioutil" 20 + "io" 21 21 "log" 22 22 "math/rand" 23 23 "net/http" ··· 79 79 } 80 80 defer rep.Body.Close() 81 81 82 - body, readErr = ioutil.ReadAll(rep.Body) 82 + body, readErr = io.ReadAll(rep.Body) 83 83 } else { 84 - body, readErr = ioutil.ReadFile(u) 84 + body, readErr = os.ReadFile(u) 85 85 } 86 86 87 87 if readErr != nil {
+1 -2
cmd/zoekt-mirror-bitbucket-server/main.go
··· 20 20 "crypto/tls" 21 21 "flag" 22 22 "fmt" 23 - "io/ioutil" 24 23 "log" 25 24 "net/http" 26 25 "net/url" ··· 74 73 if *credentialsFile == "" { 75 74 log.Fatal("must set --credentials") 76 75 } else { 77 - content, err := ioutil.ReadFile(*credentialsFile) 76 + content, err := os.ReadFile(*credentialsFile) 78 77 if err != nil { 79 78 log.Fatal(err) 80 79 }
+5 -4
cmd/zoekt-mirror-gerrit/main.go
··· 20 20 "bytes" 21 21 "flag" 22 22 "fmt" 23 - "io/ioutil" 23 + "io" 24 24 "log" 25 25 "net/http" 26 26 "net/url" 27 + "os" 27 28 "path/filepath" 28 29 "strconv" 29 30 "strings" ··· 53 54 log.Println("Rep: ", rep, err) 54 55 } 55 56 if err == nil { 56 - body, _ := ioutil.ReadAll(rep.Body) 57 + body, _ := io.ReadAll(rep.Body) 57 58 58 59 rep.Body.Close() 59 60 if debug { ··· 91 92 } 92 93 93 94 if *httpCrendentialsPath != "" { 94 - creds, err := ioutil.ReadFile(*httpCrendentialsPath) 95 + creds, err := os.ReadFile(*httpCrendentialsPath) 95 96 if err != nil { 96 97 log.Print("Cannot read gerrit http credentials, going Anonymous") 97 98 } else { ··· 206 207 if err != nil { 207 208 return err 208 209 } 209 - names[filepath.Join(u.Host, u.Path) + ".git"] = struct{}{} 210 + names[filepath.Join(u.Host, u.Path)+".git"] = struct{}{} 210 211 } 211 212 212 213 if err := gitindex.DeleteRepos(destDir, u, names, filter); err != nil {
+1 -2
cmd/zoekt-mirror-github/main.go
··· 22 22 "context" 23 23 "flag" 24 24 "fmt" 25 - "io/ioutil" 26 25 "log" 27 26 "net/url" 28 27 "os" ··· 109 108 } 110 109 111 110 if *token != "" { 112 - content, err := ioutil.ReadFile(*token) 111 + content, err := os.ReadFile(*token) 113 112 if err != nil { 114 113 log.Fatal(err) 115 114 }
+2 -2
cmd/zoekt-mirror-gitiles/cgit.go
··· 17 17 import ( 18 18 "bytes" 19 19 "fmt" 20 - "io/ioutil" 20 + "io" 21 21 "log" 22 22 "net/http" 23 23 "net/url" ··· 41 41 return nil, fmt.Errorf("status %s", rep.Status) 42 42 } 43 43 44 - c, err := ioutil.ReadAll(rep.Body) 44 + c, err := io.ReadAll(rep.Body) 45 45 if err != nil { 46 46 return nil, err 47 47 }
+2 -2
cmd/zoekt-mirror-gitiles/gitiles.go
··· 17 17 import ( 18 18 "bytes" 19 19 "encoding/json" 20 - "io/ioutil" 20 + "io" 21 21 "net/http" 22 22 "net/url" 23 23 "path" ··· 37 37 } 38 38 defer resp.Body.Close() 39 39 40 - content, err := ioutil.ReadAll(resp.Body) 40 + content, err := io.ReadAll(resp.Body) 41 41 if err != nil { 42 42 return nil, err 43 43 }
+1 -3
cmd/zoekt-mirror-gitlab/main.go
··· 21 21 // machine gitlab.com 22 22 // login oauth 23 23 // password <personal access token> 24 - // 25 24 package main 26 25 27 26 import ( 28 27 "flag" 29 28 "fmt" 30 - "io/ioutil" 31 29 "log" 32 30 "net/url" 33 31 "os" ··· 68 66 log.Fatal(err) 69 67 } 70 68 71 - content, err := ioutil.ReadFile(*token) 69 + content, err := os.ReadFile(*token) 72 70 if err != nil { 73 71 log.Fatal(err) 74 72 }
+2 -2
cmd/zoekt-repo-index/main.go
··· 32 32 "crypto/sha1" 33 33 "flag" 34 34 "fmt" 35 - "io/ioutil" 35 + "io" 36 36 "log" 37 37 "net/url" 38 38 "path" ··· 318 318 } 319 319 defer r.Close() 320 320 321 - content, _ := ioutil.ReadAll(r) 321 + content, _ := io.ReadAll(r) 322 322 return manifest.Parse(content) 323 323 } 324 324
+1 -2
cmd/zoekt-sourcegraph-indexserver/cleanup_test.go
··· 2 2 3 3 import ( 4 4 "fmt" 5 - "io/ioutil" 6 5 "net/url" 7 6 "os" 8 7 "path/filepath" ··· 159 158 } 160 159 161 160 if testing.Verbose() { 162 - data, _ := ioutil.ReadFile(filepath.Join(dir, "zoekt-indexserver-shard-log.tsv")) 161 + data, _ := os.ReadFile(filepath.Join(dir, "zoekt-indexserver-shard-log.tsv")) 163 162 if len(data) > 0 { 164 163 t.Log("shard log contents:\n" + strings.TrimSpace(string(data))) 165 164 }
+1 -2
cmd/zoekt-sourcegraph-indexserver/main.go
··· 10 10 "fmt" 11 11 "html/template" 12 12 "io" 13 - "io/ioutil" 14 13 "log" 15 14 "math" 16 15 "math/rand" ··· 183 182 repositoriesSkipSymbolsCalculationAllowList map[string]struct{} 184 183 } 185 184 186 - var debug = log.New(ioutil.Discard, "", log.LstdFlags) 185 + var debug = log.New(io.Discard, "", log.LstdFlags) 187 186 188 187 // our index commands should output something every 100mb they process. 189 188 //
+3 -3
cmd/zoekt-sourcegraph-indexserver/main_test.go
··· 3 3 import ( 4 4 "context" 5 5 "flag" 6 - "io/ioutil" 6 + "io" 7 7 "log" 8 8 "net/http" 9 9 "net/http/httptest" ··· 49 49 ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 50 50 gotURL = r.URL 51 51 52 - b, err := ioutil.ReadAll(r.Body) 52 + b, err := io.ReadAll(r.Body) 53 53 if err != nil { 54 54 t.Fatal(err) 55 55 } ··· 112 112 func TestMain(m *testing.M) { 113 113 flag.Parse() 114 114 if !testing.Verbose() { 115 - log.SetOutput(ioutil.Discard) 115 + log.SetOutput(io.Discard) 116 116 } 117 117 os.Exit(m.Run()) 118 118 }
+1 -2
cmd/zoekt-sourcegraph-indexserver/meta.go
··· 3 3 import ( 4 4 "encoding/json" 5 5 "fmt" 6 - "io/ioutil" 7 6 "os" 8 7 "path/filepath" 9 8 "syscall" ··· 89 88 return "", err 90 89 } 91 90 92 - f, err := ioutil.TempFile(filepath.Dir(p), filepath.Base(p)+".*.tmp") 91 + f, err := os.CreateTemp(filepath.Dir(p), filepath.Base(p)+".*.tmp") 93 92 if err != nil { 94 93 return "", err 95 94 }
+1 -2
cmd/zoekt-sourcegraph-indexserver/sg.go
··· 8 8 "fmt" 9 9 "hash/crc32" 10 10 "io" 11 - "io/ioutil" 12 11 "log" 13 12 "math/rand" 14 13 "net/http" ··· 270 269 defer resp.Body.Close() 271 270 272 271 if resp.StatusCode != http.StatusOK { 273 - b, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1024)) 272 + b, err := io.ReadAll(io.LimitReader(resp.Body, 1024)) 274 273 _ = resp.Body.Close() 275 274 if err != nil { 276 275 return nil, "", err
+2 -3
cmd/zoekt-test/main.go
··· 21 21 "context" 22 22 "flag" 23 23 "fmt" 24 - "io/ioutil" 25 24 "log" 26 25 "os" 27 26 "path/filepath" ··· 55 54 56 55 res := map[string][]byte{} 57 56 for _, n := range fns { 58 - c, err := ioutil.ReadFile(n) 57 + c, err := os.ReadFile(n) 59 58 if err != nil { 60 59 return nil, err 61 60 } ··· 67 66 } 68 67 69 68 func compare(dir, patfile string, caseSensitive bool) error { 70 - indexDir, err := ioutil.TempDir("", "") 69 + indexDir, err := os.MkdirTemp("", "") 71 70 if err != nil { 72 71 return err 73 72 }
+2 -3
cmd/zoekt-webserver/main.go
··· 23 23 "flag" 24 24 "fmt" 25 25 "html/template" 26 - "io/ioutil" 27 26 "log" 28 27 "net/http" 29 28 "os" ··· 87 86 88 87 log.Printf("loading templates: %v", fs) 89 88 for _, fn := range fs { 90 - content, err := ioutil.ReadFile(fn) 89 + content, err := os.ReadFile(fn) 91 90 if err != nil { 92 91 return err 93 92 } ··· 108 107 109 108 for k, v := range web.TemplateText { 110 109 nm := filepath.Join(dir, k+templateExtension) 111 - if err := ioutil.WriteFile(nm, []byte(v), 0o644); err != nil { 110 + if err := os.WriteFile(nm, []byte(v), 0o644); err != nil { 112 111 return err 113 112 } 114 113 }
+1 -2
merge.go
··· 4 4 "crypto/sha1" 5 5 "fmt" 6 6 "io" 7 - "io/ioutil" 8 7 "log" 9 8 "net/url" 10 9 "os" ··· 56 55 return err 57 56 } 58 57 59 - f, err := ioutil.TempFile(dir, filepath.Base(fn)+".*.tmp") 58 + f, err := os.CreateTemp(dir, filepath.Base(fn)+".*.tmp") 60 59 if err != nil { 61 60 return err 62 61 }
+2 -3
read_test.go
··· 21 21 "flag" 22 22 "fmt" 23 23 "io/fs" 24 - "io/ioutil" 25 24 "os" 26 25 "path" 27 26 "path/filepath" ··· 189 188 if raw, err := json.MarshalIndent(got, "", " "); err != nil { 190 189 t.Errorf("failed marshalling search results for %s during updating: %v", name, err) 191 190 continue 192 - } else if err := ioutil.WriteFile(golden, raw, 0644); err != nil { 191 + } else if err := os.WriteFile(golden, raw, 0644); err != nil { 193 192 t.Errorf("failed writing search results for %s during updating: %v", name, err) 194 193 continue 195 194 } 196 195 } 197 196 198 197 var want out 199 - if buf, err := ioutil.ReadFile(golden); err != nil { 198 + if buf, err := os.ReadFile(golden); err != nil { 200 199 t.Fatalf("failed reading search results for %s: %v", name, err) 201 200 } else if err := json.Unmarshal(buf, &want); err != nil { 202 201 t.Fatalf("failed unmarshalling search results for %s: %v", name, err)
+4 -5
shards/watcher_test.go
··· 16 16 17 17 import ( 18 18 "fmt" 19 - "io/ioutil" 20 19 "os" 21 20 "path/filepath" 22 21 "testing" ··· 60 59 // } 61 60 62 61 shard := filepath.Join(dir, "foo.zoekt") 63 - if err := ioutil.WriteFile(shard, []byte("hello"), 0o644); err != nil { 62 + if err := os.WriteFile(shard, []byte("hello"), 0o644); err != nil { 64 63 t.Fatalf("WriteFile: %v", err) 65 64 } 66 65 ··· 76 75 77 76 // Must sleep because of FS timestamp resolution. 78 77 advanceFS() 79 - if err := ioutil.WriteFile(shard, []byte("changed"), 0o644); err != nil { 78 + if err := os.WriteFile(shard, []byte("changed"), 0o644); err != nil { 80 79 t.Fatalf("WriteFile: %v", err) 81 80 } 82 81 ··· 94 93 } 95 94 96 95 advanceFS() 97 - if err := ioutil.WriteFile(shard+".bla", []byte("changed"), 0o644); err != nil { 96 + if err := os.WriteFile(shard+".bla", []byte("changed"), 0o644); err != nil { 98 97 t.Fatalf("WriteFile: %v", err) 99 98 } 100 99 ··· 189 188 for delta := -1; delta <= 1; delta++ { 190 189 repo := fmt.Sprintf("foo_v%d.00000.zoekt", want+delta) 191 190 shard := filepath.Join(dir, repo) 192 - if err := ioutil.WriteFile(shard, []byte("hello"), 0644); err != nil { 191 + if err := os.WriteFile(shard, []byte("hello"), 0644); err != nil { 193 192 t.Fatalf("WriteFile: %v", err) 194 193 } 195 194 }
+7 -7
web/e2e_test.go
··· 19 19 "context" 20 20 "encoding/json" 21 21 "fmt" 22 - "io/ioutil" 22 + "io" 23 23 "log" 24 24 "net/http" 25 25 "net/http/httptest" ··· 240 240 if err != nil { 241 241 t.Fatal(err) 242 242 } 243 - resultBytes, err := ioutil.ReadAll(res.Body) 243 + resultBytes, err := io.ReadAll(res.Body) 244 244 res.Body.Close() 245 245 if err != nil { 246 246 log.Fatal(err) ··· 617 617 if err != nil { 618 618 t.Fatal(err) 619 619 } 620 - resultBytes, err := ioutil.ReadAll(res.Body) 620 + resultBytes, err := io.ReadAll(res.Body) 621 621 res.Body.Close() 622 622 if err != nil { 623 623 log.Fatal(err) ··· 727 727 if err != nil { 728 728 t.Fatal(err) 729 729 } 730 - resultBytes, err := ioutil.ReadAll(res.Body) 730 + resultBytes, err := io.ReadAll(res.Body) 731 731 res.Body.Close() 732 732 if err != nil { 733 733 t.Fatal(err) ··· 780 780 if err != nil { 781 781 t.Fatalf("Do(%v): %v", req, err) 782 782 } 783 - resultBytes, err := ioutil.ReadAll(res.Body) 783 + resultBytes, err := io.ReadAll(res.Body) 784 784 res.Body.Close() 785 785 if err != nil { 786 786 t.Fatalf("ReadAll: %v", err) ··· 830 830 if err != nil { 831 831 t.Fatalf("Do(%v): %v", req, err) 832 832 } 833 - resultBytes, err := ioutil.ReadAll(res.Body) 833 + resultBytes, err := io.ReadAll(res.Body) 834 834 res.Body.Close() 835 835 if err != nil { 836 836 t.Fatalf("ReadAll: %v", err) ··· 879 879 if err != nil { 880 880 t.Fatalf("Do(%v): %v", req, err) 881 881 } 882 - resultBytes, err := ioutil.ReadAll(res.Body) 882 + resultBytes, err := io.ReadAll(res.Body) 883 883 res.Body.Close() 884 884 if err != nil { 885 885 t.Fatalf("ReadAll: %v", err)