/
repository.go
179 lines (162 loc) · 4.77 KB
/
repository.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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
package main
import (
"fmt"
"github.com/BurntSushi/toml"
"github.com/fatih/color"
"github.com/getsentry/raven-go"
"gopkg.in/src-d/go-git.v4"
"io/ioutil"
"log"
"os"
"path/filepath"
"strings"
)
type Repository struct {
Name string
LocalFolder string
Vendor string
Port string
}
type RepositoryMetaInfo struct {
Config string
Dependency string
DiskSize float64
Readme string
}
type solver struct {
Name string
Class string
}
type solvers struct {
Solvers []solver
}
type RepoSolver struct {
Vendor string
Package string
SolverName string
Port string
}
func readRepos() []Repository {
configs := readConfig()
repos := configs.Repositories
return repos
}
func readClientRepos(currentHomedir string) []Repository {
configs := readClientConfig(currentHomedir)
repos := configs.Repositories
return repos
}
func addRepo(repos []Repository, repo Repository) []Repository {
alreadyInstalled := false
for _, existed_repo := range repos {
if repo.Name == existed_repo.Name && repo.Vendor == existed_repo.Vendor {
alreadyInstalled = true
}
}
if alreadyInstalled {
log.Fatal("Repo Already Exists! Remove it first.")
}
repos = append(repos, repo)
return repos
}
func delRepo(repos []Repository, Vendor string, Name string) []Repository {
for i, repo := range repos {
if repo.Name == Name && repo.Vendor == Vendor {
repos = append(repos[:i], repos[i+1:]...)
}
}
return repos
}
func runRepo(Vendor string, Name string, Solver string, Port string) {
repos := readRepos()
existed := false
for _, existed_repo := range repos {
if existed_repo.Name == Name && existed_repo.Vendor == Vendor {
files, _ := ioutil.ReadDir(existed_repo.LocalFolder)
for _, file := range files {
if file.Name() == "runner_"+Solver+".py" {
existed = true
RunningRepos = append(RunningRepos, Repository{Vendor, Name, Solver, Port})
RunningSolvers = append(RunningSolvers, RepoSolver{Vendor: Vendor, Package: Name, SolverName: Solver, Port: Port})
runfileFullPath := filepath.Join(existed_repo.LocalFolder, file.Name())
python([]string{runfileFullPath, Port})
}
}
}
}
if !existed {
log.Fatal("Solver Not Found! Expecting " + Solver)
}
}
func CloneFromGit(remoteURL string, targetFolder string) Repository {
localFolderName := strings.Split(remoteURL, "/")
vendorName := localFolderName[len(localFolderName)-2]
repoName := localFolderName[len(localFolderName)-1]
localFolder := filepath.Join(targetFolder, vendorName, repoName)
color.Cyan("Cloning " + remoteURL + " into " + localFolder)
_, err := git.PlainClone(localFolder, false, &git.CloneOptions{
URL: remoteURL,
Progress: os.Stdout,
})
if err != nil {
raven.CaptureErrorAndWait(err, nil)
fmt.Println(err)
}
repo := Repository{Name: repoName, Vendor: vendorName, LocalFolder: localFolder}
return repo
}
func InstallDependencies(localFolder string) {
pip([]string{"install", "-r", filepath.Join(localFolder, "requirements.txt"), "--user"})
}
// Generating Runners for future use
func GeneratingRunners(localFolder string) {
var mySolvers solvers
cvpmFile := filepath.Join(localFolder, "cvpm.toml")
if _, err := toml.DecodeFile(cvpmFile, &mySolvers); err != nil {
log.Fatal(err)
}
renderRunnerTpl(localFolder, mySolvers)
}
// After Installation
// Return Repository Meta Info: Dependency, Config, Disk Size and Readme
func GetMetaInfo(Vendor string, Name string) RepositoryMetaInfo {
repos := readRepos()
repositoryMeta := RepositoryMetaInfo{}
for _, existed_repo := range repos {
if existed_repo.Name == Name && existed_repo.Vendor == Vendor {
// Read config file etc
byte_config, err := ioutil.ReadFile(filepath.Join(existed_repo.LocalFolder, "cvpm.toml"))
if err != nil {
repositoryMeta.Config = "Read cvpm.toml failed"
} else {
repositoryMeta.Config = string(byte_config)
}
byte_dependency, err := ioutil.ReadFile(filepath.Join(existed_repo.LocalFolder, "requirements.txt"))
if err != nil {
repositoryMeta.Dependency = "Read requirements.txt failed"
} else {
repositoryMeta.Dependency = string(byte_dependency)
}
byte_readme, err := ioutil.ReadFile(filepath.Join(existed_repo.LocalFolder, "README.md"))
if err != nil {
repositoryMeta.Readme = "Read Readme.md failed"
} else {
repositoryMeta.Readme = string(byte_readme)
}
packageSize := getDirSizeMB(existed_repo.LocalFolder)
repositoryMeta.DiskSize = packageSize
}
}
return repositoryMeta
}
// Install Repository from Git
func InstallFromGit(remoteURL string) {
config := readConfig()
var repo Repository
repo = CloneFromGit(remoteURL, config.Local.LocalFolder)
repoFolder := repo.LocalFolder
InstallDependencies(repoFolder)
GeneratingRunners(repoFolder)
config.Repositories = addRepo(config.Repositories, repo)
writeConfig(config)
}