mystiq/dex
Archived
4
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity

*: ClientIdentityXXX -> ClientXXX

Browse source 
Get rid of all outdated "ClientIdentity" terminology.
This commit is contained in:
Bobby Rullo 2016-04-14 16:27:57 -07:00
parent 95757e8779
commit e5948ab3ce
32 changed files with 220 additions and 220 deletions

6
admin/api.go
View file

@ -19,7 +19,7 @@ type AdminAPI struct {
userManager *manager.UserManager userManager *manager.UserManager
userRepo user.UserRepo userRepo user.UserRepo
passwordInfoRepo user.PasswordInfoRepo passwordInfoRepo user.PasswordInfoRepo
clientIdentityRepo client.ClientIdentityRepo clientRepo client.ClientRepo
localConnectorID string localConnectorID string
} }
@ -33,7 +33,7 @@ func NewAdminAPI(dbMap *gorp.DbMap, userManager *manager.UserManager, localConne
userManager: userManager, userManager: userManager,
userRepo: db.NewUserRepo(dbMap), userRepo: db.NewUserRepo(dbMap),
passwordInfoRepo: db.NewPasswordInfoRepo(dbMap), passwordInfoRepo: db.NewPasswordInfoRepo(dbMap),
clientIdentityRepo: db.NewClientIdentityRepo(dbMap), clientRepo: db.NewClientRepo(dbMap),
localConnectorID: localConnectorID, localConnectorID: localConnectorID,
} }
} }
@ -136,7 +136,7 @@ func (a *AdminAPI) CreateClient(req adminschema.ClientCreateRequest) (adminschem
cli.Credentials.ID = id cli.Credentials.ID = id
creds, err := a.clientIdentityRepo.New(cli) creds, err := a.clientRepo.New(cli)
if err != nil { if err != nil {
return adminschema.ClientCreateResponse{}, mapError(err) return adminschema.ClientCreateResponse{}, mapError(err)
} }

6
client/client.go
View file

@ -23,7 +23,7 @@ type Client struct {
Admin bool Admin bool
} }
type ClientIdentityRepo interface { type ClientRepo interface {
Get(clientID string) (Client, error) Get(clientID string) (Client, error)
// Metadata returns one matching ClientMetadata if the given client // Metadata returns one matching ClientMetadata if the given client
@ -37,10 +37,10 @@ type ClientIdentityRepo interface {
// to make these assertions will a non-nil error be returned. // to make these assertions will a non-nil error be returned.
Authenticate(creds oidc.ClientCredentials) (bool, error) Authenticate(creds oidc.ClientCredentials) (bool, error)
// All returns all registered Client Identities. // All returns all registered Clients
All() ([]Client, error) All() ([]Client, error)
// New registers a ClientIdentity with the repo for the given metadata. // New registers a Client with the repo.
// An unused ID must be provided. A corresponding secret will be returned // An unused ID must be provided. A corresponding secret will be returned
// in a ClientCredentials struct along with the provided ID. // in a ClientCredentials struct along with the provided ID.
New(client Client) (*oidc.ClientCredentials, error) New(client Client) (*oidc.ClientCredentials, error)

4
cmd/dexctl/driver_db.go
View file

@ -14,7 +14,7 @@ func newDBDriver(dsn string) (driver, error) {
} }
drv := &dbDriver{ drv := &dbDriver{
ciRepo: db.NewClientIdentityRepo(dbc), ciRepo: db.NewClientRepo(dbc),
cfgRepo: db.NewConnectorConfigRepo(dbc), cfgRepo: db.NewConnectorConfigRepo(dbc),
} }
@ -22,7 +22,7 @@ func newDBDriver(dsn string) (driver, error) {
} }
type dbDriver struct { type dbDriver struct {
ciRepo client.ClientIdentityRepo ciRepo client.ClientRepo
cfgRepo *db.ConnectorConfigRepo cfgRepo *db.ConnectorConfigRepo
} }

79
db/client.go
View file

@ -18,7 +18,7 @@ import (
) )
const ( const (
clientIdentityTableName = "client_identity" clientTableName = "client_identity"
bcryptHashCost = 10 bcryptHashCost = 10
@ -34,19 +34,18 @@ const (
func init() { func init() {
register(table{ register(table{
name: clientIdentityTableName, name: clientTableName,
model: clientIdentityModel{}, model: clientModel{},
autoinc: false, autoinc: false,
pkey: []string{"id"}, pkey: []string{"id"},
}) })
} }
func newClientIdentityModel(cli client.Client) (*clientIdentityModel, error) { func newClientModel(cli client.Client) (*clientModel, error) {
secretBytes, err := base64.URLEncoding.DecodeString(cli.Credentials.Secret) secretBytes, err := base64.URLEncoding.DecodeString(cli.Credentials.Secret)
if err != nil { if err != nil {
return nil, err return nil, err
} }
hashed, err := bcrypt.GenerateFromPassword([]byte( hashed, err := bcrypt.GenerateFromPassword([]byte(
secretBytes), secretBytes),
bcryptHashCost) bcryptHashCost)
@ -59,7 +58,7 @@ func newClientIdentityModel(cli client.Client) (*clientIdentityModel, error) {
return nil, err return nil, err
} }
cim := clientIdentityModel{ cim := clientModel{
ID: cli.Credentials.ID, ID: cli.Credentials.ID,
Secret: hashed, Secret: hashed,
Metadata: string(bmeta), Metadata: string(bmeta),
@ -69,14 +68,14 @@ func newClientIdentityModel(cli client.Client) (*clientIdentityModel, error) {
return &cim, nil return &cim, nil
} }
type clientIdentityModel struct { type clientModel struct {
ID string `db:"id"` ID string `db:"id"`
Secret []byte `db:"secret"` Secret []byte `db:"secret"`
Metadata string `db:"metadata"` Metadata string `db:"metadata"`
DexAdmin bool `db:"dex_admin"` DexAdmin bool `db:"dex_admin"`
} }
func (m *clientIdentityModel) Client() (*client.Client, error) { func (m *clientModel) Client() (*client.Client, error) {
ci := client.Client{ ci := client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: m.ID, ID: m.ID,
@ -92,16 +91,16 @@ func (m *clientIdentityModel) Client() (*client.Client, error) {
return &ci, nil return &ci, nil
} }
func NewClientIdentityRepo(dbm *gorp.DbMap) client.ClientIdentityRepo { func NewClientRepo(dbm *gorp.DbMap) client.ClientRepo {
return newClientIdentityRepo(dbm) return newClientRepo(dbm)
} }
func newClientIdentityRepo(dbm *gorp.DbMap) *clientIdentityRepo { func newClientRepo(dbm *gorp.DbMap) *clientRepo {
return &clientIdentityRepo{db: &db{dbm}} return &clientRepo{db: &db{dbm}}
} }
func NewClientIdentityRepoFromClients(dbm *gorp.DbMap, clients []client.Client) (client.ClientIdentityRepo, error) { func NewClientRepoFromClients(dbm *gorp.DbMap, clients []client.Client) (client.ClientRepo, error) {
repo := newClientIdentityRepo(dbm) repo := newClientRepo(dbm)
tx, err := repo.begin() tx, err := repo.begin()
if err != nil { if err != nil {
return nil, err return nil, err
@ -112,7 +111,7 @@ func NewClientIdentityRepoFromClients(dbm *gorp.DbMap, clients []client.Client)
if c.Credentials.Secret == "" { if c.Credentials.Secret == "" {
return nil, fmt.Errorf("client %q has no secret", c.Credentials.ID) return nil, fmt.Errorf("client %q has no secret", c.Credentials.ID)
} }
cm, err := newClientIdentityModel(c) cm, err := newClientModel(c)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -127,13 +126,12 @@ func NewClientIdentityRepoFromClients(dbm *gorp.DbMap, clients []client.Client)
return repo, nil return repo, nil
} }
type clientIdentityRepo struct { type clientRepo struct {
*db *db
} }
func (r *clientIdentityRepo) Get(clientID string) (client.Client, error) { func (r *clientRepo) Get(clientID string) (client.Client, error) {
m, err := r.executor(nil).Get(clientIdentityModel{}, clientID) m, err := r.executor(nil).Get(clientModel{}, clientID)
if err == sql.ErrNoRows || m == nil { if err == sql.ErrNoRows || m == nil {
return client.Client{}, client.ErrorNotFound return client.Client{}, client.ErrorNotFound
} }
@ -141,7 +139,7 @@ func (r *clientIdentityRepo) Get(clientID string) (client.Client, error) {
return client.Client{}, err return client.Client{}, err
} }
cim, ok := m.(*clientIdentityModel) cim, ok := m.(*clientModel)
if !ok { if !ok {
log.Errorf("expected clientModel but found %v", reflect.TypeOf(m)) log.Errorf("expected clientModel but found %v", reflect.TypeOf(m))
return client.Client{}, errors.New("unrecognized model") return client.Client{}, errors.New("unrecognized model")
@ -155,7 +153,7 @@ func (r *clientIdentityRepo) Get(clientID string) (client.Client, error) {
return *ci, nil return *ci, nil
} }
func (r *clientIdentityRepo) Metadata(clientID string) (*oidc.ClientMetadata, error) { func (r *clientRepo) Metadata(clientID string) (*oidc.ClientMetadata, error) {
c, err := r.Get(clientID) c, err := r.Get(clientID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -164,22 +162,22 @@ func (r *clientIdentityRepo) Metadata(clientID string) (*oidc.ClientMetadata, er
return &c.Metadata, nil return &c.Metadata, nil
} }
func (r *clientIdentityRepo) IsDexAdmin(clientID string) (bool, error) { func (r *clientRepo) IsDexAdmin(clientID string) (bool, error) {
m, err := r.executor(nil).Get(clientIdentityModel{}, clientID) m, err := r.executor(nil).Get(clientModel{}, clientID)
if m == nil || err != nil { if m == nil || err != nil {
return false, err return false, err
} }
cim, ok := m.(*clientIdentityModel) cim, ok := m.(*clientModel)
if !ok { if !ok {
log.Errorf("expected clientIdentityModel but found %v", reflect.TypeOf(m)) log.Errorf("expected clientModel but found %v", reflect.TypeOf(m))
return false, errors.New("unrecognized model") return false, errors.New("unrecognized model")
} }
return cim.DexAdmin, nil return cim.DexAdmin, nil
} }
func (r *clientIdentityRepo) SetDexAdmin(clientID string, isAdmin bool) error { func (r *clientRepo) SetDexAdmin(clientID string, isAdmin bool) error {
tx, err := r.begin() tx, err := r.begin()
if err != nil { if err != nil {
return err return err
@ -187,14 +185,14 @@ func (r *clientIdentityRepo) SetDexAdmin(clientID string, isAdmin bool) error {
defer tx.Rollback() defer tx.Rollback()
exec := r.executor(tx) exec := r.executor(tx)
m, err := exec.Get(clientIdentityModel{}, clientID) m, err := exec.Get(clientModel{}, clientID)
if m == nil || err != nil { if m == nil || err != nil {
return err return err
} }
cim, ok := m.(*clientIdentityModel) cim, ok := m.(*clientModel)
if !ok { if !ok {
log.Errorf("expected clientIdentityModel but found %v", reflect.TypeOf(m)) log.Errorf("expected clientModel but found %v", reflect.TypeOf(m))
return errors.New("unrecognized model") return errors.New("unrecognized model")
} }
@ -207,15 +205,15 @@ func (r *clientIdentityRepo) SetDexAdmin(clientID string, isAdmin bool) error {
return tx.Commit() return tx.Commit()
} }
func (r *clientIdentityRepo) Authenticate(creds oidc.ClientCredentials) (bool, error) { func (r *clientRepo) Authenticate(creds oidc.ClientCredentials) (bool, error) {
m, err := r.executor(nil).Get(clientIdentityModel{}, creds.ID) m, err := r.executor(nil).Get(clientModel{}, creds.ID)
if m == nil || err != nil { if m == nil || err != nil {
return false, err return false, err
} }
cim, ok := m.(*clientIdentityModel) cim, ok := m.(*clientModel)
if !ok { if !ok {
log.Errorf("expected clientIdentityModel but found %v", reflect.TypeOf(m)) log.Errorf("expected clientModel but found %v", reflect.TypeOf(m))
return false, errors.New("unrecognized model") return false, errors.New("unrecognized model")
} }
@ -252,14 +250,15 @@ func isAlreadyExistsErr(err error) bool {
return false return false
} }
func (r *clientIdentityRepo) New(cli client.Client) (*oidc.ClientCredentials, error) { func (r *clientRepo) New(cli client.Client) (*oidc.ClientCredentials, error) {
secret, err := pcrypto.RandBytes(maxSecretLength) secret, err := pcrypto.RandBytes(maxSecretLength)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cli.Credentials.Secret = base64.URLEncoding.EncodeToString(secret) cli.Credentials.Secret = base64.URLEncoding.EncodeToString(secret)
cim, err := newClientIdentityModel(cli) cim, err := newClientModel(cli)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -279,19 +278,19 @@ func (r *clientIdentityRepo) New(cli client.Client) (*oidc.ClientCredentials, er
return &cc, nil return &cc, nil
} }
func (r *clientIdentityRepo) All() ([]client.Client, error) { func (r *clientRepo) All() ([]client.Client, error) {
qt := r.quote(clientIdentityTableName) qt := r.quote(clientTableName)
q := fmt.Sprintf("SELECT * FROM %s", qt) q := fmt.Sprintf("SELECT * FROM %s", qt)
objs, err := r.executor(nil).Select(&clientIdentityModel{}, q) objs, err := r.executor(nil).Select(&clientModel{}, q)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs := make([]client.Client, len(objs)) cs := make([]client.Client, len(objs))
for i, obj := range objs { for i, obj := range objs {
m, ok := obj.(*clientIdentityModel) m, ok := obj.(*clientModel)
if !ok { if !ok {
return nil, errors.New("unable to cast client identity to clientIdentityModel") return nil, errors.New("unable to cast client identity to clientModel")
} }
ci, err := m.Client() ci, err := m.Client()

6
db/migrate_test.go
View file

@ -88,7 +88,7 @@ func TestMigrateClientMetadata(t *testing.T) {
} }
for i, tt := range tests { for i, tt := range tests {
model := &clientIdentityModel{ model := &clientModel{
ID: strconv.Itoa(i), ID: strconv.Itoa(i),
Secret: []byte("verysecret"), Secret: []byte("verysecret"),
Metadata: tt.before, Metadata: tt.before,
@ -108,12 +108,12 @@ func TestMigrateClientMetadata(t *testing.T) {
for i, tt := range tests { for i, tt := range tests {
id := strconv.Itoa(i) id := strconv.Itoa(i)
m, err := dbMap.Get(clientIdentityModel{}, id) m, err := dbMap.Get(clientModel{}, id)
if err != nil { if err != nil {
t.Errorf("case %d: failed to get model: %v", i, err) t.Errorf("case %d: failed to get model: %v", i, err)
continue continue
} }
cim, ok := m.(*clientIdentityModel) cim, ok := m.(*clientModel)
if !ok { if !ok {
t.Errorf("case %d: unrecognized model type: %T", i, m) t.Errorf("case %d: unrecognized model type: %T", i, m)
continue continue

4
db/refresh.go
View file

@ -189,9 +189,9 @@ func (r *refreshTokenRepo) RevokeTokensForClient(userID, clientID string) error
func (r *refreshTokenRepo) ClientsWithRefreshTokens(userID string) ([]client.Client, error) { func (r *refreshTokenRepo) ClientsWithRefreshTokens(userID string) ([]client.Client, error) {
q := `SELECT c.* FROM %s as c q := `SELECT c.* FROM %s as c
INNER JOIN %s as r ON c.id = r.client_id WHERE r.user_id = $1;` INNER JOIN %s as r ON c.id = r.client_id WHERE r.user_id = $1;`
q = fmt.Sprintf(q, r.quote(clientIdentityTableName), r.quote(refreshTokenTableName)) q = fmt.Sprintf(q, r.quote(clientTableName), r.quote(refreshTokenTableName))
var clients []clientIdentityModel var clients []clientModel
if _, err := r.executor(nil).Select(&clients, q, userID); err != nil { if _, err := r.executor(nil).Select(&clients, q, userID); err != nil {
return nil, err return nil, err
} }

20
functional/db_test.go
View file

@ -181,8 +181,8 @@ func TestDBPrivateKeySetRepoSetGet(t *testing.T) {
} }
} }
func TestDBClientIdentityRepoMetadata(t *testing.T) { func TestDBClientRepoMetadata(t *testing.T) {
r := db.NewClientIdentityRepo(connect(t)) r := db.NewClientRepo(connect(t))
cm := oidc.ClientMetadata{ cm := oidc.ClientMetadata{
RedirectURIs: []url.URL{ RedirectURIs: []url.URL{
@ -211,8 +211,8 @@ func TestDBClientIdentityRepoMetadata(t *testing.T) {
} }
} }
func TestDBClientIdentityRepoMetadataNoExist(t *testing.T) { func TestDBClientRepoMetadataNoExist(t *testing.T) {
r := db.NewClientIdentityRepo(connect(t)) r := db.NewClientRepo(connect(t))
got, err := r.Metadata("noexist") got, err := r.Metadata("noexist")
if err != client.ErrorNotFound { if err != client.ErrorNotFound {
@ -223,8 +223,8 @@ func TestDBClientIdentityRepoMetadataNoExist(t *testing.T) {
} }
} }
func TestDBClientIdentityRepoNewDuplicate(t *testing.T) { func TestDBClientRepoNewDuplicate(t *testing.T) {
r := db.NewClientIdentityRepo(connect(t)) r := db.NewClientRepo(connect(t))
meta1 := oidc.ClientMetadata{ meta1 := oidc.ClientMetadata{
RedirectURIs: []url.URL{ RedirectURIs: []url.URL{
@ -257,8 +257,8 @@ func TestDBClientIdentityRepoNewDuplicate(t *testing.T) {
} }
} }
func TestDBClientIdentityRepoAuthenticate(t *testing.T) { func TestDBClientRepoAuthenticate(t *testing.T) {
r := db.NewClientIdentityRepo(connect(t)) r := db.NewClientRepo(connect(t))
cm := oidc.ClientMetadata{ cm := oidc.ClientMetadata{
RedirectURIs: []url.URL{ RedirectURIs: []url.URL{
@ -310,8 +310,8 @@ func TestDBClientIdentityRepoAuthenticate(t *testing.T) {
} }
} }
func TestDBClientIdentityAll(t *testing.T) { func TestDBClientAll(t *testing.T) {
r := db.NewClientIdentityRepo(connect(t)) r := db.NewClientRepo(connect(t))
cm := oidc.ClientMetadata{ cm := oidc.ClientMetadata{
RedirectURIs: []url.URL{ RedirectURIs: []url.URL{

6
functional/repo/client_repo_test.go
View file

@ -48,7 +48,7 @@ var (
} }
) )
func newClientIdentityRepo(t *testing.T) client.ClientIdentityRepo { func newClientRepo(t *testing.T) client.ClientRepo {
dsn := os.Getenv("DEX_TEST_DSN") dsn := os.Getenv("DEX_TEST_DSN")
var dbMap *gorp.DbMap var dbMap *gorp.DbMap
if dsn == "" { if dsn == "" {
@ -56,7 +56,7 @@ func newClientIdentityRepo(t *testing.T) client.ClientIdentityRepo {
} else { } else {
dbMap = connect(t) dbMap = connect(t)
} }
repo, err := db.NewClientIdentityRepoFromClients(dbMap, testClients) repo, err := db.NewClientRepoFromClients(dbMap, testClients)
if err != nil { if err != nil {
t.Fatalf("failed to create client repo from clients: %v", err) t.Fatalf("failed to create client repo from clients: %v", err)
} }
@ -101,7 +101,7 @@ func TestGetSetAdminClient(t *testing.T) {
Tests: Tests:
for i, tt := range tests { for i, tt := range tests {
repo := newClientIdentityRepo(t) repo := newClientRepo(t)
for _, cid := range startAdmins { for _, cid := range startAdmins {
err := repo.SetDexAdmin(cid, true) err := repo.SetDexAdmin(cid, true)
if err != nil { if err != nil {

2
functional/repo/refresh_repo_test.go
View file

@ -27,7 +27,7 @@ func newRefreshRepo(t *testing.T, users []user.UserWithRemoteIdentities, clients
if _, err := db.NewUserRepoFromUsers(dbMap, users); err != nil { if _, err := db.NewUserRepoFromUsers(dbMap, users); err != nil {
t.Fatalf("Unable to add users: %v", err) t.Fatalf("Unable to add users: %v", err)
} }
if _, err := db.NewClientIdentityRepoFromClients(dbMap, clients); err != nil { if _, err := db.NewClientRepoFromClients(dbMap, clients); err != nil {
t.Fatalf("Unable to add clients: %v", err) t.Fatalf("Unable to add clients: %v", err)
} }
return db.NewRefreshTokenRepo(dbMap) return db.NewRefreshTokenRepo(dbMap)

2
integration/client_api_test.go
View file

@ -73,7 +73,7 @@ func TestClientCreate(t *testing.T) {
t.Error("Expected non-empty Client Secret") t.Error("Expected non-empty Client Secret")
} }
meta, err := srv.ClientIdentityRepo.Metadata(newClient.Id) meta, err := srv.ClientRepo.Metadata(newClient.Id)
if err != nil { if err != nil {
t.Errorf("Error looking up client metadata: %v", err) t.Errorf("Error looking up client metadata: %v", err)
} else if meta == nil { } else if meta == nil {

8
integration/oidc_test.go
View file

@ -35,7 +35,7 @@ func mockServer(cis []client.Client) (*server.Server, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
clientIdentityRepo, err := db.NewClientIdentityRepoFromClients(dbMap, cis) clientRepo, err := db.NewClientRepoFromClients(dbMap, cis)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -44,7 +44,7 @@ func mockServer(cis []client.Client) (*server.Server, error) {
srv := &server.Server{ srv := &server.Server{
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
KeyManager: km, KeyManager: km,
ClientIdentityRepo: clientIdentityRepo, ClientRepo: clientRepo,
SessionManager: sm, SessionManager: sm,
} }
@ -125,7 +125,7 @@ func TestHTTPExchangeTokenRefreshToken(t *testing.T) {
} }
dbMap := db.NewMemDB() dbMap := db.NewMemDB()
cir, err := db.NewClientIdentityRepoFromClients(dbMap, []client.Client{ci}) cir, err := db.NewClientRepoFromClients(dbMap, []client.Client{ci})
if err != nil { if err != nil {
t.Fatalf("Failed to create client identity repo: " + err.Error()) t.Fatalf("Failed to create client identity repo: " + err.Error())
} }
@ -164,7 +164,7 @@ func TestHTTPExchangeTokenRefreshToken(t *testing.T) {
IssuerURL: issuerURL, IssuerURL: issuerURL,
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: cir, ClientRepo: cir,
Templates: template.New(connector.LoginPageTemplateName), Templates: template.New(connector.LoginPageTemplateName),
Connectors: []connector.Connector{}, Connectors: []connector.Connector{},
UserRepo: userRepo, UserRepo: userRepo,

4
integration/user_api_test.go
View file

@ -101,8 +101,8 @@ func makeUserAPITestFixtures() *userAPITestFixtures {
f := &userAPITestFixtures{} f := &userAPITestFixtures{}
dbMap, _, _, um := makeUserObjects(userUsers, userPasswords) dbMap, _, _, um := makeUserObjects(userUsers, userPasswords)
cir := func() client.ClientIdentityRepo { cir := func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(dbMap, []client.Client{ repo, err := db.NewClientRepoFromClients(dbMap, []client.Client{
client.Client{ client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: testClientID, ID: testClientID,

1
schema/adminschema/v1-json.go
View file

@ -1,4 +1,5 @@
package adminschema package adminschema
// //
// This file is automatically generated by schema/generator // This file is automatically generated by schema/generator
// //

1
schema/workerschema/v1-json.go
View file

@ -1,4 +1,5 @@
package workerschema package workerschema
// //
// This file is automatically generated by schema/generator // This file is automatically generated by schema/generator
// //

4
server/auth_middleware.go
View file

@ -14,7 +14,7 @@ import (
type clientTokenMiddleware struct { type clientTokenMiddleware struct {
issuerURL string issuerURL string
ciRepo client.ClientIdentityRepo ciRepo client.ClientRepo
keysFunc func() ([]key.PublicKey, error) keysFunc func() ([]key.PublicKey, error)
next http.Handler next http.Handler
} }
@ -31,7 +31,7 @@ func (c *clientTokenMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request
} }
if c.ciRepo == nil { if c.ciRepo == nil {
log.Errorf("Misconfigured clientTokenMiddleware, ClientIdentityRepo is not set") log.Errorf("Misconfigured clientTokenMiddleware, ClientRepo is not set")
respondError() respondError()
return return
} }

6
server/auth_middleware_test.go
View file

@ -37,7 +37,7 @@ func TestClientToken(t *testing.T) {
}, },
}, },
} }
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ci}) repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{ci})
if err != nil { if err != nil {
t.Fatalf("Failed to create client identity repo: %v", err) t.Fatalf("Failed to create client identity repo: %v", err)
} }
@ -65,7 +65,7 @@ func TestClientToken(t *testing.T) {
tests := []struct { tests := []struct {
keys []key.PublicKey keys []key.PublicKey
repo client.ClientIdentityRepo repo client.ClientRepo
header string header string
wantCode int wantCode int
}{ }{
@ -114,7 +114,7 @@ func TestClientToken(t *testing.T) {
// empty repo // empty repo
{ {
keys: []key.PublicKey{pubKey}, keys: []key.PublicKey{pubKey},
repo: db.NewClientIdentityRepo(db.NewMemDB()), repo: db.NewClientRepo(db.NewMemDB()),
header: fmt.Sprintf("BEARER %s", validJWT), header: fmt.Sprintf("BEARER %s", validJWT),
wantCode: http.StatusUnauthorized, wantCode: http.StatusUnauthorized,
}, },

2
server/client_registration.go
View file

@ -45,7 +45,7 @@ func (s *Server) handleClientRegistrationRequest(r *http.Request) (*oidc.ClientR
return nil, newAPIError(oauth2.ErrorServerError, "unable to save client metadata") return nil, newAPIError(oauth2.ErrorServerError, "unable to save client metadata")
} }
creds, err := s.ClientIdentityRepo.New(client.Client{ creds, err := s.ClientRepo.New(client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: id, ID: id,
}, },

2
server/client_registration_test.go
View file

@ -143,7 +143,7 @@ func TestClientRegistration(t *testing.T) {
return fmt.Errorf("no client id in registration response") return fmt.Errorf("no client id in registration response")
} }
metadata, err := fixtures.clientIdentityRepo.Metadata(r.ClientID) metadata, err := fixtures.clientRepo.Metadata(r.ClientID)
if err != nil { if err != nil {
return fmt.Errorf("failed to lookup client id after creation") return fmt.Errorf("failed to lookup client id after creation")
} }

4
server/client_resource.go
View file

@ -14,10 +14,10 @@ import (
) )
type clientResource struct { type clientResource struct {
repo client.ClientIdentityRepo repo client.ClientRepo
} }
func registerClientResource(prefix string, repo client.ClientIdentityRepo) (string, http.Handler) { func registerClientResource(prefix string, repo client.ClientRepo) (string, http.Handler) {
mux := http.NewServeMux() mux := http.NewServeMux()
c := &clientResource{ c := &clientResource{
repo: repo, repo: repo,

6
server/client_resource_test.go
View file

@ -28,7 +28,7 @@ func makeBody(s string) io.ReadCloser {
func TestCreateInvalidRequest(t *testing.T) { func TestCreateInvalidRequest(t *testing.T) {
u := &url.URL{Scheme: "http", Host: "example.com", Path: "clients"} u := &url.URL{Scheme: "http", Host: "example.com", Path: "clients"}
h := http.Header{"Content-Type": []string{"application/json"}} h := http.Header{"Content-Type": []string{"application/json"}}
repo := db.NewClientIdentityRepo(db.NewMemDB()) repo := db.NewClientRepo(db.NewMemDB())
res := &clientResource{repo: repo} res := &clientResource{repo: repo}
tests := []struct { tests := []struct {
req *http.Request req *http.Request
@ -119,7 +119,7 @@ func TestCreateInvalidRequest(t *testing.T) {
} }
func TestCreate(t *testing.T) { func TestCreate(t *testing.T) {
repo := db.NewClientIdentityRepo(db.NewMemDB()) repo := db.NewClientRepo(db.NewMemDB())
res := &clientResource{repo: repo} res := &clientResource{repo: repo}
tests := [][]string{ tests := [][]string{
[]string{"http://example.com"}, []string{"http://example.com"},
@ -239,7 +239,7 @@ func TestList(t *testing.T) {
} }
for i, tt := range tests { for i, tt := range tests {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), tt.cs) repo, err := db.NewClientRepoFromClients(db.NewMemDB(), tt.cs)
if err != nil { if err != nil {
t.Errorf("case %d: failed to create client identity repo: %v", i, err) t.Errorf("case %d: failed to create client identity repo: %v", i, err)
continue continue

8
server/config.go
View file

@ -114,7 +114,7 @@ func (cfg *SingleServerConfig) Configure(srv *Server) error {
if err != nil { if err != nil {
return fmt.Errorf("unable to read clients from file %s: %v", cfg.ClientsFile, err) return fmt.Errorf("unable to read clients from file %s: %v", cfg.ClientsFile, err)
} }
ciRepo, err := db.NewClientIdentityRepoFromClients(dbMap, clients) ciRepo, err := db.NewClientRepoFromClients(dbMap, clients)
if err != nil { if err != nil {
return fmt.Errorf("failed to create client identity repo: %v", err) return fmt.Errorf("failed to create client identity repo: %v", err)
} }
@ -155,7 +155,7 @@ func (cfg *SingleServerConfig) Configure(srv *Server) error {
txnFactory := db.TransactionFactory(dbMap) txnFactory := db.TransactionFactory(dbMap)
userManager := usermanager.NewUserManager(userRepo, pwiRepo, cfgRepo, txnFactory, usermanager.ManagerOptions{}) userManager := usermanager.NewUserManager(userRepo, pwiRepo, cfgRepo, txnFactory, usermanager.ManagerOptions{})
srv.ClientIdentityRepo = ciRepo srv.ClientRepo = ciRepo
srv.KeySetRepo = kRepo srv.KeySetRepo = kRepo
srv.ConnectorConfigRepo = cfgRepo srv.ConnectorConfigRepo = cfgRepo
srv.UserRepo = userRepo srv.UserRepo = userRepo
@ -246,7 +246,7 @@ func (cfg *MultiServerConfig) Configure(srv *Server) error {
return fmt.Errorf("unable to create PrivateKeySetRepo: %v", err) return fmt.Errorf("unable to create PrivateKeySetRepo: %v", err)
} }
ciRepo := db.NewClientIdentityRepo(dbc) ciRepo := db.NewClientRepo(dbc)
sRepo := db.NewSessionRepo(dbc) sRepo := db.NewSessionRepo(dbc)
skRepo := db.NewSessionKeyRepo(dbc) skRepo := db.NewSessionKeyRepo(dbc)
cfgRepo := db.NewConnectorConfigRepo(dbc) cfgRepo := db.NewConnectorConfigRepo(dbc)
@ -257,7 +257,7 @@ func (cfg *MultiServerConfig) Configure(srv *Server) error {
sm := sessionmanager.NewSessionManager(sRepo, skRepo) sm := sessionmanager.NewSessionManager(sRepo, skRepo)
srv.ClientIdentityRepo = ciRepo srv.ClientRepo = ciRepo
srv.KeySetRepo = kRepo srv.KeySetRepo = kRepo
srv.ConnectorConfigRepo = cfgRepo srv.ConnectorConfigRepo = cfgRepo
srv.UserRepo = userRepo srv.UserRepo = userRepo

4
server/email_verification.go
View file

@ -28,7 +28,7 @@ func handleVerifyEmailResendFunc(
srvKeysFunc func() ([]key.PublicKey, error), srvKeysFunc func() ([]key.PublicKey, error),
emailer *useremail.UserEmailer, emailer *useremail.UserEmailer,
userRepo user.UserRepo, userRepo user.UserRepo,
clientIdentityRepo client.ClientIdentityRepo) http.HandlerFunc { clientRepo client.ClientRepo) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) { return func(w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body) decoder := json.NewDecoder(r.Body)
var params struct { var params struct {
@ -57,7 +57,7 @@ func handleVerifyEmailResendFunc(
return return
} }
cm, err := clientIdentityRepo.Metadata(clientID) cm, err := clientRepo.Metadata(clientID)
if err == client.ErrorNotFound { if err == client.ErrorNotFound {
log.Errorf("No such client: %v", err) log.Errorf("No such client: %v", err)
writeAPIError(w, http.StatusBadRequest, writeAPIError(w, http.StatusBadRequest,

2
server/email_verification_test.go
View file

@ -130,7 +130,7 @@ func TestHandleVerifyEmailResend(t *testing.T) {
keysFunc, keysFunc,
f.srv.UserEmailer, f.srv.UserEmailer,
f.userRepo, f.userRepo,
f.clientIdentityRepo) f.clientRepo)
w := httptest.NewRecorder() w := httptest.NewRecorder()
u := "http://example.com" u := "http://example.com"

8
server/http_test.go
View file

@ -78,8 +78,8 @@ func TestHandleAuthFuncResponsesSingleRedirectURL(t *testing.T) {
srv := &Server{ srv := &Server{
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
SessionManager: manager.NewSessionManager(db.NewSessionRepo(db.NewMemDB()), db.NewSessionKeyRepo(db.NewMemDB())), SessionManager: manager.NewSessionManager(db.NewSessionRepo(db.NewMemDB()), db.NewSessionKeyRepo(db.NewMemDB())),
ClientIdentityRepo: func() client.ClientIdentityRepo { ClientRepo: func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{ client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: "XXX", ID: "XXX",
@ -230,8 +230,8 @@ func TestHandleAuthFuncResponsesMultipleRedirectURLs(t *testing.T) {
srv := &Server{ srv := &Server{
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
SessionManager: manager.NewSessionManager(db.NewSessionRepo(db.NewMemDB()), db.NewSessionKeyRepo(db.NewMemDB())), SessionManager: manager.NewSessionManager(db.NewSessionRepo(db.NewMemDB()), db.NewSessionKeyRepo(db.NewMemDB())),
ClientIdentityRepo: func() client.ClientIdentityRepo { ClientRepo: func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{ client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: "XXX", ID: "XXX",

2
server/password.go
View file

@ -29,7 +29,7 @@ type SendResetPasswordEmailHandler struct {
tpl *template.Template tpl *template.Template
emailer *useremail.UserEmailer emailer *useremail.UserEmailer
sm *sessionmanager.SessionManager sm *sessionmanager.SessionManager
cr client.ClientIdentityRepo cr client.ClientRepo
} }
func (h *SendResetPasswordEmailHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { func (h *SendResetPasswordEmailHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

2
server/password_test.go
View file

@ -267,7 +267,7 @@ func TestSendResetPasswordEmailHandler(t *testing.T) {
tpl: f.srv.SendResetPasswordEmailTemplate, tpl: f.srv.SendResetPasswordEmailTemplate,
emailer: f.srv.UserEmailer, emailer: f.srv.UserEmailer,
sm: f.sessionManager, sm: f.sessionManager,
cr: f.clientIdentityRepo, cr: f.clientRepo,
} }
w := httptest.NewRecorder() w := httptest.NewRecorder()

20
server/server.go
View file

@ -60,7 +60,7 @@ type Server struct {
KeyManager key.PrivateKeyManager KeyManager key.PrivateKeyManager
KeySetRepo key.PrivateKeySetRepo KeySetRepo key.PrivateKeySetRepo
SessionManager *sessionmanager.SessionManager SessionManager *sessionmanager.SessionManager
ClientIdentityRepo client.ClientIdentityRepo ClientRepo client.ClientRepo
ConnectorConfigRepo connector.ConnectorConfigRepo ConnectorConfigRepo connector.ConnectorConfigRepo
Templates *template.Template Templates *template.Template
LoginTemplate *template.Template LoginTemplate *template.Template
@ -213,13 +213,13 @@ func (s *Server) HTTPHandler() http.Handler {
s.KeyManager.PublicKeys, s.KeyManager.PublicKeys,
s.UserEmailer, s.UserEmailer,
s.UserRepo, s.UserRepo,
s.ClientIdentityRepo))) s.ClientRepo)))
mux.Handle(httpPathSendResetPassword, &SendResetPasswordEmailHandler{ mux.Handle(httpPathSendResetPassword, &SendResetPasswordEmailHandler{
tpl: s.SendResetPasswordEmailTemplate, tpl: s.SendResetPasswordEmailTemplate,
emailer: s.UserEmailer, emailer: s.UserEmailer,
sm: s.SessionManager, sm: s.SessionManager,
cr: s.ClientIdentityRepo, cr: s.ClientRepo,
}) })
mux.Handle(httpPathResetPassword, &ResetPasswordHandler{ mux.Handle(httpPathResetPassword, &ResetPasswordHandler{
@ -256,11 +256,11 @@ func (s *Server) HTTPHandler() http.Handler {
apiBasePath := path.Join(httpPathAPI, APIVersion) apiBasePath := path.Join(httpPathAPI, APIVersion)
registerDiscoveryResource(apiBasePath, mux) registerDiscoveryResource(apiBasePath, mux)
clientPath, clientHandler := registerClientResource(apiBasePath, s.ClientIdentityRepo) clientPath, clientHandler := registerClientResource(apiBasePath, s.ClientRepo)
mux.Handle(path.Join(apiBasePath, clientPath), s.NewClientTokenAuthHandler(clientHandler)) mux.Handle(path.Join(apiBasePath, clientPath), s.NewClientTokenAuthHandler(clientHandler))
usersAPI := usersapi.NewUsersAPI(s.dbMap, s.UserManager, s.UserEmailer, s.localConnectorID) usersAPI := usersapi.NewUsersAPI(s.dbMap, s.UserManager, s.UserEmailer, s.localConnectorID)
handler := NewUserMgmtServer(usersAPI, s.JWTVerifierFactory(), s.UserManager, s.ClientIdentityRepo).HTTPHandler() handler := NewUserMgmtServer(usersAPI, s.JWTVerifierFactory(), s.UserManager, s.ClientRepo).HTTPHandler()
mux.Handle(apiBasePath+"/", handler) mux.Handle(apiBasePath+"/", handler)
@ -271,14 +271,14 @@ func (s *Server) HTTPHandler() http.Handler {
func (s *Server) NewClientTokenAuthHandler(handler http.Handler) http.Handler { func (s *Server) NewClientTokenAuthHandler(handler http.Handler) http.Handler {
return &clientTokenMiddleware{ return &clientTokenMiddleware{
issuerURL: s.IssuerURL.String(), issuerURL: s.IssuerURL.String(),
ciRepo: s.ClientIdentityRepo, ciRepo: s.ClientRepo,
keysFunc: s.KeyManager.PublicKeys, keysFunc: s.KeyManager.PublicKeys,
next: handler, next: handler,
} }
} }
func (s *Server) ClientMetadata(clientID string) (*oidc.ClientMetadata, error) { func (s *Server) ClientMetadata(clientID string) (*oidc.ClientMetadata, error) {
return s.ClientIdentityRepo.Metadata(clientID) return s.ClientRepo.Metadata(clientID)
} }
func (s *Server) NewSession(ipdcID, clientID, clientState string, redirectURL url.URL, nonce string, register bool, scope []string) (string, error) { func (s *Server) NewSession(ipdcID, clientID, clientState string, redirectURL url.URL, nonce string, register bool, scope []string) (string, error) {
@ -365,7 +365,7 @@ func (s *Server) Login(ident oidc.Identity, key string) (string, error) {
} }
func (s *Server) ClientCredsToken(creds oidc.ClientCredentials) (*jose.JWT, error) { func (s *Server) ClientCredsToken(creds oidc.ClientCredentials) (*jose.JWT, error) {
ok, err := s.ClientIdentityRepo.Authenticate(creds) ok, err := s.ClientRepo.Authenticate(creds)
if err != nil { if err != nil {
log.Errorf("Failed fetching client %s from repo: %v", creds.ID, err) log.Errorf("Failed fetching client %s from repo: %v", creds.ID, err)
return nil, oauth2.NewError(oauth2.ErrorServerError) return nil, oauth2.NewError(oauth2.ErrorServerError)
@ -397,7 +397,7 @@ func (s *Server) ClientCredsToken(creds oidc.ClientCredentials) (*jose.JWT, erro
} }
func (s *Server) CodeToken(creds oidc.ClientCredentials, sessionKey string) (*jose.JWT, string, error) { func (s *Server) CodeToken(creds oidc.ClientCredentials, sessionKey string) (*jose.JWT, string, error) {
ok, err := s.ClientIdentityRepo.Authenticate(creds) ok, err := s.ClientRepo.Authenticate(creds)
if err != nil { if err != nil {
log.Errorf("Failed fetching client %s from repo: %v", creds.ID, err) log.Errorf("Failed fetching client %s from repo: %v", creds.ID, err)
return nil, "", oauth2.NewError(oauth2.ErrorServerError) return nil, "", oauth2.NewError(oauth2.ErrorServerError)
@ -466,7 +466,7 @@ func (s *Server) CodeToken(creds oidc.ClientCredentials, sessionKey string) (*jo
} }
func (s *Server) RefreshToken(creds oidc.ClientCredentials, token string) (*jose.JWT, error) { func (s *Server) RefreshToken(creds oidc.ClientCredentials, token string) (*jose.JWT, error) {
ok, err := s.ClientIdentityRepo.Authenticate(creds) ok, err := s.ClientRepo.Authenticate(creds)
if err != nil { if err != nil {
log.Errorf("Failed fetching client %s from repo: %v", creds.ID, err) log.Errorf("Failed fetching client %s from repo: %v", creds.ID, err)
return nil, oauth2.NewError(oauth2.ErrorServerError) return nil, oauth2.NewError(oauth2.ErrorServerError)

42
server/server_test.go
View file

@ -194,8 +194,8 @@ func TestServerLogin(t *testing.T) {
}, },
}, },
} }
ciRepo := func() client.ClientIdentityRepo { ciRepo := func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ci}) repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{ci})
if err != nil { if err != nil {
t.Fatalf("Failed to create client identity repo: %v", err) t.Fatalf("Failed to create client identity repo: %v", err)
} }
@ -222,7 +222,7 @@ func TestServerLogin(t *testing.T) {
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
UserRepo: userRepo, UserRepo: userRepo,
} }
@ -244,8 +244,8 @@ func TestServerLogin(t *testing.T) {
} }
func TestServerLoginUnrecognizedSessionKey(t *testing.T) { func TestServerLoginUnrecognizedSessionKey(t *testing.T) {
ciRepo := func() client.ClientIdentityRepo { ciRepo := func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{ client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: "XXX", Secret: clientTestSecret, ID: "XXX", Secret: clientTestSecret,
@ -266,7 +266,7 @@ func TestServerLoginUnrecognizedSessionKey(t *testing.T) {
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
} }
ident := oidc.Identity{ID: "YYY", Name: "elroy", Email: "elroy@example.com"} ident := oidc.Identity{ID: "YYY", Name: "elroy", Email: "elroy@example.com"}
@ -296,8 +296,8 @@ func TestServerLoginDisabledUser(t *testing.T) {
}, },
}, },
} }
ciRepo := func() client.ClientIdentityRepo { ciRepo := func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ci}) repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{ci})
if err != nil { if err != nil {
t.Fatalf("Failed to create client identity repo: %v", err) t.Fatalf("Failed to create client identity repo: %v", err)
} }
@ -338,7 +338,7 @@ func TestServerLoginDisabledUser(t *testing.T) {
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
UserRepo: userRepo, UserRepo: userRepo,
} }
@ -361,8 +361,8 @@ func TestServerCodeToken(t *testing.T) {
Secret: clientTestSecret, Secret: clientTestSecret,
}, },
} }
ciRepo := func() client.ClientIdentityRepo { ciRepo := func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ci}) repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{ci})
if err != nil { if err != nil {
t.Fatalf("Failed to create client identity repo: %v", err) t.Fatalf("Failed to create client identity repo: %v", err)
} }
@ -384,7 +384,7 @@ func TestServerCodeToken(t *testing.T) {
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
UserRepo: userRepo, UserRepo: userRepo,
RefreshTokenRepo: refreshTokenRepo, RefreshTokenRepo: refreshTokenRepo,
} }
@ -447,8 +447,8 @@ func TestServerTokenUnrecognizedKey(t *testing.T) {
Secret: clientTestSecret, Secret: clientTestSecret,
}, },
} }
ciRepo := func() client.ClientIdentityRepo { ciRepo := func() client.ClientRepo {
repo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ci}) repo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{ci})
if err != nil { if err != nil {
t.Fatalf("Failed to create client identity repo: %v", err) t.Fatalf("Failed to create client identity repo: %v", err)
} }
@ -463,7 +463,7 @@ func TestServerTokenUnrecognizedKey(t *testing.T) {
IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"}, IssuerURL: url.URL{Scheme: "http", Host: "server.example.com"},
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
} }
sessionID, err := sm.NewSession("connector_id", ci.Credentials.ID, "bogus", url.URL{}, "", false, []string{"openid", "offline_access"}) sessionID, err := sm.NewSession("connector_id", ci.Credentials.ID, "bogus", url.URL{}, "", false, []string{"openid", "offline_access"})
@ -569,7 +569,7 @@ func TestServerTokenFail(t *testing.T) {
km := &StaticKeyManager{ km := &StaticKeyManager{
signer: tt.signer, signer: tt.signer,
} }
ciRepo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ ciRepo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{Credentials: ccFixture}, client.Client{Credentials: ccFixture},
}) })
if err != nil { if err != nil {
@ -593,7 +593,7 @@ func TestServerTokenFail(t *testing.T) {
IssuerURL: issuerURL, IssuerURL: issuerURL,
KeyManager: km, KeyManager: km,
SessionManager: sm, SessionManager: sm,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
UserRepo: userRepo, UserRepo: userRepo,
RefreshTokenRepo: refreshTokenRepo, RefreshTokenRepo: refreshTokenRepo,
} }
@ -731,7 +731,7 @@ func TestServerRefreshToken(t *testing.T) {
signer: tt.signer, signer: tt.signer,
} }
ciRepo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ ciRepo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{Credentials: credXXX}, client.Client{Credentials: credXXX},
client.Client{Credentials: credYYY}, client.Client{Credentials: credYYY},
}) })
@ -750,7 +750,7 @@ func TestServerRefreshToken(t *testing.T) {
srv := &Server{ srv := &Server{
IssuerURL: issuerURL, IssuerURL: issuerURL,
KeyManager: km, KeyManager: km,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
UserRepo: userRepo, UserRepo: userRepo,
RefreshTokenRepo: refreshTokenRepo, RefreshTokenRepo: refreshTokenRepo,
} }
@ -784,7 +784,7 @@ func TestServerRefreshToken(t *testing.T) {
signer: signerFixture, signer: signerFixture,
} }
ciRepo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ ciRepo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{Credentials: credXXX}, client.Client{Credentials: credXXX},
client.Client{Credentials: credYYY}, client.Client{Credentials: credYYY},
}) })
@ -810,7 +810,7 @@ func TestServerRefreshToken(t *testing.T) {
srv := &Server{ srv := &Server{
IssuerURL: issuerURL, IssuerURL: issuerURL,
KeyManager: km, KeyManager: km,
ClientIdentityRepo: ciRepo, ClientRepo: ciRepo,
UserRepo: userRepo, UserRepo: userRepo,
RefreshTokenRepo: refreshTokenRepo, RefreshTokenRepo: refreshTokenRepo,
} }

8
server/testutil.go
View file

@ -78,7 +78,7 @@ type testFixtures struct {
sessionManager *sessionmanager.SessionManager sessionManager *sessionmanager.SessionManager
emailer *email.TemplatizedEmailer emailer *email.TemplatizedEmailer
redirectURL url.URL redirectURL url.URL
clientIdentityRepo client.ClientIdentityRepo clientRepo client.ClientRepo
} }
func sequentialGenerateCodeFunc() sessionmanager.GenerateCodeFunc { func sequentialGenerateCodeFunc() sessionmanager.GenerateCodeFunc {
@ -136,7 +136,7 @@ func makeTestFixtures() (*testFixtures, error) {
return nil, err return nil, err
} }
clientIdentityRepo, err := db.NewClientIdentityRepoFromClients(db.NewMemDB(), []client.Client{ clientRepo, err := db.NewClientRepoFromClients(db.NewMemDB(), []client.Client{
client.Client{ client.Client{
Credentials: oidc.ClientCredentials{ Credentials: oidc.ClientCredentials{
ID: "XXX", ID: "XXX",
@ -169,7 +169,7 @@ func makeTestFixtures() (*testFixtures, error) {
srv := &Server{ srv := &Server{
IssuerURL: testIssuerURL, IssuerURL: testIssuerURL,
SessionManager: sessionManager, SessionManager: sessionManager,
ClientIdentityRepo: clientIdentityRepo, ClientRepo: clientRepo,
Templates: tpl, Templates: tpl,
UserRepo: userRepo, UserRepo: userRepo,
PasswordInfoRepo: pwRepo, PasswordInfoRepo: pwRepo,
@ -206,6 +206,6 @@ func makeTestFixtures() (*testFixtures, error) {
userRepo: userRepo, userRepo: userRepo,
sessionManager: sessionManager, sessionManager: sessionManager,
emailer: emailer, emailer: emailer,
clientIdentityRepo: clientIdentityRepo, clientRepo: clientRepo,
}, nil }, nil
} }

4
server/user.go
View file

@ -39,10 +39,10 @@ type UserMgmtServer struct {
api *api.UsersAPI api *api.UsersAPI
jwtvFactory JWTVerifierFactory jwtvFactory JWTVerifierFactory
um *manager.UserManager um *manager.UserManager
cir client.ClientIdentityRepo cir client.ClientRepo
} }
func NewUserMgmtServer(userMgmtAPI *api.UsersAPI, jwtvFactory JWTVerifierFactory, um *manager.UserManager, cir client.ClientIdentityRepo) *UserMgmtServer { func NewUserMgmtServer(userMgmtAPI *api.UsersAPI, jwtvFactory JWTVerifierFactory, um *manager.UserManager, cir client.ClientRepo) *UserMgmtServer {
return &UserMgmtServer{ return &UserMgmtServer{
api: userMgmtAPI, api: userMgmtAPI,
jwtvFactory: jwtvFactory, jwtvFactory: jwtvFactory,

8
user/api/api.go
View file

@ -90,7 +90,7 @@ func (e Error) Error() string {
type UsersAPI struct { type UsersAPI struct {
manager *manager.UserManager manager *manager.UserManager
localConnectorID string localConnectorID string
clientIdentityRepo client.ClientIdentityRepo clientRepo client.ClientRepo
refreshRepo refresh.RefreshTokenRepo refreshRepo refresh.RefreshTokenRepo
emailer Emailer emailer Emailer
} }
@ -109,7 +109,7 @@ func NewUsersAPI(dbMap *gorp.DbMap, userManager *manager.UserManager, emailer Em
return &UsersAPI{ return &UsersAPI{
manager: userManager, manager: userManager,
refreshRepo: db.NewRefreshTokenRepo(dbMap), refreshRepo: db.NewRefreshTokenRepo(dbMap),
clientIdentityRepo: db.NewClientIdentityRepo(dbMap), clientRepo: db.NewClientRepo(dbMap),
localConnectorID: localConnectorID, localConnectorID: localConnectorID,
emailer: emailer, emailer: emailer,
} }
@ -157,7 +157,7 @@ func (u *UsersAPI) CreateUser(creds Creds, usr schema.User, redirURL url.URL) (s
return schema.UserCreateResponse{}, mapError(err) return schema.UserCreateResponse{}, mapError(err)
} }
metadata, err := u.clientIdentityRepo.Metadata(creds.ClientID) metadata, err := u.clientRepo.Metadata(creds.ClientID)
if err != nil { if err != nil {
return schema.UserCreateResponse{}, mapError(err) return schema.UserCreateResponse{}, mapError(err)
} }
@ -202,7 +202,7 @@ func (u *UsersAPI) ResendEmailInvitation(creds Creds, userID string, redirURL ur
return schema.ResendEmailInvitationResponse{}, ErrorUnauthorized return schema.ResendEmailInvitationResponse{}, ErrorUnauthorized
} }
metadata, err := u.clientIdentityRepo.Metadata(creds.ClientID) metadata, err := u.clientRepo.Metadata(creds.ClientID)
if err != nil { if err != nil {
return schema.ResendEmailInvitationResponse{}, mapError(err) return schema.ResendEmailInvitationResponse{}, mapError(err)
} }

3
user/api/api_test.go
View file

@ -167,8 +167,7 @@ func makeTestFixtures() (*UsersAPI, *testEmailer) {
}, },
}, },
} }
if _, err := db.NewClientRepoFromClients(dbMap, []client.Client{ci}); err != nil {
if _, err := db.NewClientIdentityRepoFromClients(dbMap, []client.Client{ci}); err != nil {
panic("Failed to create client repo: " + err.Error()) panic("Failed to create client repo: " + err.Error())
} }