commit 8fe42d6c75cc6c142dc1493c2a86f5204e14ff37 · julien.rbrt.fr/tangled-core

+2 -2

appview/db/db.go

···

       7
       7
        
       )

     

       8
       8
        
       

     

       9
       9
        
       type DB struct {

     

       10
       10
       -
       	Db *sql.DB

     

       10
       10
       +
       	db *sql.DB

     

       11
       11
        
       }

     

       12
       12
        
       

     

       13
       13
        
       func Make(dbPath string) (*DB, error) {

     
···

       43
       43
        
       	if err != nil {

     

       44
       44
        
       		return nil, err

     

       45
       45
        
       	}

     

       46
       46
       -
       	return &DB{Db: db}, nil

     

       46
       46
       +
       	return &DB{db: db}, nil

     

       47
       47
        
       }

+4 -11

appview/db/pubkeys.go

···

       1
       1
        
       package db

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"database/sql"

     

       5
       4
        
       	"encoding/json"

     

       6
       5
        
       	"time"

     

       7
       6
        
       )

     

       8
       7
        
       

     

       9
       8
        
       func (d *DB) AddPublicKey(did, name, key string) error {

     

       10
       9
        
       	query := `insert into public_keys (did, name, key) values (?, ?, ?)`

     

       11
       11
       -
       	_, err := d.Db.Exec(query, did, name, key)

     

       12
       12
       -
       	return err

     

       13
       13
       -
       }

     

       14
       14
       -
       

     

       15
       15
       -
       func (d *DB) AddPublicKeyTx(tx *sql.Tx, did, name, key string) error {

     

       16
       16
       -
       	query := `insert into public_keys (did, name, key) values (?, ?, ?)`

     

       17
       17
       -
       	_, err := tx.Exec(query, did, name, key)

     

       10
       10
       +
       	_, err := d.db.Exec(query, did, name, key)

     

       18
       11
        
       	return err

     

       19
       12
        
       }

     

       20
       13
        
       

     

       21
       14
        
       func (d *DB) RemovePublicKey(did string) error {

     

       22
       15
        
       	query := `delete from public_keys where did = ?`

     

       23
       23
       -
       	_, err := d.Db.Exec(query, did)

     

       16
       16
       +
       	_, err := d.db.Exec(query, did)

     

       24
       17
        
       	return err

     

       25
       18
        
       }

     

       26
       19
        
       

     
···

       45
       38
        
       func (d *DB) GetAllPublicKeys() ([]PublicKey, error) {

     

       46
       39
        
       	var keys []PublicKey

     

       47
       40
        
       

     

       48
       48
       -
       	rows, err := d.Db.Query(`select key, name, did, created from public_keys`)

     

       41
       41
       +
       	rows, err := d.db.Query(`select key, name, did, created from public_keys`)

     

       49
       42
        
       	if err != nil {

     

       50
       43
        
       		return nil, err

     

       51
       44
        
       	}

     
···

       71
       64
        
       func (d *DB) GetPublicKeys(did string) ([]PublicKey, error) {

     

       72
       65
        
       	var keys []PublicKey

     

       73
       66
        
       

     

       74
       74
       -
       	rows, err := d.Db.Query(`select did, key, name, created from public_keys where did = ?`, did)

     

       67
       67
       +
       	rows, err := d.db.Query(`select did, key, name, created from public_keys where did = ?`, did)

     

       75
       68
        
       	if err != nil {

     

       76
       69
        
       		return nil, err

     

       77
       70
        
       	}

+5 -58

appview/db/registration.go

···

       35
       35
        
       func (d *DB) RegistrationsByDid(did string) ([]Registration, error) {

     

       36
       36
        
       	var registrations []Registration

     

       37
       37
        
       

     

       38
       38
       -
       	rows, err := d.Db.Query(`

     

       38
       38
       +
       	rows, err := d.db.Query(`

     

       39
       39
        
       		select domain, did, created, registered from registrations

     

       40
       40
        
       		where did = ?

     

       41
       41
        
       	`, did)

     
···

       75
       75
        
       	var registeredAt *int64

     

       76
       76
        
       	var registration Registration

     

       77
       77
        
       

     

       78
       78
       -
       	err := d.Db.QueryRow(`

     

       79
       79
       -
       		select domain, did, created, registered from registrations

     

       80
       80
       -
       		where domain = ?

     

       81
       81
       -
       	`, domain).Scan(&registration.Domain, &registration.ByDid, &createdAt, &registeredAt)

     

       82
       82
       -
       

     

       83
       83
       -
       	if err != nil {

     

       84
       84
       -
       		if err == sql.ErrNoRows {

     

       85
       85
       -
       			return nil, nil

     

       86
       86
       -
       		} else {

     

       87
       87
       -
       			return nil, err

     

       88
       88
       -
       		}

     

       89
       89
       -
       	}

     

       90
       90
       -
       

     

       91
       91
       -
       	createdAtTime := time.Unix(*createdAt, 0)

     

       92
       92
       -
       	var registeredAtTime *time.Time

     

       93
       93
       -
       	if registeredAt != nil {

     

       94
       94
       -
       		x := time.Unix(*registeredAt, 0)

     

       95
       95
       -
       		registeredAtTime = &x

     

       96
       96
       -
       	}

     

       97
       97
       -
       

     

       98
       98
       -
       	registration.Created = &createdAtTime

     

       99
       99
       -
       	registration.Registered = registeredAtTime

     

       100
       100
       -
       

     

       101
       101
       -
       	return &registration, nil

     

       102
       102
       -
       }

     

       103
       103
       -
       

     

       104
       104
       -
       func (d *DB) RegistrationByDomainTx(tx *sql.Tx, domain string) (*Registration, error) {

     

       105
       105
       -
       	var createdAt *int64

     

       106
       106
       -
       	var registeredAt *int64

     

       107
       107
       -
       	var registration Registration

     

       108
       108
       -
       

     

       109
       109
       -
       	err := tx.QueryRow(`

     

       78
       78
       +
       	err := d.db.QueryRow(`

     

       110
       79
        
       		select domain, did, created, registered from registrations

     

       111
       80
        
       		where domain = ?

     

       112
       81
        
       	`, domain).Scan(&registration.Domain, &registration.ByDid, &createdAt, &registeredAt)

     
···

       153
       122
        
       

     

       154
       123
        
       	secret := uuid.New().String()

     

       155
       124
        
       

     

       156
       156
       -
       	_, err = d.Db.Exec(`

     

       125
       125
       +
       	_, err = d.db.Exec(`

     

       157
       126
        
       		insert into registrations (domain, did, secret)

     

       158
       127
        
       		values (?, ?, ?)

     

       159
       128
        
       		on conflict(domain) do update set did = excluded.did, secret = excluded.secret

     
···

       167
       136
        
       }

     

       168
       137
        
       

     

       169
       138
        
       func (d *DB) GetRegistrationKey(domain string) (string, error) {

     

       170
       170
       -
       	res := d.Db.QueryRow(`select secret from registrations where domain = ?`, domain)

     

       171
       171
       -
       

     

       172
       172
       -
       	var secret string

     

       173
       173
       -
       	err := res.Scan(&secret)

     

       174
       174
       -
       	if err != nil || secret == "" {

     

       175
       175
       -
       		return "", err

     

       176
       176
       -
       	}

     

       177
       177
       -
       

     

       178
       178
       -
       	return secret, nil

     

       179
       179
       -
       }

     

       180
       180
       -
       

     

       181
       181
       -
       func (d *DB) GetRegistrationKeyTx(tx *sql.Tx, domain string) (string, error) {

     

       182
       182
       -
       	res := tx.QueryRow(`select secret from registrations where domain = ?`, domain)

     

       139
       139
       +
       	res := d.db.QueryRow(`select secret from registrations where domain = ?`, domain)

     

       183
       140
        
       

     

       184
       141
        
       	var secret string

     

       185
       142
        
       	err := res.Scan(&secret)

     
···

       191
       148
        
       }

     

       192
       149
        
       

     

       193
       150
        
       func (d *DB) Register(domain string) error {

     

       194
       194
       -
       	_, err := d.Db.Exec(`

     

       195
       195
       -
       		update registrations

     

       196
       196
       -
       		set registered = strftime('%s', 'now')

     

       197
       197
       -
       		where domain = ?;

     

       198
       198
       -
       		`, domain)

     

       199
       199
       -
       

     

       200
       200
       -
       	return err

     

       201
       201
       -
       }

     

       202
       202
       -
       

     

       203
       203
       -
       func (d *DB) RegisterTx(tx *sql.Tx, domain string) error {

     

       204
       204
       -
       	_, err := tx.Exec(`

     

       151
       151
       +
       	_, err := d.db.Exec(`

     

       205
       152
        
       		update registrations

     

       206
       153
        
       		set registered = strftime('%s', 'now')

     

       207
       154
        
       		where domain = ?;

+4 -11

appview/db/repos.go

···

       1
       1
        
       package db

     

       2
       2
        
       

     

       3
       3
       -
       import "database/sql"

     

       4
       4
       -
       

     

       5
       3
        
       type Repo struct {

     

       6
       4
        
       	Did     string

     

       7
       5
        
       	Name    string

     
···

       12
       10
        
       func (d *DB) GetAllReposByDid(did string) ([]Repo, error) {

     

       13
       11
        
       	var repos []Repo

     

       14
       12
        
       

     

       15
       15
       -
       	rows, err := d.Db.Query(`select did, name, knot, created from repos where did = ?`, did)

     

       13
       13
       +
       	rows, err := d.db.Query(`select did, name, knot, created from repos where did = ?`, did)

     

       16
       14
        
       	if err != nil {

     

       17
       15
        
       		return nil, err

     

       18
       16
        
       	}

     
···

       38
       36
        
       func (d *DB) GetRepo(did, name string) (*Repo, error) {

     

       39
       37
        
       	var repo Repo

     

       40
       38
        
       

     

       41
       41
       -
       	row := d.Db.QueryRow(`select did, name, knot, created from repos where did = ? and name = ?`, did, name)

     

       39
       39
       +
       	row := d.db.QueryRow(`select did, name, knot, created from repos where did = ? and name = ?`, did, name)

     

       42
       40
        
       	var createdAt *int64

     

       43
       41
        
       	if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt); err != nil {

     

       44
       42
        
       		return nil, err

     
···

       49
       47
        
       }

     

       50
       48
        
       

     

       51
       49
        
       func (d *DB) AddRepo(repo *Repo) error {

     

       52
       52
       -
       	_, err := d.Db.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot)

     

       53
       53
       -
       	return err

     

       54
       54
       -
       }

     

       55
       55
       -
       

     

       56
       56
       -
       func (d *DB) AddRepoTx(tx *sql.Tx, repo *Repo) error {

     

       57
       57
       -
       	_, err := tx.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot)

     

       50
       50
       +
       	_, err := d.db.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot)

     

       58
       51
        
       	return err

     

       59
       52
        
       }

     

       60
       53
        
       

     

       61
       54
        
       func (d *DB) RemoveRepo(did, name, knot string) error {

     

       62
       62
       -
       	_, err := d.Db.Exec(`delete from repos where did = ? and name = ? and knot = ?`, did, name, knot)

     

       55
       55
       +
       	_, err := d.db.Exec(`delete from repos where did = ? and name = ? and knot = ?`, did, name, knot)

     

       63
       56
        
       	return err

     

       64
       57
        
       }

+32 -100

appview/state/state.go

···

       200
       200
        
       			return

     

       201
       201
        
       		}

     

       202
       202
        
       

     

       203
       203
       -
       		// Start transaction

     

       204
       204
       -
       		tx, err := s.db.Db.Begin()

     

       205
       205
       -
       		if err != nil {

     

       206
       206
       -
       			log.Printf("failed to start transaction: %s", err)

     

       207
       207
       -
       			http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       208
       208
       -
       			return

     

       209
       209
       -
       		}

     

       210
       210
       -
       		defer tx.Rollback() // Will rollback if not committed

     

       211
       211
       -
       

     

       212
       212
       -
       		if err := s.db.AddPublicKeyTx(tx, did, name, key); err != nil {

     

       203
       203
       +
       		if err := s.db.AddPublicKey(did, name, key); err != nil {

     

       213
       204
        
       			log.Printf("adding public key: %s", err)

     

       214
       205
        
       			return

     

       215
       206
        
       		}

     
···

       232
       223
        
       			return

     

       233
       224
        
       		}

     

       234
       225
        
       

     

       235
       235
       -
       		// If everything succeeded, commit the transaction

     

       236
       236
       -
       		if err := tx.Commit(); err != nil {

     

       237
       237
       -
       			log.Printf("failed to commit transaction: %s", err)

     

       238
       238
       -
       			http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       239
       239
       -
       			return

     

       240
       240
       -
       		}

     

       241
       241
       -
       

     

       242
       226
        
       		log.Println("created atproto record: ", resp.Uri)

     

       243
       227
        
       

     

       244
       228
        
       		return

     
···

       256
       240
        
       	}

     

       257
       241
        
       	log.Println("checking ", domain)

     

       258
       242
        
       

     

       259
       259
       -
       	// Start transaction

     

       260
       260
       -
       	tx, err := s.db.Db.Begin()

     

       261
       261
       -
       	if err != nil {

     

       262
       262
       -
       		log.Printf("failed to start transaction: %s", err)

     

       263
       263
       -
       		http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       264
       264
       -
       		return

     

       265
       265
       -
       	}

     

       266
       266
       -
       	defer tx.Rollback() // Will rollback if not committed

     

       267
       267
       -
       

     

       268
       268
       -
       	secret, err := s.db.GetRegistrationKeyTx(tx, domain)

     

       243
       243
       +
       	secret, err := s.db.GetRegistrationKey(domain)

     

       269
       244
        
       	if err != nil {

     

       270
       245
        
       		log.Printf("no key found for domain %s: %s\n", domain, err)

     

       271
       246
        
       		return

     
···

       310
       285
        
       		return

     

       311
       286
        
       	}

     

       312
       287
        
       

     

       313
       313
       -
       	// mark as registered within transaction

     

       314
       314
       -
       	err = s.db.RegisterTx(tx, domain)

     

       288
       288
       +
       	// mark as registered

     

       289
       289
       +
       	err = s.db.Register(domain)

     

       315
       290
        
       	if err != nil {

     

       316
       291
        
       		log.Println("failed to register domain", err)

     

       317
       292
        
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       318
       293
        
       		return

     

       319
       294
        
       	}

     

       320
       295
        
       

     

       321
       321
       -
       	// set permissions for this did as owner within transaction

     

       322
       322
       -
       	reg, err := s.db.RegistrationByDomainTx(tx, domain)

     

       296
       296
       +
       	// set permissions for this did as owner

     

       297
       297
       +
       	reg, err := s.db.RegistrationByDomain(domain)

     

       323
       298
        
       	if err != nil {

     

       324
       299
        
       		log.Println("failed to register domain", err)

     

       325
       300
        
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       326
       301
        
       		return

     

       327
       302
        
       	}

     

       328
       303
        
       

     

       329
       329
       -
       	// add basic acls for this domain within transaction

     

       304
       304
       +
       	// add basic acls for this domain

     

       330
       305
        
       	err = s.enforcer.AddDomain(domain)

     

       331
       306
        
       	if err != nil {

     

       332
       307
        
       		log.Println("failed to setup owner of domain", err)

     
···

       334
       309
        
       		return

     

       335
       310
        
       	}

     

       336
       311
        
       

     

       337
       337
       -
       	// add this did as owner of this domain within transaction

     

       312
       312
       +
       	// add this did as owner of this domain

     

       338
       313
        
       	err = s.enforcer.AddOwner(domain, reg.ByDid)

     

       339
       314
        
       	if err != nil {

     

       340
       315
        
       		log.Println("failed to setup owner of domain", err)

     

       341
       316
        
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       342
       342
       -
       		return

     

       343
       343
       -
       	}

     

       344
       344
       -
       

     

       345
       345
       -
       	// Commit transaction

     

       346
       346
       -
       	if err := tx.Commit(); err != nil {

     

       347
       347
       -
       		log.Printf("failed to commit transaction: %s", err)

     

       348
       348
       -
       		http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       349
       317
        
       		return

     

       350
       318
        
       	}

     

       351
       319
        
       

     
···

       443
       411
        
       	}

     

       444
       412
        
       	log.Printf("adding %s to %s\n", memberIdent.Handle.String(), domain)

     

       445
       413
        
       

     

       446
       446
       -
       	// Start transaction

     

       447
       447
       -
       	tx, err := s.db.Db.Begin()

     

       414
       414
       +
       	// announce this relation into the firehose, store into owners' pds

     

       415
       415
       +
       	client, _ := s.auth.AuthorizedClient(r)

     

       416
       416
       +
       	currentUser := s.auth.GetUser(r)

     

       417
       417
       +
       	addedAt := time.Now().Format(time.RFC3339)

     

       418
       418
       +
       	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       419
       419
       +
       		Collection: tangled.KnotMemberNSID,

     

       420
       420
       +
       		Repo:       currentUser.Did,

     

       421
       421
       +
       		Rkey:       s.TID(),

     

       422
       422
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       423
       423
       +
       			Val: &tangled.KnotMember{

     

       424
       424
       +
       				Member:  memberIdent.DID.String(),

     

       425
       425
       +
       				Domain:  domain,

     

       426
       426
       +
       				AddedAt: &addedAt,

     

       427
       427
       +
       			}},

     

       428
       428
       +
       	})

     

       429
       429
       +
       	// invalid record

     

       448
       430
        
       	if err != nil {

     

       449
       449
       -
       		log.Printf("failed to start transaction: %s", err)

     

       450
       450
       -
       		http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       431
       431
       +
       		log.Printf("failed to create record: %s", err)

     

       451
       432
        
       		return

     

       452
       433
        
       	}

     

       453
       453
       -
       	defer tx.Rollback() // Will rollback if not committed

     

       434
       434
       +
       	log.Println("created atproto record: ", resp.Uri)

     

       454
       435
        
       

     

       455
       455
       -
       	// Get registration key within transaction

     

       456
       456
       -
       	secret, err := s.db.GetRegistrationKeyTx(tx, domain)

     

       436
       436
       +
       	secret, err := s.db.GetRegistrationKey(domain)

     

       457
       437
        
       	if err != nil {

     

       458
       438
        
       		log.Printf("no key found for domain %s: %s\n", domain, err)

     

       459
       439
        
       		return

     

       460
       440
        
       	}

     

       461
       441
        
       

     

       462
       462
       -
       	// Make the external call to the knot server

     

       463
       442
        
       	ksClient, err := NewSignedClient(domain, secret)

     

       464
       443
        
       	if err != nil {

     

       465
       444
        
       		log.Println("failed to create client to ", domain)

     
···

       468
       447
        
       

     

       469
       448
        
       	ksResp, err := ksClient.AddMember(memberIdent.DID.String(), []string{})

     

       470
       449
        
       	if err != nil {

     

       471
       471
       -
       		log.Printf("failed to make request to %s: %s", domain, err)

     

       472
       472
       -
       		return

     

       450
       450
       +
       		log.Printf("failet to make request to %s: %s", domain, err)

     

       473
       451
        
       	}

     

       474
       452
        
       

     

       475
       453
        
       	if ksResp.StatusCode != http.StatusNoContent {

     
···

       477
       455
        
       		return

     

       478
       456
        
       	}

     

       479
       457
        
       

     

       480
       480
       -
       	// Create ATProto record within transaction

     

       481
       481
       -
       	client, _ := s.auth.AuthorizedClient(r)

     

       482
       482
       -
       	currentUser := s.auth.GetUser(r)

     

       483
       483
       -
       	addedAt := time.Now().Format(time.RFC3339)

     

       484
       484
       -
       	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       485
       485
       -
       		Collection: tangled.KnotMemberNSID,

     

       486
       486
       -
       		Repo:       currentUser.Did,

     

       487
       487
       -
       		Rkey:       s.TID(),

     

       488
       488
       -
       		Record: &lexutil.LexiconTypeDecoder{

     

       489
       489
       -
       			Val: &tangled.KnotMember{

     

       490
       490
       -
       				Member:  memberIdent.DID.String(),

     

       491
       491
       -
       				Domain:  domain,

     

       492
       492
       -
       				AddedAt: &addedAt,

     

       493
       493
       -
       			}},

     

       494
       494
       -
       	})

     

       495
       495
       -
       	if err != nil {

     

       496
       496
       -
       		log.Printf("failed to create record: %s", err)

     

       497
       497
       -
       		return

     

       498
       498
       -
       	}

     

       499
       499
       -
       

     

       500
       500
       -
       	// Update RBAC within transaction

     

       501
       458
        
       	err = s.enforcer.AddMember(domain, memberIdent.DID.String())

     

       502
       459
        
       	if err != nil {

     

       503
       460
        
       		w.Write([]byte(fmt.Sprint("failed to add member: ", err)))

     

       504
       461
        
       		return

     

       505
       462
        
       	}

     

       506
       463
        
       

     

       507
       507
       -
       	// If everything succeeded, commit the transaction

     

       508
       508
       -
       	if err := tx.Commit(); err != nil {

     

       509
       509
       -
       		log.Printf("failed to commit transaction: %s", err)

     

       510
       510
       -
       		http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       511
       511
       -
       		return

     

       512
       512
       -
       	}

     

       513
       513
       -
       

     

       514
       514
       -
       	log.Println("created atproto record: ", resp.Uri)

     

       515
       464
        
       	w.Write([]byte(fmt.Sprint("added member: ", memberIdent.Handle.String())))

     

       516
       465
        
       }

     

       517
       466
        
       

     
···

       545
       494
        
       			return

     

       546
       495
        
       		}

     

       547
       496
        
       

     

       548
       548
       -
       		// Start transaction

     

       549
       549
       -
       		tx, err := s.db.Db.Begin()

     

       550
       550
       -
       		if err != nil {

     

       551
       551
       -
       			log.Printf("failed to start transaction: %s", err)

     

       552
       552
       -
       			http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       553
       553
       -
       			return

     

       554
       554
       -
       		}

     

       555
       555
       -
       		defer tx.Rollback() // Will rollback if not committed

     

       556
       556
       -
       

     

       557
       557
       -
       		secret, err := s.db.GetRegistrationKeyTx(tx, domain)

     

       497
       497
       +
       		secret, err := s.db.GetRegistrationKey(domain)

     

       558
       498
        
       		if err != nil {

     

       559
       499
        
       			log.Printf("no key found for domain %s: %s\n", domain, err)

     

       560
       500
        
       			return

     
···

       563
       503
        
       		client, err := NewSignedClient(domain, secret)

     

       564
       504
        
       		if err != nil {

     

       565
       505
        
       			log.Println("failed to create client to ", domain)

     

       566
       566
       -
       			return

     

       567
       506
        
       		}

     

       568
       507
        
       

     

       569
       508
        
       		resp, err := client.NewRepo(user.Did, repoName)

     
···

       576
       515
        
       			return

     

       577
       516
        
       		}

     

       578
       517
        
       

     

       579
       579
       -
       		// add to local db within transaction

     

       518
       518
       +
       		// add to local db

     

       580
       519
        
       		repo := &db.Repo{

     

       581
       520
        
       			Did:  user.Did,

     

       582
       521
        
       			Name: repoName,

     

       583
       522
        
       			Knot: domain,

     

       584
       523
        
       		}

     

       585
       585
       -
       		err = s.db.AddRepoTx(tx, repo)

     

       524
       524
       +
       		err = s.db.AddRepo(repo)

     

       586
       525
        
       		if err != nil {

     

       587
       526
        
       			log.Println("failed to add repo to db", err)

     

       588
       527
        
       			return

     

       589
       528
        
       		}

     

       590
       529
        
       

     

       591
       591
       -
       		// acls within transaction

     

       530
       530
       +
       		// acls

     

       592
       531
        
       		err = s.enforcer.AddRepo(user.Did, domain, filepath.Join(user.Did, repoName))

     

       593
       532
        
       		if err != nil {

     

       594
       533
        
       			log.Println("failed to set up acls", err)

     

       595
       595
       -
       			return

     

       596
       596
       -
       		}

     

       597
       597
       -
       

     

       598
       598
       -
       		// Commit transaction

     

       599
       599
       -
       		if err := tx.Commit(); err != nil {

     

       600
       600
       -
       			log.Printf("failed to commit transaction: %s", err)

     

       601
       601
       -
       			http.Error(w, "Internal server error", http.StatusInternalServerError)

     

       602
       534
        
       			return

     

       603
       535
        
       		}

     

       604
       536