storage

type AllStorage interface {
	ServiceStore
	PushStore
	PushCertStore
	CommandEnqueuer
	CertAuthStore
	CertAuthRetriever
	StoreMigrator
	TokenUpdateTallyStore
	PushCertStorer
}

type BootstrapTokenStore interface {
	StoreBootstrapToken(r *mdm.Request, msg *mdm.SetBootstrapToken) error

	// RetrieveBootstrapToken retrieves the previously-escrowed Bootstrap Token.
	// If a token has not yet been escrowed then a nil token and no error should be returned.
	RetrieveBootstrapToken(r *mdm.Request, msg *mdm.GetBootstrapToken) (*mdm.BootstrapToken, error)
}

type CertAuthRetriever interface {
	// EnrollmentFromHash retrieves a normalized enrollment ID from a cert hash.
	// The hash parameter, when present, is likely (but not required) to be
	// a 64-charachter hex string representation of a SHA-256 digest.
	// Implementations should return an empty string if no result is found.
	EnrollmentFromHash(ctx context.Context, hash string) (string, error)
}

type CertAuthStore interface {
	// HasCertHash checks if hash has ever been associated to any enrollment.
	HasCertHash(r *mdm.Request, hash string) (has bool, err error)

	// EnrollmentHasCertHash checks that r.ID has any hash associated.
	// The hash parameter can usually be ignored.
	EnrollmentHasCertHash(r *mdm.Request, hash string) (bool, error)

	// IsCertHashAssociated checks that r.ID is associated to hash.
	IsCertHashAssociated(r *mdm.Request, hash string) (bool, error)

	// AssociateCertHash associates r.ID with hash.
	// Here hash is a cryptographic hash of the request certificate.
	AssociateCertHash(r *mdm.Request, hash string) error
}

type CheckinStore interface {
	// StoreAuthenticate stores the Authenticate check-in message from an enrollment.
	StoreAuthenticate(r *mdm.Request, msg *mdm.Authenticate) error

	// StoreTokenUpdate stores the TokenUpdate check-in message.
	// Storing this first TokenUpdate message represents a successful enrollment.
	// Note both device and user channel enrollments receive TokenUpdate messages.
	StoreTokenUpdate(r *mdm.Request, msg *mdm.TokenUpdate) error

	// Disable the MDM enrollment.
	// If r is from a device channel then any user channels for this device
	// also need to be disabled.
	Disable(r *mdm.Request) error

	UserAuthenticateStore
}

type CommandAndReportResultsStore interface {
	StoreCommandReport(r *mdm.Request, report *mdm.CommandResults) error
	RetrieveNextCommand(r *mdm.Request, skipNotNow bool) (*mdm.Command, error)
	ClearQueue(r *mdm.Request) error
}

type CommandEnqueuer interface {
	EnqueueCommand(ctx context.Context, id []string, cmd *mdm.Command) (map[string]error, error)
}

type PushCertStore interface {
	// IsPushCertStale asks whether staleToken is stale or not.
	// The staleToken is returned from RetrievePushCert
	// and should turn stale (and return true) if the certificate has
	// changed—such as being renewed.
	IsPushCertStale(ctx context.Context, topic string, staleToken string) (bool, error)
	RetrievePushCert(ctx context.Context, topic string) (cert *tls.Certificate, staleToken string, err error)
}

type PushCertStorer interface {
	// StorePushCert stores the PEM certificate and private key.
	// The APNs topic (UserID OID), which implementations will likely
	// need to use as a key, is decoded from the from the PEM certificate.
	StorePushCert(ctx context.Context, pemCert, pemKey []byte) error
}

type PushStore interface {
	// RetrievePushInfo retrieves push data for the given ids.
	//
	// If an ID does not exist or is not enrolled properly then
	// implementations should silently skip returning any push data for
	// them. It is up to the caller to discern any missing IDs from the
	// returned map.
	RetrievePushInfo(ctx context.Context, ids []string) (map[string]*mdm.Push, error)
}

type ServiceStore interface {
	CheckinStore
	CommandAndReportResultsStore
	BootstrapTokenStore
}

type StoreMigrator interface {
	// RetrieveMigrationCheckins sends the (decoded) forms of
	// Authenticate and TokenUpdate messages to the provided channel.
	// Note that order matters: device channel TokenUpdate messages must
	// follow Authenticate messages and user channel TokenUpdates must
	// follow the device channel TokenUpdate.
	RetrieveMigrationCheckins(context.Context, chan<- interface{}) error
}

type TokenUpdateTallyStore interface {
	// RetrieveTokenUpdateTally retrieves the TokenUpdate tally (count) for id.
	// If no tally exists or is not yet set, 0 with a nil error should be returned.
	RetrieveTokenUpdateTally(ctx context.Context, id string) (int, error)
}

type UserAuthenticateStore interface {
	// StoreUserAuthenticate stores the UserAuthenticate check-in message from an enrollment.
	StoreUserAuthenticate(r *mdm.Request, msg *mdm.UserAuthenticate) error
}