+8 -152

appview/db/db.go

··· 2 2 3 3 import ( 4 4 "database/sql" 5 5 - "fmt" 6 6 - "log" 7 7 - "time" 8 5 9 9 - "github.com/google/uuid" 10 6 _ "github.com/mattn/go-sqlite3" 11 7 ) 12 8 ··· 35 31 created integer default (strftime('%s', 'now')), 36 32 unique(did, name, key) 37 33 ); 34 34 + create table if not exists repos ( 35 35 + id integer primary key autoincrement, 36 36 + did text not null, 37 37 + name text not null, 38 38 + knot text not null, 39 39 + created integer default (strftime('%s', 'now')), 40 40 + unique(did, name, knot) 41 41 + ); 38 42 `) 39 43 if err != nil { 40 44 return nil, err 41 45 } 42 46 return &DB{db: db}, nil 43 47 } 44 44 - 45 45 - type Registration struct { 46 46 - Domain string 47 47 - ByDid string 48 48 - Created *time.Time 49 49 - Registered *time.Time 50 50 - } 51 51 - 52 52 - func (r *Registration) Status() Status { 53 53 - if r.Registered != nil { 54 54 - return Registered 55 55 - } else { 56 56 - return Pending 57 57 - } 58 58 - } 59 59 - 60 60 - type Status uint32 61 61 - 62 62 - const ( 63 63 - Registered Status = iota 64 64 - Pending 65 65 - ) 66 66 - 67 67 - // returns registered status, did of owner, error 68 68 - func (d *DB) RegistrationsByDid(did string) ([]Registration, error) { 69 69 - var registrations []Registration 70 70 - 71 71 - rows, err := d.db.Query(` 72 72 - select domain, did, created, registered from registrations 73 73 - where did = ? 74 74 - `, did) 75 75 - if err != nil { 76 76 - return nil, err 77 77 - } 78 78 - 79 79 - for rows.Next() { 80 80 - var createdAt *int64 81 81 - var registeredAt *int64 82 82 - var registration Registration 83 83 - err = rows.Scan(&registration.Domain, &registration.ByDid, &createdAt, &registeredAt) 84 84 - 85 85 - if err != nil { 86 86 - log.Println(err) 87 87 - } else { 88 88 - createdAtTime := time.Unix(*createdAt, 0) 89 89 - 90 90 - var registeredAtTime *time.Time 91 91 - if registeredAt != nil { 92 92 - x := time.Unix(*registeredAt, 0) 93 93 - registeredAtTime = &x 94 94 - } 95 95 - 96 96 - registration.Created = &createdAtTime 97 97 - registration.Registered = registeredAtTime 98 98 - registrations = append(registrations, registration) 99 99 - } 100 100 - } 101 101 - 102 102 - return registrations, nil 103 103 - } 104 104 - 105 105 - // returns registered status, did of owner, error 106 106 - func (d *DB) RegistrationByDomain(domain string) (*Registration, error) { 107 107 - var createdAt *int64 108 108 - var registeredAt *int64 109 109 - var registration Registration 110 110 - 111 111 - err := d.db.QueryRow(` 112 112 - select domain, did, created, registered from registrations 113 113 - where domain = ? 114 114 - `, domain).Scan(&registration.Domain, &registration.ByDid, &createdAt, &registeredAt) 115 115 - 116 116 - if err != nil { 117 117 - if err == sql.ErrNoRows { 118 118 - return nil, nil 119 119 - } else { 120 120 - return nil, err 121 121 - } 122 122 - } 123 123 - 124 124 - createdAtTime := time.Unix(*createdAt, 0) 125 125 - var registeredAtTime *time.Time 126 126 - if registeredAt != nil { 127 127 - x := time.Unix(*registeredAt, 0) 128 128 - registeredAtTime = &x 129 129 - } 130 130 - 131 131 - registration.Created = &createdAtTime 132 132 - registration.Registered = registeredAtTime 133 133 - 134 134 - return &registration, nil 135 135 - } 136 136 - 137 137 - func (d *DB) GenerateRegistrationKey(domain, did string) (string, error) { 138 138 - // sanity check: does this domain already have a registration? 139 139 - reg, err := d.RegistrationByDomain(domain) 140 140 - if err != nil { 141 141 - return "", err 142 142 - } 143 143 - 144 144 - // registration is open 145 145 - if reg != nil { 146 146 - switch reg.Status() { 147 147 - case Registered: 148 148 - // already registered by `owner` 149 149 - return "", fmt.Errorf("%s already registered by %s", domain, reg.ByDid) 150 150 - case Pending: 151 151 - // TODO: be loud about this 152 152 - log.Printf("%s registered by %s, status pending", domain, reg.ByDid) 153 153 - } 154 154 - } 155 155 - 156 156 - secret := uuid.New().String() 157 157 - 158 158 - _, err = d.db.Exec(` 159 159 - insert into registrations (domain, did, secret) 160 160 - values (?, ?, ?) 161 161 - on conflict(domain) do update set did = excluded.did, secret = excluded.secret 162 162 - `, domain, did, secret) 163 163 - 164 164 - if err != nil { 165 165 - return "", err 166 166 - } 167 167 - 168 168 - return secret, nil 169 169 - } 170 170 - 171 171 - func (d *DB) GetRegistrationKey(domain string) (string, error) { 172 172 - res := d.db.QueryRow(`select secret from registrations where domain = ?`, domain) 173 173 - 174 174 - var secret string 175 175 - err := res.Scan(&secret) 176 176 - if err != nil || secret == "" { 177 177 - return "", err 178 178 - } 179 179 - 180 180 - return secret, nil 181 181 - } 182 182 - 183 183 - func (d *DB) Register(domain string) error { 184 184 - _, err := d.db.Exec(` 185 185 - update registrations 186 186 - set registered = strftime('%s', 'now') 187 187 - where domain = ?; 188 188 - `, domain) 189 189 - 190 190 - return err 191 191 - }

+158

appview/db/registration.go

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "fmt" 6 6 + "log" 7 7 + "time" 8 8 + 9 9 + "github.com/google/uuid" 10 10 + ) 11 11 + 12 12 + type Registration struct { 13 13 + Domain string 14 14 + ByDid string 15 15 + Created *time.Time 16 16 + Registered *time.Time 17 17 + } 18 18 + 19 19 + func (r *Registration) Status() Status { 20 20 + if r.Registered != nil { 21 21 + return Registered 22 22 + } else { 23 23 + return Pending 24 24 + } 25 25 + } 26 26 + 27 27 + type Status uint32 28 28 + 29 29 + const ( 30 30 + Registered Status = iota 31 31 + Pending 32 32 + ) 33 33 + 34 34 + // returns registered status, did of owner, error 35 35 + func (d *DB) RegistrationsByDid(did string) ([]Registration, error) { 36 36 + var registrations []Registration 37 37 + 38 38 + rows, err := d.db.Query(` 39 39 + select domain, did, created, registered from registrations 40 40 + where did = ? 41 41 + `, did) 42 42 + if err != nil { 43 43 + return nil, err 44 44 + } 45 45 + 46 46 + for rows.Next() { 47 47 + var createdAt *int64 48 48 + var registeredAt *int64 49 49 + var registration Registration 50 50 + err = rows.Scan(&registration.Domain, &registration.ByDid, &createdAt, &registeredAt) 51 51 + 52 52 + if err != nil { 53 53 + log.Println(err) 54 54 + } else { 55 55 + createdAtTime := time.Unix(*createdAt, 0) 56 56 + 57 57 + var registeredAtTime *time.Time 58 58 + if registeredAt != nil { 59 59 + x := time.Unix(*registeredAt, 0) 60 60 + registeredAtTime = &x 61 61 + } 62 62 + 63 63 + registration.Created = &createdAtTime 64 64 + registration.Registered = registeredAtTime 65 65 + registrations = append(registrations, registration) 66 66 + } 67 67 + } 68 68 + 69 69 + return registrations, nil 70 70 + } 71 71 + 72 72 + // returns registered status, did of owner, error 73 73 + func (d *DB) RegistrationByDomain(domain string) (*Registration, error) { 74 74 + var createdAt *int64 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) GenerateRegistrationKey(domain, did string) (string, error) { 105 105 + // sanity check: does this domain already have a registration? 106 106 + reg, err := d.RegistrationByDomain(domain) 107 107 + if err != nil { 108 108 + return "", err 109 109 + } 110 110 + 111 111 + // registration is open 112 112 + if reg != nil { 113 113 + switch reg.Status() { 114 114 + case Registered: 115 115 + // already registered by `owner` 116 116 + return "", fmt.Errorf("%s already registered by %s", domain, reg.ByDid) 117 117 + case Pending: 118 118 + // TODO: be loud about this 119 119 + log.Printf("%s registered by %s, status pending", domain, reg.ByDid) 120 120 + } 121 121 + } 122 122 + 123 123 + secret := uuid.New().String() 124 124 + 125 125 + _, err = d.db.Exec(` 126 126 + insert into registrations (domain, did, secret) 127 127 + values (?, ?, ?) 128 128 + on conflict(domain) do update set did = excluded.did, secret = excluded.secret 129 129 + `, domain, did, secret) 130 130 + 131 131 + if err != nil { 132 132 + return "", err 133 133 + } 134 134 + 135 135 + return secret, nil 136 136 + } 137 137 + 138 138 + func (d *DB) GetRegistrationKey(domain string) (string, error) { 139 139 + res := d.db.QueryRow(`select secret from registrations where domain = ?`, domain) 140 140 + 141 141 + var secret string 142 142 + err := res.Scan(&secret) 143 143 + if err != nil || secret == "" { 144 144 + return "", err 145 145 + } 146 146 + 147 147 + return secret, nil 148 148 + } 149 149 + 150 150 + func (d *DB) Register(domain string) error { 151 151 + _, err := d.db.Exec(` 152 152 + update registrations 153 153 + set registered = strftime('%s', 'now') 154 154 + where domain = ?; 155 155 + `, domain) 156 156 + 157 157 + return err 158 158 + }

+57

appview/db/repos.go

··· 1 1 + package db 2 2 + 3 3 + type Repo struct { 4 4 + Did string 5 5 + Name string 6 6 + Knot string 7 7 + Created *int64 8 8 + } 9 9 + 10 10 + func (d *DB) GetAllReposByDid(did string) ([]Repo, error) { 11 11 + var repos []Repo 12 12 + 13 13 + rows, err := d.db.Query(`select did, name, knot, created from repos where did = ?`, did) 14 14 + if err != nil { 15 15 + return nil, err 16 16 + } 17 17 + defer rows.Close() 18 18 + 19 19 + for rows.Next() { 20 20 + var repo Repo 21 21 + var createdAt *int64 22 22 + if err := rows.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt); err != nil { 23 23 + return nil, err 24 24 + } 25 25 + repo.Created = createdAt 26 26 + repos = append(repos, repo) 27 27 + } 28 28 + 29 29 + if err := rows.Err(); err != nil { 30 30 + return nil, err 31 31 + } 32 32 + 33 33 + return repos, nil 34 34 + } 35 35 + 36 36 + func (d *DB) GetRepo(did, name string) (*Repo, error) { 37 37 + var repo Repo 38 38 + 39 39 + row := d.db.QueryRow(`select did, name, knot, created from repos where did = ? and name = ?`, did, name) 40 40 + var createdAt *int64 41 41 + if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt); err != nil { 42 42 + return nil, err 43 43 + } 44 44 + repo.Created = createdAt 45 45 + 46 46 + return &repo, nil 47 47 + } 48 48 + 49 49 + func (d *DB) AddRepo(repo *Repo) error { 50 50 + _, err := d.db.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot) 51 51 + return err 52 52 + } 53 53 + 54 54 + func (d *DB) RemoveRepo(did, name, knot string) error { 55 55 + _, err := d.db.Exec(`delete from repos where did = ? and name = ? and knot = ?`, did, name, knot) 56 56 + return err 57 57 + }

+13

appview/state/state.go

··· 450 450 return 451 451 } 452 452 453 453 + // add to local db 454 454 + repo := &db.Repo{ 455 455 + Did: user.Did, 456 456 + Name: repoName, 457 457 + Knot: domain, 458 458 + } 459 459 + 460 460 + err = s.db.AddRepo(repo) 461 461 + if err != nil { 462 462 + log.Println("failed to add repo to db", err) 463 463 + return 464 464 + } 465 465 + 453 466 w.Write([]byte("created!")) 454 467 } 455 468 }