-
Notifications
You must be signed in to change notification settings - Fork 8
/
init_postgres.go
281 lines (255 loc) · 7.76 KB
/
init_postgres.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
package database
import (
"os"
"time"
"github.com/PretendoNetwork/super-mario-maker-secure/globals"
"github.com/lib/pq"
)
func initPostgres() {
_, err := Postgres.Exec(`CREATE SCHEMA IF NOT EXISTS datastore`)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
globals.Logger.Success("datastore Postgres schema created")
// * Super Mario Maker has non-standard DataID requirements.
// * DataID 900000 is reserved for the event course metadata
// * file, and official event courses begin at DataID 930010
// * and end at DataID 930050. To prevent a collision
// * eventually, we need to start course IDs AFTER 930050
// *
// * DataIDs are stored and processed as uint64, however
// * Super Mario Maker can not use the full uint64 range.
// * This is because course share codes are generated from the
// * courses DataID. A course share code is an 8 byte hex
// * string, where the upper 2 bytes are the checksum of the
// * lower 6 bytes. The lower 6 bytes are the courses DataID
// *
// * Super Mario Maker is only capable of displaying codes up
// * to 0xFFFFFFFFFFFF, essentially truncating DataIDs down to
// * 48 bit integers instead of 64 bit. I doubt we will ever
// * hit even the 32 bit limit, let alone 48, but this is here
// * just in case
_, err = Postgres.Exec(`CREATE SEQUENCE IF NOT EXISTS datastore.object_data_id_seq
INCREMENT 1
MINVALUE 1
MAXVALUE 281474976710656
START 940000
CACHE 1`, // * Honestly I don't know what CACHE does but I saw it recommended so here it is
)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
// * "deletion_reason" and "under_review" are specific to SMM.
// * Everything else is stock
_, err = Postgres.Exec(`CREATE TABLE IF NOT EXISTS datastore.objects (
data_id bigint NOT NULL DEFAULT nextval('datastore.object_data_id_seq') PRIMARY KEY,
upload_completed boolean NOT NULL DEFAULT FALSE,
deleted boolean NOT NULL DEFAULT FALSE,
deletion_reason int NOT NULL DEFAULT 0,
under_review boolean NOT NULL DEFAULT FALSE,
owner int,
size int,
name text,
data_type int,
meta_binary bytea,
permission int,
permission_recipients int[],
delete_permission int,
delete_permission_recipients int[],
flag int,
period int,
refer_data_id bigint,
tags text[],
persistence_slot_id int,
extra_data text[],
access_password bigint NOT NULL DEFAULT 0,
update_password bigint NOT NULL DEFAULT 0,
creation_date timestamp,
update_date timestamp
)`)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
// * Unsure what like half of this is but the client sends it so we saves it
_, err = Postgres.Exec(`CREATE TABLE IF NOT EXISTS datastore.object_ratings (
data_id bigint,
slot smallint,
flag smallint,
internal_flag smallint,
lock_type smallint,
initial_value bigint,
range_min int,
range_max int,
period_hour smallint,
period_duration int,
total_value bigint,
count int NOT NULL DEFAULT 0,
PRIMARY KEY(data_id, slot)
)`)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
// * Custom rankings are specific to SMM
// TODO - Store the period? What even is the period of custom rankings?
_, err = Postgres.Exec(`CREATE TABLE IF NOT EXISTS datastore.object_custom_rankings (
data_id bigint,
application_id bigint,
value bigint,
PRIMARY KEY(data_id, application_id)
)`)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
// * BufferQueues are specific to SMM
// * Real server does not allow duplicate buffers in a given slot for an object,
// * even if uploaded by different users. We could change this, but I don't see
// * much point
_, err = Postgres.Exec(`CREATE TABLE IF NOT EXISTS datastore.buffer_queues (
data_id bigint,
slot int,
creation_date timestamp,
buffer bytea,
PRIMARY KEY(data_id, slot, buffer)
)`)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
// * Course records are specific to SMM
_, err = Postgres.Exec(`CREATE TABLE IF NOT EXISTS datastore.course_records (
data_id bigint,
slot int,
first_pid int,
best_pid int,
best_score int,
creation_date timestamp,
update_date timestamp,
PRIMARY KEY(data_id, slot)
)`)
if err != nil {
globals.Logger.Critical(err.Error())
os.Exit(0)
}
globals.Logger.Success("Postgres tables created")
ensureEventCourseMetaDataFileExists()
}
func ensureEventCourseMetaDataFileExists() {
// * The event course metadata file is REQUIRED for
// * Super Mario Maker to open Course World. This
// * ensures that it exists both in S3 and in the
// * database before booting. It has the reserved
// * DataID 900000
bucket := os.Getenv("PN_SMM_CONFIG_S3_BUCKET")
key := "900000.bin"
objectSizeS3, err := globals.S3ObjectSize(bucket, key)
if err != nil {
globals.Logger.Errorf("Failed to stat event course metadata file. Ensure your S3 credentials are correct and the 900000.bin file is uploaded to your bucket. S3 error: %s", err.Error())
os.Exit(0)
}
globals.Logger.Success("Event course metadata file found. Verifying database")
var exists bool
err = Postgres.QueryRow(`SELECT EXISTS(SELECT 1 FROM datastore.objects WHERE data_id=900000) AS "exists"`).Scan(&exists)
if err != nil {
globals.Logger.Errorf("Error querying for event course metadata object in Postgres: %s", err.Error())
os.Exit(0)
}
now := time.Now()
if !exists {
var dataID uint64
globals.Logger.Info("Event course metadata object not found in Postgres. Creating")
err := Postgres.QueryRow(`INSERT INTO datastore.objects (
data_id,
upload_completed,
owner,
size,
name,
data_type,
meta_binary,
permission,
permission_recipients,
delete_permission,
delete_permission_recipients,
flag,
period,
refer_data_id,
tags,
persistence_slot_id,
extra_data,
creation_date,
update_date
) VALUES (
$1,
$2,
$3,
$4,
$5,
$6,
$7,
$8,
$9,
$10,
$11,
$12,
$13,
$14,
$15,
$16,
$17,
$18,
$19
) RETURNING data_id`,
900000,
true,
2, // * "Quazal Rendez-Vous" special account
objectSizeS3,
"", // * Has no name
50, // * Metadata file has DataType 50. Event courses have DataType 51
[]byte{}, // * No MetaBinary
0, // * Accessible by everyone
pq.Array([]uint32{}),
3, // * THE REAL SERVER HAS THIS SET TO 0, FOR EVERYONE. THAT'S SUPER INSECURE.
pq.Array([]uint32{}),
0,
64306,
0,
pq.Array([]string{}),
0, // * Unsure what the slot ID actually is
pq.Array([]string{}),
now,
now,
).Scan(&dataID)
if err != nil {
globals.Logger.Errorf("Error creating event course metadata object: %s", err.Error())
os.Exit(0)
}
} else {
var objectSizeDB uint32
err := Postgres.QueryRow(`SELECT size FROM datastore.objects WHERE data_id=900000`).Scan(&objectSizeDB)
if err != nil {
globals.Logger.Errorf("Error querying event course metadata object size: %s", err.Error())
os.Exit(0)
}
if objectSizeS3 != uint64(objectSizeDB) {
globals.Logger.Success("Event course metadata object found in Postgres! Updating size")
_, err := Postgres.Exec(`UPDATE datastore.objects SET size=$1, update_date=$2 WHERE data_id=900000`, objectSizeS3, now)
if err != nil {
globals.Logger.Errorf("Error updating event course metadata object size: %s", err.Error())
os.Exit(0)
}
} else {
globals.Logger.Success("Event course metadata object found in Postgres!")
}
globals.Logger.Info("Ensuring event course metadata object has correct delete permission")
_, err = Postgres.Exec(`UPDATE datastore.objects SET delete_permission=3 WHERE data_id=900000`)
if err != nil {
globals.Logger.Errorf("Error updating event course metadata object delete permission: %s", err.Error())
os.Exit(0)
}
}
globals.Logger.Success("Event course metadata object found and is up to date!")
}