PROTO

Author: 256dpi

heat/model.go

@@ -0,0 +1,27 @@
+package heat
+
+import (
+	"time"
+
+	"github.com/256dpi/fire/coal"
+	"github.com/256dpi/fire/stick"
+)
+
+type Model struct {
+	coal.Base `json:"-" bson:",inline" coal:"keys"`
+	Issued    time.Time `json:"issued"`
+	Expires   time.Time `json:"expires"`
+	Data      stick.Map `json:"data"`
+	Parents   []coal.ID `json:"-" coal:"parents:keys"` // TODO: Store in key.
+}
+
+func (m *Model) Validate() error {
+	return stick.Validate(m, func(v *stick.Validator) {
+		v.Value("Issued", false, stick.IsNotZero)
+		v.Value("Expires", false, stick.IsNotZero)
+	})
+}
+
+func AddModelIndexes(catalog *coal.Catalog) {
+	catalog.AddIndex(&Model{}, false, 1, "Expires")
+}

heat/notary.go

@@ -10,10 +10,17 @@ import (
 	"github.com/256dpi/fire/stick"
 )
 
+// TODO: Allow secret data to be provided with a stored key.
+//  => Would allow us to use this system for handling invitations.
+//  => Unique IDs/Labels?
+
+var ErrMissingKey = xo.BF("missing key")
+
 // Notary is used to issue and verify tokens from keys.
 type Notary struct {
 	issuer string
 	secret []byte
+	store  *coal.Store
 }
 
 // NewNotary creates a new notary with the specified name and secret. It will
@@ -30,15 +37,17 @@ func NewNotary(name string, secret []byte) *Notary {
 	}
 
 	return &Notary{
-		secret: secret,
 		issuer: name,
+		secret: secret,
 	}
 }
 
-// Issue will generate a token from the specified key.
-func (n *Notary) Issue(ctx context.Context, key Key) (string, error) {
+// Issue will generate a token from the specified key. If store is true, the
+// key is also saved in the specified store and flagged respectively.
+func (n *Notary) Issue(ctx context.Context, key Key, store bool) (string, error) {
 	// trace
-	_, span := xo.Trace(ctx, "heat/Notary.Issue")
+	ctx, span := xo.Trace(ctx, "heat/Notary.Issue")
+	span.Tag("store", store)
 	defer span.End()
 
 	// get meta
@@ -75,6 +84,8 @@ func (n *Notary) Issue(ctx context.Context, key Key) (string, error) {
 		return "", err
 	}
 
+	// TODO: Set stored flag in claims?
+
 	// issue token
 	token, err := Issue(n.secret, n.issuer, meta.Name, RawKey{
 		ID:      base.ID.Hex(),
@@ -86,13 +97,38 @@ func (n *Notary) Issue(ctx context.Context, key Key) (string, error) {
 		return "", err
 	}
 
+	// return token if not stored
+	if !store {
+		return token, nil
+	}
+
+	// TODO: Set parent.
+
+	// otherwise, prepare model
+	model := Model{
+		Base:    coal.B(base.ID),
+		Issued:  base.Issued,
+		Expires: base.Expires,
+		Data:    data,
+	}
+
+	// insert key
+	err = n.store.M(&model).Insert(ctx, &model)
+	if err != nil {
+		return "", err
+	}
+
 	return token, nil
 }
 
-// Verify will verify the specified token and fill the specified key.
-func (n *Notary) Verify(ctx context.Context, key Key, token string) error {
+// TODO: IssueAndStore()?
+
+// Verify will verify the specified token and fill the specified key. If retrieve
+// is true, the key is retrieve from the store and verified to exist and not
+// be revoked.
+func (n *Notary) Verify(ctx context.Context, key Key, token string, retrieve bool) error {
 	// trace
-	_, span := xo.Trace(ctx, "heat/Notary.Verify")
+	ctx, span := xo.Trace(ctx, "heat/Notary.Verify")
 	defer span.End()
 
 	// get meta
@@ -129,5 +165,42 @@ func (n *Notary) Verify(ctx context.Context, key Key, token string) error {
 		return err
 	}
 
+	// return if not retrieve
+	if !retrieve {
+		return nil
+	}
+
+	// otherwise, retrieve key
+	var model Model
+	found, err := n.store.M(&model).Find(ctx, &model, key.GetBase().ID, false)
+	if err != nil {
+		return err
+	} else if !found {
+		return ErrMissingKey.Wrap()
+	}
+
+	// TODO: Further validate?
+
+	return nil
+}
+
+// TODO: VerifyAndRetrieve()?
+
+// Revoke will revoke the specified key by deleting it.
+func (n *Notary) Revoke(ctx context.Context, key Key) error {
+	// trace
+	ctx, span := xo.Trace(ctx, "heat/Notary.Delete")
+	defer span.End()
+
+	// TODO: Also revoke descendants?
+
+	// delete key
+	found, err := n.store.M(&Model{}).Delete(ctx, nil, key.GetBase().ID)
+	if err != nil {
+		return err
+	} else if !found {
+		return ErrMissingKey.Wrap()
+	}
+
 	return nil
 }