agent/consul/state,fsm: support for deleting intentions

agent/consul/fsm/commands_oss.go

@@ -263,8 +263,7 @@ func (c *FSM) applyIntentionOperation(buf []byte, index uint64) interface{} {
 	case structs.IntentionOpCreate, structs.IntentionOpUpdate:
 		return c.state.IntentionSet(index, req.Intention)
 	case structs.IntentionOpDelete:
-		panic("TODO")
+		return c.state.IntentionDelete(index, req.Intention.ID)
-		//return c.state.PreparedQueryDelete(index, req.Query.ID)
 	default:
 		c.logger.Printf("[WARN] consul.fsm: Invalid Intention operation '%s'", req.Op)
 		return fmt.Errorf("Invalid Intention operation '%s'", req.Op)

agent/consul/state/intention.go

@@ -156,3 +156,39 @@ func (s *Store) IntentionGet(ws memdb.WatchSet, id string) (uint64, *structs.Int
 
 	return idx, result, nil
 }
+
+// IntentionDelete deletes the given intention by ID.
+func (s *Store) IntentionDelete(idx uint64, id string) error {
+	tx := s.db.Txn(true)
+	defer tx.Abort()
+
+	if err := s.intentionDeleteTxn(tx, idx, id); err != nil {
+		return fmt.Errorf("failed intention delete: %s", err)
+	}
+
+	tx.Commit()
+	return nil
+}
+
+// intentionDeleteTxn is the inner method used to delete a intention
+// with the proper indexes into the state store.
+func (s *Store) intentionDeleteTxn(tx *memdb.Txn, idx uint64, queryID string) error {
+	// Pull the query.
+	wrapped, err := tx.First(intentionsTableName, "id", queryID)
+	if err != nil {
+		return fmt.Errorf("failed intention lookup: %s", err)
+	}
+	if wrapped == nil {
+		return nil
+	}
+
+	// Delete the query and update the index.
+	if err := tx.Delete(intentionsTableName, wrapped); err != nil {
+		return fmt.Errorf("failed intention delete: %s", err)
+	}
+	if err := tx.Insert("index", &IndexEntry{intentionsTableName, idx}); err != nil {
+		return fmt.Errorf("failed updating index: %s", err)
+	}
+
+	return nil
+}

agent/consul/state/intention_test.go

@@ -121,6 +121,56 @@ func TestStore_IntentionSet_emptyId(t *testing.T) {
 	}
 }
 
+func TestStore_IntentionDelete(t *testing.T) {
+	s := testStateStore(t)
+
+	// Call Get to populate the watch set
+	ws := memdb.NewWatchSet()
+	_, _, err := s.IntentionGet(ws, testUUID())
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Create
+	ixn := &structs.Intention{ID: testUUID()}
+	if err := s.IntentionSet(1, ixn); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Make sure the index got updated.
+	if idx := s.maxIndex(intentionsTableName); idx != 1 {
+		t.Fatalf("bad index: %d", idx)
+	}
+	if !watchFired(ws) {
+		t.Fatalf("bad")
+	}
+
+	// Delete
+	if err := s.IntentionDelete(2, ixn.ID); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Make sure the index got updated.
+	if idx := s.maxIndex(intentionsTableName); idx != 2 {
+		t.Fatalf("bad index: %d", idx)
+	}
+	if !watchFired(ws) {
+		t.Fatalf("bad")
+	}
+
+	// Sanity check to make sure it's not there.
+	idx, actual, err := s.IntentionGet(nil, ixn.ID)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	if idx != 2 {
+		t.Fatalf("bad index: %d", idx)
+	}
+	if actual != nil {
+		t.Fatalf("bad: %v", actual)
+	}
+}
+
 func TestStore_IntentionsList(t *testing.T) {
 	s := testStateStore(t)