dawgs Version 2

Makefile

@@ -7,6 +7,7 @@ MAIN_PACKAGES=$$($(GO_CMD) list ./...)
 
 default: format test
 all: generate format test
+update: mod_update mod_tidy
 
 generate:
 	@$(GO_CMD) generate ./...
@@ -17,4 +18,10 @@ format:
 test:
 	@for pkg in $(MAIN_PACKAGES) ; do \
 		$(GO_CMD) test -cover $$pkg -parallel=20 ; \
-	done
+	done
+
+mod_update:
+	@$(GO_CMD) get -u ./...
+
+mod_tidy:
+	@$(GO_CMD) mod tidy

algo/reach.go

@@ -8,8 +8,9 @@ import (
 	"github.com/gammazero/deque"
 	"github.com/specterops/dawgs/cardinality"
 	"github.com/specterops/dawgs/container"
+	"github.com/specterops/dawgs/database/v1compat"
+	"github.com/specterops/dawgs/database/v1compat/query"
 	"github.com/specterops/dawgs/graph"
-	"github.com/specterops/dawgs/query"
 )
 
 type reachCursor struct {
@@ -262,11 +263,11 @@ func (s *ReachabilityCache) XorReach(node uint64, direction graph.Direction, dup
 	duplex.Xor(reachBitmap)
 }
 
-func edgesFilteredByKinds(kinds ...graph.Kind) graph.Criteria {
+func edgesFilteredByKinds(kinds ...graph.Kind) v1compat.Criteria {
 	return query.KindIn(query.Relationship(), kinds...)
 }
 
-func FetchReachabilityCache(ctx context.Context, db graph.Database, criteria graph.Criteria) (*ReachabilityCache, error) {
+func FetchReachabilityCache(ctx context.Context, db v1compat.Database, criteria v1compat.Criteria) (*ReachabilityCache, error) {
 	if digraph, err := container.FetchDirectedGraph(ctx, db, criteria); err != nil {
 		return nil, err
 	} else {
@@ -275,6 +276,6 @@ func FetchReachabilityCache(ctx context.Context, db graph.Database, criteria gra
 	}
 }
 
-func FetchFilteredReachabilityCache(ctx context.Context, db graph.Database, traversalKinds ...graph.Kind) (*ReachabilityCache, error) {
+func FetchFilteredReachabilityCache(ctx context.Context, db v1compat.Database, traversalKinds ...graph.Kind) (*ReachabilityCache, error) {
 	return FetchReachabilityCache(ctx, db, edgesFilteredByKinds(traversalKinds...))
 }

algo/scc.go

@@ -120,7 +120,7 @@ func StronglyConnectedComponents(ctx context.Context, digraph container.Directed
 			}
 		}
 
-		return true
+		return util.IsContextLive(ctx)
 	})
 
 	return components, nodeToComp

cardinality/lock.go

@@ -6,13 +6,13 @@ import (
 
 type threadSafeDuplex[T uint32 | uint64] struct {
 	provider Duplex[T]
-	lock     *sync.Mutex
+	lock     *sync.RWMutex
 }
 
 func ThreadSafeDuplex[T uint32 | uint64](provider Duplex[T]) Duplex[T] {
 	return threadSafeDuplex[T]{
 		provider: provider,
-		lock:     &sync.Mutex{},
+		lock:     &sync.RWMutex{},
 	}
 }
 
@@ -66,56 +66,60 @@ func (s threadSafeDuplex[T]) Or(other Provider[T]) {
 }
 
 func (s threadSafeDuplex[T]) Cardinality() uint64 {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	return s.provider.Cardinality()
 }
 
 func (s threadSafeDuplex[T]) Slice() []T {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	return s.provider.Slice()
 }
 
 func (s threadSafeDuplex[T]) Contains(value T) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	return s.provider.Contains(value)
 }
 
 func (s threadSafeDuplex[T]) Each(delegate func(value T) bool) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	s.provider.Each(delegate)
 }
 
 func (s threadSafeDuplex[T]) CheckedAdd(value T) bool {
+	if s.Contains(value) {
+		return false
+	}
+
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	return s.provider.CheckedAdd(value)
 }
 
 func (s threadSafeDuplex[T]) Clone() Duplex[T] {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	return ThreadSafeDuplex(s.provider.Clone())
 }
 
 type threadSafeSimplex[T uint32 | uint64] struct {
 	provider Simplex[T]
-	lock     *sync.Mutex
+	lock     *sync.RWMutex
 }
 
 func ThreadSafeSimplex[T uint32 | uint64](provider Simplex[T]) Simplex[T] {
 	return threadSafeSimplex[T]{
 		provider: provider,
-		lock:     &sync.Mutex{},
+		lock:     &sync.RWMutex{},
 	}
 }
 
@@ -141,15 +145,15 @@ func (s threadSafeSimplex[T]) Or(other Provider[T]) {
 }
 
 func (s threadSafeSimplex[T]) Cardinality() uint64 {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	return s.provider.Cardinality()
 }
 
 func (s threadSafeSimplex[T]) Clone() Simplex[T] {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+	s.lock.RLock()
+	defer s.lock.RUnlock()
 
 	return ThreadSafeSimplex(s.provider.Clone())
 }

cmd/viz/graph.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+	"io"
+	"os"
+	"strconv"
+
+	"github.com/go-echarts/go-echarts/v2/charts"
+	"github.com/go-echarts/go-echarts/v2/components"
+	"github.com/go-echarts/go-echarts/v2/opts"
+	"github.com/specterops/dawgs/container"
+	"github.com/specterops/dawgs/graph"
+)
+
+var graphNodes = []opts.GraphNode{
+	{Name: "Node1"},
+	{Name: "Node2"},
+	{Name: "Node3"},
+	{Name: "Node4"},
+	{Name: "Node5"},
+	{Name: "Node6"},
+	{Name: "Node7"},
+	{Name: "Node8"},
+}
+
+func genLinks() []opts.GraphLink {
+	links := make([]opts.GraphLink, 0)
+	for i := 0; i < len(graphNodes); i++ {
+		for j := 0; j < len(graphNodes); j++ {
+			links = append(links, opts.GraphLink{Source: graphNodes[i].Name, Target: graphNodes[j].Name})
+		}
+	}
+	return links
+}
+
+func graphBase() *charts.Graph {
+	graph := charts.NewGraph()
+	graph.SetGlobalOptions(
+		charts.WithTitleOpts(opts.Title{Title: "basic graph example"}),
+	)
+	graph.AddSeries("graph", graphNodes, genLinks(),
+		charts.WithGraphChartOpts(
+			opts.GraphChart{Force: &opts.GraphForce{Repulsion: 8000}},
+		),
+	)
+	return graph
+}
+
+func graphCircle() *charts.Graph {
+	graph := charts.NewGraph()
+	graph.SetGlobalOptions(
+		charts.WithTitleOpts(opts.Title{Title: "Circular layout"}),
+	)
+
+	graph.AddSeries("graph", graphNodes, genLinks()).
+		SetSeriesOptions(
+			charts.WithGraphChartOpts(
+				opts.GraphChart{
+					Force:  &opts.GraphForce{Repulsion: 8000},
+					Layout: "circular",
+				}),
+			charts.WithLabelOpts(opts.Label{Show: opts.Bool(true), Position: "right"}),
+		)
+	return graph
+}
+
+func graphDigraph(digraph container.DirectedGraph, direction graph.Direction) *charts.Graph {
+	graph := charts.NewGraph()
+	graph.SetGlobalOptions(
+		charts.WithTitleOpts(opts.Title{
+			Title: "demo",
+		}))
+
+	var (
+		nodes []opts.GraphNode
+		links []opts.GraphLink
+	)
+
+	digraph.EachNode(func(node uint64) bool {
+		sourceNode := strconv.FormatUint(node, 10)
+
+		nodes = append(nodes, opts.GraphNode{
+			Name: sourceNode,
+		})
+
+		digraph.EachAdjacentNode(node, direction, func(adjacent uint64) bool {
+			links = append(links, opts.GraphLink{
+				Source: sourceNode,
+				Target: strconv.FormatUint(adjacent, 10),
+			})
+
+			return true
+		})
+
+		return true
+	})
+
+	graph.AddSeries("graph", nodes, links).
+		SetSeriesOptions(
+			charts.WithGraphChartOpts(opts.GraphChart{
+				Force: &opts.GraphForce{Repulsion: 8000},
+			}),
+		)
+	return graph
+}
+
+func doTheGraph(digraph container.DirectedGraph, direction graph.Direction) {
+	page := components.NewPage()
+	page.AddCharts(
+		graphDigraph(digraph, direction),
+	)
+
+	f, err := os.Create("graph.html")
+	if err != nil {
+		panic(err)
+
+	}
+	page.Render(io.MultiWriter(f))
+	f.Close()
+}

cmd/viz/main.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/specterops/dawgs"
+	"github.com/specterops/dawgs/container"
+	"github.com/specterops/dawgs/database/pg"
+	"github.com/specterops/dawgs/graph"
+	"github.com/specterops/dawgs/query"
+)
+
+func main() {
+	ctx, done := context.WithCancel(context.Background())
+	defer done()
+
+	dbInst, err := dawgs.Open(ctx, pg.DriverName, dawgs.Config{
+		ConnectionString: "user=postgres dbname=bhe password=bhe4eva host=localhost",
+	})
+
+	if err != nil {
+		panic(err)
+	}
+
+	metaKinds := graph.Kinds{
+		graph.StringKind("Meta"),
+		graph.StringKind("MetaDetail"),
+	}
+
+	kindFilter := query.And(
+		query.Not(query.Start().Kinds().HasOneOf(metaKinds)),
+		query.Not(query.End().Kinds().HasOneOf(metaKinds)),
+	)
+
+	if digraph, err := container.FetchTSDB(ctx, dbInst, kindFilter); err != nil {
+		panic(err)
+	} else {
+		fmt.Printf("Loaded %d nodes\n", digraph.Triplestore.NumNodes())
+
+		// algo.CalculateKatzCentrality(digraph, 0.01, 1, 0.01, 1000)
+	}
+}

container/adjacencymap.go

@@ -33,6 +33,7 @@ func BuildAdjacencyMapGraph(adj map[uint64][]uint64) MutableDirectedGraph {
 
 	return digraph
 }
+
 func (s *adjacencyMapDigraph) AddNode(node uint64) {
 	s.nodes.Add(node)
 }

container/digraph.go

@@ -41,19 +41,6 @@ func (s KindMap) FindAll(id uint64) graph.Kinds {
 	return matchedKinds
 }
 
-type DirectedGraph interface {
-	NumNodes() uint64
-	EachNode(delegate func(node uint64) bool)
-	EachAdjacentNode(node uint64, direction graph.Direction, delegate func(adjacent uint64) bool)
-}
-
-type MutableDirectedGraph interface {
-	DirectedGraph
-
-	AddNode(node uint64)
-	AddEdge(start, end uint64)
-}
-
 func BuildGraph(constructor func() MutableDirectedGraph, adj map[uint64][]uint64) MutableDirectedGraph {
 	digraph := constructor()
 
@@ -110,6 +97,19 @@ func AdjacentNodes(digraph DirectedGraph, node uint64, direction graph.Direction
 	return nodes
 }
 
+type DirectedGraph interface {
+	NumNodes() uint64
+	EachNode(delegate func(node uint64) bool)
+	EachAdjacentNode(node uint64, direction graph.Direction, delegate func(adjacent uint64) bool)
+}
+
+type MutableDirectedGraph interface {
+	DirectedGraph
+
+	AddNode(node uint64)
+	AddEdge(start, end uint64)
+}
+
 func Dimensions(digraph DirectedGraph, direction graph.Direction) (uint64, uint64) {
 	var largestRow uint64 = 0