refactor: remove unnessary bool return

Author: siyul-park

pkg/runtime/runtime.go

@@ -163,8 +163,8 @@ func (r *Runtime) Reconcile(ctx context.Context) error {
 
 			bounded := make(map[uuid.UUID]spec.Spec)
 			for _, id := range r.symbolTable.Keys() {
-				sb, ok := r.symbolTable.Lookup(id)
-				if ok && r.scheme.IsBound(sb.Spec, secrets...) {
+				sb := r.symbolTable.Lookup(id)
+				if sb != nil && r.scheme.IsBound(sb.Spec, secrets...) {
 					bounded[sb.Spec.GetID()] = sb.Spec
 				}
 			}

pkg/symbol/loader.go

@@ -85,8 +85,8 @@ func (l *Loader) Load(ctx context.Context, specs ...spec.Spec) error {
 			continue
 		}
 
-		sb, ok := l.table.Lookup(decode.GetID())
-		if !ok || !reflect.DeepEqual(sb.Spec, decode) {
+		sb := l.table.Lookup(decode.GetID())
+		if sb == nil || !reflect.DeepEqual(sb.Spec, decode) {
 			n, err := l.scheme.Compile(decode)
 			if err != nil {
 				errs = append(errs, err)
@@ -108,8 +108,8 @@ func (l *Loader) Load(ctx context.Context, specs ...spec.Spec) error {
 	}
 
 	for _, id := range l.table.Keys() {
-		sb, ok := l.table.Lookup(id)
-		if ok && len(resource.Match(sb.Spec, examples...)) > 0 {
+		sb := l.table.Lookup(id)
+		if sb != nil && len(resource.Match(sb.Spec, examples...)) > 0 {
 			ok := false
 			for _, s := range symbols {
 				if s.ID() == id {

pkg/symbol/loader_test.go

@@ -77,15 +77,9 @@ func TestLoader_Load(t *testing.T) {
 
 		err := loader.Load(ctx, meta1, meta2, meta3)
 		assert.NoError(t, err)
-
-		_, ok := table.Lookup(meta1.GetID())
-		assert.True(t, ok)
-
-		_, ok = table.Lookup(meta2.GetID())
-		assert.True(t, ok)
-
-		_, ok = table.Lookup(meta3.GetID())
-		assert.True(t, ok)
+		assert.NotNil(t, table.Lookup(meta1.GetID()))
+		assert.NotNil(t, table.Lookup(meta2.GetID()))
+		assert.NotNil(t, table.Lookup(meta3.GetID()))
 	})
 
 	t.Run("ReloadWithSameID", func(t *testing.T) {
@@ -166,9 +160,7 @@ func TestLoader_Load(t *testing.T) {
 
 		err = loader.Load(ctx, meta)
 		assert.NoError(t, err)
-
-		_, ok := table.Lookup(meta.GetID())
-		assert.False(t, ok)
+		assert.Nil(t, table.Lookup(meta.GetID()))
 	})
 
 	t.Run("LoadMultipleSecrets", func(t *testing.T) {
@@ -214,9 +206,7 @@ func TestLoader_Load(t *testing.T) {
 
 		err := loader.Load(ctx, meta)
 		assert.NoError(t, err)
-
-		_, ok := table.Lookup(meta.GetID())
-		assert.True(t, ok)
+		assert.NotNil(t, table.Lookup(meta.GetID()))
 	})
 
 	t.Run("LoadNonExistSecret", func(t *testing.T) {
@@ -252,8 +242,6 @@ func TestLoader_Load(t *testing.T) {
 
 		err := loader.Load(ctx, meta)
 		assert.Error(t, err)
-
-		_, ok := table.Lookup(meta.GetID())
-		assert.False(t, ok)
+		assert.Nil(t, table.Lookup(meta.GetID()))
 	})
 }

pkg/symbol/symbol.go

@@ -11,12 +11,11 @@ import (
 
 // Symbol represents a Node that is identifiable within a Spec.
 type Symbol struct {
-	Spec     spec.Spec
-	Node     node.Node
-	inbounds map[string][]spec.Port
-	ins      map[string]*port.InPort
-	outs     map[string]*port.OutPort
-	mu       sync.RWMutex
+	Spec spec.Spec
+	Node node.Node
+	ins  map[string]*port.InPort
+	outs map[string]*port.OutPort
+	mu   sync.RWMutex
 }
 
 var _ node.Node = (*Symbol)(nil)
@@ -51,18 +50,6 @@ func (s *Symbol) Ports() map[string][]spec.Port {
 	return s.Spec.GetPorts()
 }
 
-// Links returns the references associated with the Symbol.
-func (s *Symbol) Links() map[string][]spec.Port {
-	links := make(map[string][]spec.Port)
-	for name, ports := range s.Spec.GetPorts() {
-		links[name] = append(links[name], ports...)
-	}
-	for name, ports := range s.inbounds {
-		links[name] = append(links[name], ports...)
-	}
-	return links
-}
-
 // Env returns the environment variables associated with the Symbol.
 func (s *Symbol) Env() map[string][]spec.Secret {
 	return s.Spec.GetEnv()

pkg/symbol/symbol_test.go

@@ -44,7 +44,6 @@ func TestSymbol_Getter(t *testing.T) {
 	assert.Equal(t, meta.GetName(), sb.Name())
 	assert.Equal(t, meta.GetAnnotations(), sb.Annotations())
 	assert.Equal(t, meta.GetPorts(), sb.Ports())
-	assert.Equal(t, meta.GetPorts(), sb.Links())
 	assert.Equal(t, meta.GetEnv(), sb.Env())
 	assert.Equal(t, n.In(node.PortIn), sb.In(node.PortIn))
 	assert.Equal(t, n.Out(node.PortOut), sb.Out(node.PortOut))

pkg/symbol/table.go

@@ -21,6 +21,7 @@ type TableOptions struct {
 type Table struct {
 	symbols     map[uuid.UUID]*Symbol
 	namespaces  map[string]map[string]uuid.UUID
+	refences    map[uuid.UUID]map[string][]spec.Port
 	loadHooks   LoadHooks
 	unloadHooks UnloadHooks
 	mu          sync.RWMutex
@@ -38,6 +39,7 @@ func NewTable(opts ...TableOptions) *Table {
 	return &Table{
 		symbols:     make(map[uuid.UUID]*Symbol),
 		namespaces:  make(map[string]map[string]uuid.UUID),
+		refences:    make(map[uuid.UUID]map[string][]spec.Port),
 		loadHooks:   loadHooks,
 		unloadHooks: unloadHooks,
 	}
@@ -48,17 +50,10 @@ func (t *Table) Insert(sb *Symbol) error {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 
-	if sb.inbounds == nil {
-		sb.inbounds = make(map[string][]spec.Port)
-	}
-
 	if _, err := t.free(sb.ID()); err != nil {
 		return err
 	}
-	if err := t.insert(sb); err != nil {
-		return err
-	}
-	return nil
+	return t.insert(sb)
 }
 
 // Free removes a symbol from the table by its ID.
@@ -74,12 +69,11 @@ func (t *Table) Free(id uuid.UUID) (bool, error) {
 }
 
 // Lookup retrieves a symbol from the table by its ID.
-func (t *Table) Lookup(id uuid.UUID) (*Symbol, bool) {
+func (t *Table) Lookup(id uuid.UUID) *Symbol {
 	t.mu.RLock()
 	defer t.mu.RUnlock()
 
-	sb, ok := t.symbols[id]
-	return sb, ok
+	return t.symbols[id]
 }
 
 // Keys returns all IDs of symbols in the table.
@@ -198,7 +192,13 @@ func (t *Table) links(sb *Symbol) {
 						}
 					}
 
-					ref.inbounds[port.Port] = append(ref.inbounds[port.Port], spec.Port{
+					refences := t.refences[ref.ID()]
+					if refences == nil {
+						refences = make(map[string][]spec.Port)
+						t.refences[ref.ID()] = refences
+					}
+
+					refences[port.Port] = append(refences[port.Port], spec.Port{
 						ID:   sb.ID(),
 						Name: port.Name,
 						Port: name,
@@ -224,7 +224,13 @@ func (t *Table) links(sb *Symbol) {
 						}
 					}
 
-					sb.inbounds[port.Port] = append(sb.inbounds[port.Port], spec.Port{
+					refences := t.refences[sb.ID()]
+					if refences == nil {
+						refences = make(map[string][]spec.Port)
+						t.refences[sb.ID()] = refences
+					}
+
+					refences[port.Port] = append(refences[port.Port], spec.Port{
 						ID:   ref.ID(),
 						Name: port.Name,
 						Port: name,
@@ -248,20 +254,28 @@ func (t *Table) unlinks(sb *Symbol) {
 				continue
 			}
 
+			refences := t.refences[ref.ID()]
+			if refences == nil {
+				refences = make(map[string][]spec.Port)
+				t.refences[ref.ID()] = refences
+			}
+
 			var ports []spec.Port
-			for _, port := range ref.inbounds[port.Port] {
+			for _, port := range refences[port.Port] {
 				if port.ID != sb.ID() && port.Port != name {
 					ports = append(ports, port)
 				}
 			}
 
 			if len(ports) > 0 {
-				ref.inbounds[port.Port] = ports
+				refences[port.Port] = ports
 			} else {
-				delete(ref.inbounds, port.Port)
+				delete(refences, port.Port)
 			}
 		}
 	}
+
+	delete(t.refences, sb.ID())
 }
 
 func (t *Table) linked(sb *Symbol) []*Symbol {
@@ -271,7 +285,7 @@ func (t *Table) linked(sb *Symbol) []*Symbol {
 	for len(nexts) > 0 {
 		sb := nexts[len(nexts)-1]
 		ok := true
-		for _, ports := range sb.inbounds {
+		for _, ports := range t.refences[sb.ID()] {
 			for _, port := range ports {
 				next := t.symbols[port.ID]
 				ok = slices.Contains(nexts, next) || slices.Contains(linked, next)

pkg/symbol/table_test.go

@@ -383,7 +383,7 @@ func TestTable_Free(t *testing.T) {
 	assert.Equal(t, 0, p3.Links())
 }
 
-func TestTable_LookupByID(t *testing.T) {
+func TestTable_Lookup(t *testing.T) {
 	kind := faker.UUIDHyphenated()
 
 	tb := NewTable()
@@ -396,12 +396,10 @@ func TestTable_LookupByID(t *testing.T) {
 	}
 
 	sb := &Symbol{Spec: meta, Node: node.NewOneToOneNode(nil)}
+
 	err := tb.Insert(sb)
 	assert.NoError(t, err)
-
-	r, ok := tb.Lookup(sb.ID())
-	assert.True(t, ok)
-	assert.Equal(t, sb, r)
+	assert.Equal(t, sb, tb.Lookup(sb.ID()))
 }
 
 func TestTable_Keys(t *testing.T) {