package storage import ( "errors" "strings" "github.com/sirupsen/logrus" ) // Tests for this code are in the "memory" package, since this package doesn't // define a concrete storage implementation. // staticClientsStorage is a storage that only allow read-only actions on clients. // All read actions return from the list of clients stored in memory, not the // underlying type staticClientsStorage struct { Storage // A read-only set of clients. clients []Client clientsByID map[string]Client } // WithStaticClients adds a read-only set of clients to the underlying storages. func WithStaticClients(s Storage, staticClients []Client) Storage { clientsByID := make(map[string]Client, len(staticClients)) for _, client := range staticClients { clientsByID[client.ID] = client } return staticClientsStorage{s, staticClients, clientsByID} } func (s staticClientsStorage) GetClient(id string) (Client, error) { if client, ok := s.clientsByID[id]; ok { return client, nil } return s.Storage.GetClient(id) } func (s staticClientsStorage) isStatic(id string) bool { _, ok := s.clientsByID[id] return ok } func (s staticClientsStorage) ListClients() ([]Client, error) { clients, err := s.Storage.ListClients() if err != nil { return nil, err } n := 0 for _, client := range clients { // If a client in the backing storage has the same ID as a static client // prefer the static client. if !s.isStatic(client.ID) { clients[n] = client n++ } } return append(clients[:n], s.clients...), nil } func (s staticClientsStorage) CreateClient(c Client) error { if s.isStatic(c.ID) { return errors.New("static clients: read-only cannot create client") } return s.Storage.CreateClient(c) } func (s staticClientsStorage) DeleteClient(id string) error { if s.isStatic(id) { return errors.New("static clients: read-only cannot delete client") } return s.Storage.DeleteClient(id) } func (s staticClientsStorage) UpdateClient(id string, updater func(old Client) (Client, error)) error { if s.isStatic(id) { return errors.New("static clients: read-only cannot update client") } return s.Storage.UpdateClient(id, updater) } type staticPasswordsStorage struct { Storage // A read-only set of passwords. passwords []Password // A map of passwords that is indexed by lower-case email ids passwordsByEmail map[string]Password logger logrus.FieldLogger } // WithStaticPasswords returns a storage with a read-only set of passwords. func WithStaticPasswords(s Storage, staticPasswords []Password, logger logrus.FieldLogger) Storage { passwordsByEmail := make(map[string]Password, len(staticPasswords)) for _, p := range staticPasswords { //Enable case insensitive email comparison. lowerEmail := strings.ToLower(p.Email) if _, ok := passwordsByEmail[lowerEmail]; ok { logger.Errorf("Attempting to create StaticPasswords with the same email id: %s", p.Email) } passwordsByEmail[lowerEmail] = p } return staticPasswordsStorage{s, staticPasswords, passwordsByEmail, logger} } func (s staticPasswordsStorage) isStatic(email string) bool { _, ok := s.passwordsByEmail[strings.ToLower(email)] return ok } func (s staticPasswordsStorage) GetPassword(email string) (Password, error) { // TODO(ericchiang): BLAH. We really need to figure out how to handle // lower cased emails better. email = strings.ToLower(email) if password, ok := s.passwordsByEmail[email]; ok { return password, nil } return s.Storage.GetPassword(email) } func (s staticPasswordsStorage) ListPasswords() ([]Password, error) { passwords, err := s.Storage.ListPasswords() if err != nil { return nil, err } n := 0 for _, password := range passwords { // If an entry has the same email as those provided in the static // values, prefer the static value. if !s.isStatic(password.Email) { passwords[n] = password n++ } } return append(passwords[:n], s.passwords...), nil } func (s staticPasswordsStorage) CreatePassword(p Password) error { if s.isStatic(p.Email) { return errors.New("static passwords: read-only cannot create password") } return s.Storage.CreatePassword(p) } func (s staticPasswordsStorage) DeletePassword(email string) error { if s.isStatic(email) { return errors.New("static passwords: read-only cannot delete password") } return s.Storage.DeletePassword(email) } func (s staticPasswordsStorage) UpdatePassword(email string, updater func(old Password) (Password, error)) error { if s.isStatic(email) { return errors.New("static passwords: read-only cannot update password") } return s.Storage.UpdatePassword(email, updater) } // staticConnectorsStorage represents a storage with read-only set of connectors. type staticConnectorsStorage struct { Storage // A read-only set of connectors. connectors []Connector connectorsByID map[string]Connector } // WithStaticConnectors returns a storage with a read-only set of Connectors. Write actions, // such as updating existing Connectors, will fail. func WithStaticConnectors(s Storage, staticConnectors []Connector) Storage { connectorsByID := make(map[string]Connector, len(staticConnectors)) for _, c := range staticConnectors { connectorsByID[c.ID] = c } return staticConnectorsStorage{s, staticConnectors, connectorsByID} } func (s staticConnectorsStorage) isStatic(id string) bool { _, ok := s.connectorsByID[id] return ok } func (s staticConnectorsStorage) GetConnector(id string) (Connector, error) { if connector, ok := s.connectorsByID[id]; ok { return connector, nil } return s.Storage.GetConnector(id) } func (s staticConnectorsStorage) ListConnectors() ([]Connector, error) { connectors, err := s.Storage.ListConnectors() if err != nil { return nil, err } n := 0 for _, connector := range connectors { // If an entry has the same id as those provided in the static // values, prefer the static value. if !s.isStatic(connector.ID) { connectors[n] = connector n++ } } return append(connectors[:n], s.connectors...), nil } func (s staticConnectorsStorage) CreateConnector(c Connector) error { if s.isStatic(c.ID) { return errors.New("static connectors: read-only cannot create connector") } return s.Storage.CreateConnector(c) } func (s staticConnectorsStorage) DeleteConnector(id string) error { if s.isStatic(id) { return errors.New("static connectors: read-only cannot delete connector") } return s.Storage.DeleteConnector(id) } func (s staticConnectorsStorage) UpdateConnector(id string, updater func(old Connector) (Connector, error)) error { if s.isStatic(id) { return errors.New("static connectors: read-only cannot update connector") } return s.Storage.UpdateConnector(id, updater) }