-
-
Notifications
You must be signed in to change notification settings - Fork 210
/
curseforge.go
364 lines (329 loc) · 11.1 KB
/
curseforge.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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
package curseforge
import (
"errors"
"github.com/pufferpanel/pufferpanel/v3"
"github.com/pufferpanel/pufferpanel/v3/logging"
"io"
"net/http"
"os"
"path/filepath"
"regexp"
"strings"
)
type CurseForge struct {
ProjectId uint
FileId uint
JavaBinary string
}
//new plan
//download curseforge to cache if not present (curseforge/projectid/fileid)
//extract from cache to server directory
//determine modloader to use (do this via 3 ways)
//- is there a forge installer present
//- is there a variables.txt present
//- what does the client manifest.json indicate
//install desired mod loader
//- forge
//- download installer to cache if not present
//- run installer into cache dir
//- copy directory to server
//- fabric
//- check if either installer is in the cache
//- download improved launcher to the cache
//- download "old" installer to the cache
//- run installer in cache
//- copy directory to server
//- neoforge
//- not dealing with for now
//- quilt
//- will not deal with
var forgeInstallerRegex = regexp.MustCompile("forge-.*-installer.jar")
var errNoFile = errors.New("status code 404")
var FabricInstallerUrl = "https://maven.fabricmc.net/net/fabricmc/fabric-installer/${installerVersion}/fabric-installer-${installerVersion}.jar"
var ImprovedFabricInstallerUrl = "https://meta.fabricmc.net/v2/versions/loader/${mcVersion}/${version}/${installerVersion}/server/jar"
var ForgeInstallerUrl = "https://maven.minecraftforge.net/net/minecraftforge/forge/${mcVersion}-${version}/forge-${mcVersion}-${version}-installer.jar"
var ForgeInstallerName = "forge-${mcVersion}-${version}-installer.jar"
func (c CurseForge) Run(args pufferpanel.RunOperatorArgs) pufferpanel.OperationResult {
env := args.Environment
var clientFile, serverFile File
var err error
if c.FileId == 0 {
//we need to get the latest file id to do our calls
files, err := getLatestFiles(c.ProjectId)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
for _, v := range files {
if !IsAllowedFile(v.FileStatus) {
continue
}
if v.ReleaseType != ReleaseFileType {
continue
}
if serverFile.FileDate.Before(v.FileDate) {
serverFile = v
continue
}
}
if serverFile.Id == 0 {
err = errors.New("no files available on CurseForge")
return pufferpanel.OperationResult{Error: err}
}
} else {
serverFile, err = getFileById(c.ProjectId, c.FileId)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
}
if !serverFile.IsServerPack && serverFile.ServerPackFileId != 0 {
clientFile = serverFile
serverFile, err = getFileById(c.ProjectId, serverFile.ServerPackFileId)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
}
if clientFile.Id == 0 && serverFile.ParentProjectFileId != 0 {
clientFile, err = getFileById(c.ProjectId, serverFile.ParentProjectFileId)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
}
if !serverFile.IsServerPack {
logging.Debug.Printf("File ID %d is not marked as a server pack, will not install\n", serverFile.Id)
env.DisplayToConsole(true, "File ID %d is not marked as a server pack, will not install\n", serverFile.Id)
return pufferpanel.OperationResult{Error: errors.New("not server pack")}
}
logging.Debug.Printf("Downloading modpack from %s\n", serverFile.DownloadUrl)
env.DisplayToConsole(true, "Downloading modpack from %s", serverFile.DownloadUrl)
err = downloadModpack(serverFile)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
if clientFile.Id != 0 {
logging.Debug.Printf("Downloading client modpack from %s\n", serverFile.DownloadUrl)
env.DisplayToConsole(true, "Downloading client modpack from %s", serverFile.DownloadUrl)
err = downloadModpack(clientFile)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
}
serverZipPath := getCacheFilePath(serverFile)
logging.Debug.Printf("Extracting modpack from %s\n", serverZipPath)
env.DisplayToConsole(true, "Extracting modpack from %s", serverZipPath)
err = pufferpanel.Extract(nil, serverZipPath, env.GetRootDirectory(), "*", true, nil)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
//modpack now downloaded and extracted
//worse case, this is all we could do...
//best case, we can get the modpack set up how we need it
//set 1: resolve the pack to a "modloader"
var modLoader string
var data = make(map[string]string)
var jar string
var vars map[string]string
var manifest Manifest
if jar, err = findForgeInstallerJar(env); err == nil {
modLoader = "forge"
data["jar"] = jar
} else if vars, err = readVariableFile(serverFile); err == nil {
modLoader = strings.ToLower(vars["MODLOADER"])
data["mcVersion"] = vars["MINECRAFT_VERSION"]
data["version"] = vars["MODLOADER_VERSION"]
data["installerVersion"] = vars["FABRIC_INSTALLER_VERSION"]
} else if manifest, err = getManifest(clientFile); err == nil {
mcVersion := manifest.Minecraft.Version
var loaderVersion string
for _, v := range manifest.Minecraft.ModLoaders {
if v.Primary {
loaderVersion = v.Id
break
}
}
parts := strings.SplitN(loaderVersion, "-", 2)
modLoader = parts[0]
data["mcVersion"] = mcVersion
data["version"] = parts[1]
} else {
//give up
env.DisplayToConsole(true, "Unknown server type. Could not prepare server for actual execution")
return pufferpanel.OperationResult{Error: nil}
}
//we figured out the loader, now to run their "installer"
switch modLoader {
case "forge":
{
//for forge, we need a jar
//so, if we don't have one already, we'll have to get it
jarFile := data["jar"]
if jarFile == "" {
forgeUrl := replaceTokens(ForgeInstallerUrl, data)
forgeInstaller := replaceTokens(ForgeInstallerName, data)
jarFile, err = pufferpanel.DownloadViaMaven(forgeUrl, env)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
//copy to server
err = pufferpanel.CopyFile(jarFile, filepath.Join(env.GetRootDirectory(), forgeInstaller))
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
jarFile = forgeInstaller
}
err = installForgeViaJar(env, jarFile, c.JavaBinary)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
}
case "fabric":
{
err = installFabric(env, data, c.JavaBinary)
if err != nil {
return pufferpanel.OperationResult{Error: err}
}
}
default:
{
env.DisplayToConsole(true, "Unsupported server type. Could not prepare server for actual execution")
return pufferpanel.OperationResult{Error: nil}
}
}
//loaders installed, at this stage, we're "done"
env.DisplayToConsole(true, "Pack installed and should be good to go!")
return pufferpanel.OperationResult{Error: nil}
}
func findForgeInstallerJar(env pufferpanel.Environment) (string, error) {
entries, err := os.ReadDir(env.GetRootDirectory())
if err != nil {
return "", err
}
for _, v := range entries {
if v.IsDir() {
continue
}
if forgeInstallerRegex.MatchString(v.Name()) {
return v.Name(), nil
}
}
return "", os.ErrNotExist
}
func installForgeViaJar(env pufferpanel.Environment, jarFile string, javaBinary string) error {
//forge installer found, we will run this one
result := make(chan int, 1)
err := env.Execute(pufferpanel.ExecutionData{
Command: javaBinary,
Arguments: []string{"-jar", jarFile, "--installServer"},
Callback: func(exitCode int) {
result <- exitCode
env.DisplayToConsole(true, "Installer exit code: %d", exitCode)
},
})
if err != nil {
return err
}
if <-result != 0 {
return errors.New("failed to run forge installer")
}
//delete installer now
err = os.Remove(filepath.Join(env.GetRootDirectory(), jarFile))
err = os.Remove(filepath.Join(env.GetRootDirectory(), jarFile+".log"))
if err != nil {
env.DisplayToConsole(true, "Failed to delete installer")
}
//if this is before 1.16, we have a root jar
//or if there's a shim
possibleRenames := []string{
strings.Replace(jarFile, "-installer", "", 1), //pre 1.17 forge
strings.Replace(jarFile, "-installer", "-shim", 1), //forge shim
}
var fi os.FileInfo
for _, f := range possibleRenames {
if fi, err = os.Lstat(filepath.Join(env.GetRootDirectory(), f)); err == nil && !fi.IsDir() {
err = os.Rename(filepath.Join(env.GetRootDirectory(), f), filepath.Join(env.GetRootDirectory(), "server.jar"))
if err != nil {
return err
}
} else if fi, err = os.Lstat(filepath.Join(env.GetRootDirectory(), f)); err == nil && !fi.IsDir() {
err = os.Rename(filepath.Join(env.GetRootDirectory(), f), filepath.Join(env.GetRootDirectory(), "server.jar"))
if err != nil {
return err
}
}
}
return nil
}
func installFabric(env pufferpanel.Environment, data map[string]string, javaBinary string) error {
//this is a mess
//there's 2 options that exist for fabric
//there is an "improved" launcher, which is just a jar that we need
//or we have to pull the installer and run it
//see if improved is available
fabricUrl := replaceTokens(ImprovedFabricInstallerUrl, data)
targetFile := filepath.Join(env.GetRootDirectory(), "server.jar")
env.DisplayToConsole(true, "Downloading %s to %s", fabricUrl, targetFile)
err := downloadFile(fabricUrl, targetFile)
if err == nil {
//this was a good file, we got what we need
return nil
} else if !errors.Is(err, errNoFile) {
//we got a 404, so we can't use the improved version at all
fabricUrl = replaceTokens(FabricInstallerUrl, data)
targetFile = filepath.Join(env.GetRootDirectory(), "fabric-installer.jar")
env.DisplayToConsole(true, "Downloading %s to %s", fabricUrl, targetFile)
err = downloadFile(fabricUrl, targetFile)
if err != nil {
return err
}
//forge installer found, we will run this one
result := make(chan int, 1)
err = env.Execute(pufferpanel.ExecutionData{
Command: javaBinary,
Arguments: []string{"-jar", "fabric-installer", "server", "-mcversion", data["mcVersion"], "-loader", data["version"], "-downloadMinecraft"},
Callback: func(exitCode int) {
result <- exitCode
env.DisplayToConsole(true, "Installer exit code: %d", exitCode)
},
})
if err != nil {
return err
}
if <-result != 0 {
return errors.New("failed to run fabric installer")
}
//delete installer now
err = os.Remove(filepath.Join(env.GetRootDirectory(), "fabric-installer.jar"))
if err != nil {
env.DisplayToConsole(true, "Failed to delete installer")
}
//replace jar with the fabric jar
_ = os.Remove(filepath.Join(env.GetRootDirectory(), "server.jar"))
err = os.Rename(filepath.Join(env.GetRootDirectory(), "fabric-server-launch.jar"), filepath.Join(env.GetRootDirectory(), "server.jar"))
return err
} else {
return err
}
}
func downloadFile(url, target string) error {
file, err := os.Create(target)
if err != nil {
return err
}
defer pufferpanel.Close(file)
response, err := pufferpanel.Http().Get(url)
defer pufferpanel.CloseResponse(response)
if err != nil {
return err
}
if response.StatusCode == http.StatusNotFound {
return errNoFile
}
_, err = io.Copy(file, response.Body)
return err
}
func replaceTokens(msg string, data map[string]string) string {
result := msg
for k, v := range data {
result = strings.ReplaceAll(result, "${"+k+"}", v)
}
return result
}