Skip to content

Commit 8c33cba

Browse files
mberberomberbero
committed
chore: fatal to Println
1 parent 1b1495c commit 8c33cba

File tree

1 file changed

+44
-40
lines changed

1 file changed

+44
-40
lines changed

‎certy.go

Lines changed: 44 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -91,12 +91,12 @@ func (m *Manager) GetChallengeToken(domain string) string {
9191
location := fmt.Sprintf("%s/%s/%s-acme.json", m.Location, domain, domain)
9292
file, err := os.ReadFile(location)
9393
if err != nil {
94-
log.Fatalf("Failed to read domain acme file: %v", err)
94+
log.Println("Failed to read domain acme file: ", err)
9595
}
9696

9797
var domainAcme DomainAcme
9898
if err := json.Unmarshal(file, &domainAcme); err != nil {
99-
log.Fatalf("Failed to unmarshal domain acme data: %v", err)
99+
log.Println("Failed to unmarshal domain acme data: ", err)
100100
}
101101

102102
return domainAcme.IssuerData.ChallengeToken
@@ -161,7 +161,7 @@ func (m *Manager) HTTPHandler(fallback http.Handler) http.Handler {
161161

162162
acmeData, err := m.GetAcmeFileData(r.Host)
163163
if err != nil {
164-
log.Fatalf("Failed to get acme file data: %v", err)
164+
log.Println("Failed to get acme file data: ", err)
165165
}
166166

167167
client := &acme.Client{
@@ -172,7 +172,7 @@ func (m *Manager) HTTPHandler(fallback http.Handler) http.Handler {
172172
// HTTP-01 challenge response
173173
http01, err := client.HTTP01ChallengeResponse(m.GetChallengeToken(r.Host))
174174
if err != nil {
175-
log.Fatalf("HTTP-01 challenge response failed: %v", err)
175+
log.Println("HTTP-01 challenge response failed: ", err)
176176
}
177177

178178
if token == m.GetChallengeToken(r.Host) {
@@ -191,30 +191,30 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
191191
// check location is exists or not if not create it
192192
if _, err := os.Stat(location); os.IsNotExist(err) {
193193
if err := os.Mkdir(location, 0755); err != nil {
194-
log.Fatalf("Failed to create directory: %v", err)
194+
log.Println("Failed to create directory: ", err)
195195
}
196196
}
197197

198198
// create folder for domain
199199
location = location + "/" + domain
200200
if _, err := os.Stat(location); os.IsNotExist(err) {
201201
if err := os.Mkdir(location, 0755); err != nil {
202-
log.Fatalf("Failed to create domain directory: %v", err)
202+
log.Println("Failed to create domain directory: ", err)
203203
}
204204
}
205205

206206
// if not exists create domainAcme.json file
207207
domainAcmeFile := location + "/" + domain + "-acme.json"
208208
if _, err := os.Stat(domainAcmeFile); os.IsNotExist(err) {
209209
if _, err := os.Create(domainAcmeFile); err != nil {
210-
log.Fatalf("Failed to create domain acme file: %v", err)
210+
log.Println("Failed to create domain acme file: ", err)
211211
}
212212
}
213213

214214
// read domainAcme.json file
215215
acmefile, err := os.ReadFile(domainAcmeFile)
216216
if err != nil {
217-
log.Fatalf("Failed to read domain acme file: %v", err)
217+
log.Println("Failed to read domain acme file: ", err)
218218
}
219219

220220
var domainAcme DomainAcme
@@ -239,7 +239,7 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
239239
// Generate a new account key
240240
accountKey, err := rsa.GenerateKey(rand.Reader, 4096)
241241
if err != nil {
242-
log.Fatalf("Account key generation failed: %v", err)
242+
log.Println("Account key generation failed: ", err)
243243
}
244244

245245
client := &acme.Client{
@@ -255,7 +255,7 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
255255
acct := &acme.Account{Contact: []string{"mailto:" + email}}
256256
acct, err = client.Register(context.TODO(), acct, acme.AcceptTOS)
257257
if err != nil {
258-
log.Fatalf("Account registration failed: %v", err)
258+
log.Println("Account registration failed: ", err)
259259
}
260260
fmt.Printf("Account registered: %v\n", acct.URI)
261261

@@ -274,25 +274,25 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
274274
// save domainAcme struct to domainAcme.json file
275275
jsonData, err := json.Marshal(domainAcme)
276276
if err != nil {
277-
log.Fatalf("Failed to marshal domain acme data: %v", err)
277+
log.Println("Failed to marshal domain acme data: ", err)
278278
}
279279

280280
if err := os.WriteFile(domainAcmeFile, jsonData, 0644); err != nil {
281-
log.Fatalf("Failed to write domain acme data: %v", err)
281+
log.Println("Failed to write domain acme data: ", err)
282282
}
283283

284284
// Create a new order for the domain
285285
order, err := client.AuthorizeOrder(context.TODO(), acme.DomainIDs(domain))
286286
if err != nil {
287-
log.Fatalf("Order authorization failed: %v", err)
287+
log.Println("Order authorization failed: ", err)
288288
}
289289

290290
// HTTP-01 challenge for domain verification
291291
var chal *acme.Challenge
292292
for _, authzURL := range order.AuthzURLs {
293293
authz, err := client.GetAuthorization(context.TODO(), authzURL)
294294
if err != nil {
295-
log.Fatalf("Failed to get authorization: %v", err)
295+
log.Println("Failed to get authorization: ", err)
296296
}
297297
for _, c := range authz.Challenges {
298298
if c.Type == "http-01" {
@@ -306,26 +306,30 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
306306
}
307307

308308
if chal == nil {
309-
log.Fatalf("No HTTP-01 challenge found")
309+
log.Println("No HTTP-01 challenge found")
310310
}
311311

312-
domainAcme.IssuerData.ChallengeToken = chal.Token
313-
log.Println("Challenge token: " + chal.Token)
312+
if chal != nil {
313+
domainAcme.IssuerData.ChallengeToken = chal.Token
314+
log.Println("Challenge token: " + chal.Token)
315+
} else {
316+
log.Println("Challenge token is nil.")
317+
}
314318

315319
// save domainAcme struct to domainAcme.json file
316320
jsonData, err = json.Marshal(domainAcme)
317321
if err != nil {
318-
log.Fatalf("Failed to marshal domain acme data: %v", err)
322+
log.Println("Failed to marshal domain acme data: ", err)
319323
}
320324

321325
if err := os.WriteFile(domainAcmeFile, jsonData, 0644); err != nil {
322-
log.Fatalf("Failed to write domain acme data: %v", err)
326+
log.Println("Failed to write domain acme data: ", err)
323327
}
324328

325329
// Accept the challenge
326330
_, err = client.Accept(context.TODO(), chal)
327331
if err != nil {
328-
log.Fatalf("Challenge acceptance failed: %v", err)
332+
log.Println("Challenge acceptance failed: ", err)
329333
}
330334

331335
// Wait for challenge to be valid
@@ -347,21 +351,21 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
347351

348352
ecdsaPrivateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
349353
if err != nil {
350-
log.Fatalf("ECDSA private key generation failed: %v", err)
354+
log.Println("ECDSA private key generation failed: ", err)
351355
}
352356

353357
// Create a CSR
354358
csr, err := x509.CreateCertificateRequest(rand.Reader, &x509.CertificateRequest{
355359
Subject: pkix.Name{CommonName: domain},
356360
}, ecdsaPrivateKey)
357361
if err != nil {
358-
log.Fatalf("Certificate request creation failed: %v", err)
362+
log.Println("Certificate request creation failed: ", err)
359363
}
360364

361365
// Finalize the order and get the certificate
362366
der, _, err := client.CreateOrderCert(context.TODO(), order.FinalizeURL, csr, true)
363367
if err != nil {
364-
log.Fatalf("Certificate issuance failed: %v", err)
368+
log.Println("Certificate issuance failed: ", err)
365369
}
366370

367371
// der contains the certificate chain
@@ -371,41 +375,41 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
371375
keyFile := location + "/" + domain + "-key.pem"
372376

373377
if _, err := os.Create(certFile); err != nil {
374-
log.Fatalf("Failed to create certificate file: %v", err)
378+
log.Println("Failed to create certificate file: ", err)
375379
}
376380

377381
file, err := os.OpenFile(certFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
378382
if err != nil {
379-
log.Fatalf("Failed to open file: %v", err)
383+
log.Println("Failed to open file: ", err)
380384
}
381385

382386
for _, b := range der {
383387
block := &pem.Block{Type: "CERTIFICATE", Bytes: b}
384388
// Write to file
385389
if err := pem.Encode(file, block); err != nil {
386-
log.Fatalf("Failed to write certificate: %v", err)
390+
log.Println("Failed to write certificate: ", err)
387391
}
388392

389393
}
390394

391395
ecdsaPrivateKeyBytes, err := x509.MarshalECPrivateKey(ecdsaPrivateKey)
392396
if err != nil {
393-
log.Fatalf("Failed to marshal ECDSA private key: %v", err)
397+
log.Println("Failed to marshal ECDSA private key: ", err)
394398
}
395399

396400
keyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: ecdsaPrivateKeyBytes})
397401
if err := os.WriteFile(keyFile, keyPEM, 0644); err != nil {
398-
log.Fatalf("Failed to write key: %v", err)
402+
log.Println("Failed to write key: ", err)
399403
}
400404

401405
crtFileData, err := os.ReadFile(certFile)
402406
if err != nil {
403-
log.Fatalf("Failed to read certificate file: %v", err)
407+
log.Println("Failed to read certificate file: ", err)
404408
}
405409

406410
keyFileData, err := os.ReadFile(keyFile)
407411
if err != nil {
408-
log.Fatalf("Failed to read key file: %v", err)
412+
log.Println("Failed to read key file: ", err)
409413
}
410414

411415
domainAcme.CertFile = string(crtFileData)
@@ -419,11 +423,11 @@ func (m *Manager) issueLetsEncryptCert(email, domain, location string) {
419423
// save domainAcme struct to domainAcme.json file
420424
jsonData, err = json.Marshal(domainAcme)
421425
if err != nil {
422-
log.Fatalf("Failed to marshal domain acme data: %v", err)
426+
log.Println("Failed to marshal domain acme data: ", err)
423427
}
424428

425429
if err := os.WriteFile(domainAcmeFile, jsonData, 0644); err != nil {
426-
log.Fatalf("Failed to write domain acme data: %v", err)
430+
log.Println("Failed to write domain acme data: ", err)
427431
}
428432

429433
fmt.Println("Certificate and key saved to " + location)
@@ -437,13 +441,13 @@ func (m *Manager) AddCustomCert(domain, certFileData, keyfileData string) {
437441

438442
if _, err := os.Stat(location); os.IsNotExist(err) {
439443
if _, err := os.Create(location); err != nil {
440-
log.Fatalf("Failed to create domain acme file: %v", err)
444+
log.Println("Failed to create domain acme file: ", err)
441445
}
442446
}
443447

444448
if _, err := os.Stat(acmelocation); os.IsNotExist(err) {
445449
if _, err := os.Create(acmelocation); err != nil {
446-
log.Fatalf("Failed to create domain acme file: %v", err)
450+
log.Println("Failed to create domain acme file: ", err)
447451
}
448452
}
449453

@@ -457,30 +461,30 @@ func (m *Manager) AddCustomCert(domain, certFileData, keyfileData string) {
457461

458462
jsonData, err := json.Marshal(domainAcme)
459463
if err != nil {
460-
log.Fatalf("Failed to marshal domain acme data: %v", err)
464+
log.Println("Failed to marshal domain acme data: ", err)
461465
}
462466

463467
if err := os.WriteFile(acmelocation, jsonData, 0644); err != nil {
464-
log.Fatalf("Failed to write domain acme data: %v", err)
468+
log.Println("Failed to write domain acme data: ", err)
465469
}
466470

467471
certFile := location + "/" + domain + "-cert.crt"
468472
keyFile := location + "/" + domain + "-key.pem"
469473

470474
if _, err := os.Create(certFile); err != nil {
471-
log.Fatalf("Failed to create certificate file: %v", err)
475+
log.Println("Failed to create certificate file: ", err)
472476
}
473477

474478
if _, err := os.Create(keyFile); err != nil {
475-
log.Fatalf("Failed to create key file: %v", err)
479+
log.Println("Failed to create key file: ", err)
476480
}
477481

478482
if err := os.WriteFile(certFile, []byte(certFileData), 0644); err != nil {
479-
log.Fatalf("Failed to write certificate file: %v", err)
483+
log.Println("Failed to write certificate file: ", err)
480484
}
481485

482486
if err := os.WriteFile(keyFile, []byte(keyfileData), 0644); err != nil {
483-
log.Fatalf("Failed to write key file: %v", err)
487+
log.Println("Failed to write key file: ", err)
484488
}
485489

486490
fmt.Println("Custom certificate and key saved to " + location)

0 commit comments

Comments
 (0)