github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/libnetwork/networkdb/networkdb_test.go (about)

     1  package networkdb
     2  
     3  import (
     4  	"flag"
     5  	"fmt"
     6  	"log"
     7  	"os"
     8  	"sync/atomic"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/Sirupsen/logrus"
    13  	"github.com/docker/go-events"
    14  	"github.com/stretchr/testify/assert"
    15  	"github.com/stretchr/testify/require"
    16  )
    17  
    18  var (
    19  	dbPort             int32 = 10000
    20  	runningInContainer       = flag.Bool("incontainer", false, "Indicates if the test is running in a container")
    21  )
    22  
    23  func TestMain(m *testing.M) {
    24  	logrus.SetLevel(logrus.ErrorLevel)
    25  	os.Exit(m.Run())
    26  }
    27  
    28  func createNetworkDBInstances(t *testing.T, num int, namePrefix string) []*NetworkDB {
    29  	var dbs []*NetworkDB
    30  	for i := 0; i < num; i++ {
    31  		db, err := New(&Config{
    32  			NodeName: fmt.Sprintf("%s%d", namePrefix, i+1),
    33  			BindPort: int(atomic.AddInt32(&dbPort, 1)),
    34  		})
    35  		require.NoError(t, err)
    36  
    37  		if i != 0 {
    38  			err = db.Join([]string{fmt.Sprintf("localhost:%d", db.config.BindPort-1)})
    39  			assert.NoError(t, err)
    40  		}
    41  
    42  		dbs = append(dbs, db)
    43  	}
    44  
    45  	return dbs
    46  }
    47  
    48  func closeNetworkDBInstances(dbs []*NetworkDB) {
    49  	for _, db := range dbs {
    50  		db.Close()
    51  	}
    52  }
    53  
    54  func (db *NetworkDB) verifyNodeExistence(t *testing.T, node string, present bool) {
    55  	for i := 0; i < 80; i++ {
    56  		_, ok := db.nodes[node]
    57  		if present && ok {
    58  			return
    59  		}
    60  
    61  		if !present && !ok {
    62  			return
    63  		}
    64  
    65  		time.Sleep(50 * time.Millisecond)
    66  	}
    67  
    68  	assert.Fail(t, fmt.Sprintf("%s: Node existence verification for node %s failed", db.config.NodeName, node))
    69  }
    70  
    71  func (db *NetworkDB) verifyNetworkExistence(t *testing.T, node string, id string, present bool) {
    72  	for i := 0; i < 80; i++ {
    73  		if nn, nnok := db.networks[node]; nnok {
    74  			n, ok := nn[id]
    75  			if present && ok {
    76  				return
    77  			}
    78  
    79  			if !present &&
    80  				((ok && n.leaving) ||
    81  					!ok) {
    82  				return
    83  			}
    84  		}
    85  
    86  		time.Sleep(50 * time.Millisecond)
    87  	}
    88  
    89  	assert.Fail(t, "Network existence verification failed")
    90  }
    91  
    92  func (db *NetworkDB) verifyEntryExistence(t *testing.T, tname, nid, key, value string, present bool) {
    93  	n := 80
    94  	for i := 0; i < n; i++ {
    95  		entry, err := db.getEntry(tname, nid, key)
    96  		if present && err == nil && string(entry.value) == value {
    97  			return
    98  		}
    99  
   100  		if !present &&
   101  			((err == nil && entry.deleting) ||
   102  				(err != nil)) {
   103  			return
   104  		}
   105  
   106  		if i == n-1 && !present && err != nil {
   107  			return
   108  		}
   109  
   110  		time.Sleep(50 * time.Millisecond)
   111  	}
   112  
   113  	assert.Fail(t, fmt.Sprintf("Entry existence verification test failed for %s", db.config.NodeName))
   114  }
   115  
   116  func testWatch(t *testing.T, ch chan events.Event, ev interface{}, tname, nid, key, value string) {
   117  	select {
   118  	case rcvdEv := <-ch:
   119  		assert.Equal(t, fmt.Sprintf("%T", rcvdEv), fmt.Sprintf("%T", ev))
   120  		switch rcvdEv.(type) {
   121  		case CreateEvent:
   122  			assert.Equal(t, tname, rcvdEv.(CreateEvent).Table)
   123  			assert.Equal(t, nid, rcvdEv.(CreateEvent).NetworkID)
   124  			assert.Equal(t, key, rcvdEv.(CreateEvent).Key)
   125  			assert.Equal(t, value, string(rcvdEv.(CreateEvent).Value))
   126  		case UpdateEvent:
   127  			assert.Equal(t, tname, rcvdEv.(UpdateEvent).Table)
   128  			assert.Equal(t, nid, rcvdEv.(UpdateEvent).NetworkID)
   129  			assert.Equal(t, key, rcvdEv.(UpdateEvent).Key)
   130  			assert.Equal(t, value, string(rcvdEv.(UpdateEvent).Value))
   131  		case DeleteEvent:
   132  			assert.Equal(t, tname, rcvdEv.(DeleteEvent).Table)
   133  			assert.Equal(t, nid, rcvdEv.(DeleteEvent).NetworkID)
   134  			assert.Equal(t, key, rcvdEv.(DeleteEvent).Key)
   135  		}
   136  	case <-time.After(time.Second):
   137  		t.Fail()
   138  		return
   139  	}
   140  }
   141  
   142  func TestNetworkDBSimple(t *testing.T) {
   143  	dbs := createNetworkDBInstances(t, 2, "node")
   144  	closeNetworkDBInstances(dbs)
   145  }
   146  
   147  func TestNetworkDBJoinLeaveNetwork(t *testing.T) {
   148  	dbs := createNetworkDBInstances(t, 2, "node")
   149  
   150  	err := dbs[0].JoinNetwork("network1")
   151  	assert.NoError(t, err)
   152  
   153  	dbs[1].verifyNetworkExistence(t, "node1", "network1", true)
   154  
   155  	err = dbs[0].LeaveNetwork("network1")
   156  	assert.NoError(t, err)
   157  
   158  	dbs[1].verifyNetworkExistence(t, "node1", "network1", false)
   159  	closeNetworkDBInstances(dbs)
   160  }
   161  
   162  func TestNetworkDBJoinLeaveNetworks(t *testing.T) {
   163  	dbs := createNetworkDBInstances(t, 2, "node")
   164  
   165  	n := 10
   166  	for i := 1; i <= n; i++ {
   167  		err := dbs[0].JoinNetwork(fmt.Sprintf("network0%d", i))
   168  		assert.NoError(t, err)
   169  	}
   170  
   171  	for i := 1; i <= n; i++ {
   172  		err := dbs[1].JoinNetwork(fmt.Sprintf("network1%d", i))
   173  		assert.NoError(t, err)
   174  	}
   175  
   176  	for i := 1; i <= n; i++ {
   177  		dbs[1].verifyNetworkExistence(t, "node1", fmt.Sprintf("network0%d", i), true)
   178  	}
   179  
   180  	for i := 1; i <= n; i++ {
   181  		dbs[0].verifyNetworkExistence(t, "node2", fmt.Sprintf("network1%d", i), true)
   182  	}
   183  
   184  	for i := 1; i <= n; i++ {
   185  		err := dbs[0].LeaveNetwork(fmt.Sprintf("network0%d", i))
   186  		assert.NoError(t, err)
   187  	}
   188  
   189  	for i := 1; i <= n; i++ {
   190  		err := dbs[1].LeaveNetwork(fmt.Sprintf("network1%d", i))
   191  		assert.NoError(t, err)
   192  	}
   193  
   194  	for i := 1; i <= n; i++ {
   195  		dbs[1].verifyNetworkExistence(t, "node1", fmt.Sprintf("network0%d", i), false)
   196  	}
   197  
   198  	for i := 1; i <= n; i++ {
   199  		dbs[0].verifyNetworkExistence(t, "node2", fmt.Sprintf("network1%d", i), false)
   200  	}
   201  
   202  	closeNetworkDBInstances(dbs)
   203  }
   204  
   205  func TestNetworkDBCRUDTableEntry(t *testing.T) {
   206  	dbs := createNetworkDBInstances(t, 3, "node")
   207  
   208  	err := dbs[0].JoinNetwork("network1")
   209  	assert.NoError(t, err)
   210  
   211  	dbs[1].verifyNetworkExistence(t, "node1", "network1", true)
   212  
   213  	err = dbs[1].JoinNetwork("network1")
   214  	assert.NoError(t, err)
   215  
   216  	err = dbs[0].CreateEntry("test_table", "network1", "test_key", []byte("test_value"))
   217  	assert.NoError(t, err)
   218  
   219  	dbs[1].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_value", true)
   220  	dbs[2].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_value", false)
   221  
   222  	err = dbs[0].UpdateEntry("test_table", "network1", "test_key", []byte("test_updated_value"))
   223  	assert.NoError(t, err)
   224  
   225  	dbs[1].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_updated_value", true)
   226  
   227  	err = dbs[0].DeleteEntry("test_table", "network1", "test_key")
   228  	assert.NoError(t, err)
   229  
   230  	dbs[1].verifyEntryExistence(t, "test_table", "network1", "test_key", "", false)
   231  
   232  	closeNetworkDBInstances(dbs)
   233  }
   234  
   235  func TestNetworkDBCRUDTableEntries(t *testing.T) {
   236  	dbs := createNetworkDBInstances(t, 2, "node")
   237  
   238  	err := dbs[0].JoinNetwork("network1")
   239  	assert.NoError(t, err)
   240  
   241  	dbs[1].verifyNetworkExistence(t, "node1", "network1", true)
   242  
   243  	err = dbs[1].JoinNetwork("network1")
   244  	assert.NoError(t, err)
   245  
   246  	n := 10
   247  	for i := 1; i <= n; i++ {
   248  		err = dbs[0].CreateEntry("test_table", "network1",
   249  			fmt.Sprintf("test_key0%d", i),
   250  			[]byte(fmt.Sprintf("test_value0%d", i)))
   251  		assert.NoError(t, err)
   252  	}
   253  
   254  	for i := 1; i <= n; i++ {
   255  		err = dbs[1].CreateEntry("test_table", "network1",
   256  			fmt.Sprintf("test_key1%d", i),
   257  			[]byte(fmt.Sprintf("test_value1%d", i)))
   258  		assert.NoError(t, err)
   259  	}
   260  
   261  	for i := 1; i <= n; i++ {
   262  		dbs[0].verifyEntryExistence(t, "test_table", "network1",
   263  			fmt.Sprintf("test_key1%d", i),
   264  			fmt.Sprintf("test_value1%d", i), true)
   265  		assert.NoError(t, err)
   266  	}
   267  
   268  	for i := 1; i <= n; i++ {
   269  		dbs[1].verifyEntryExistence(t, "test_table", "network1",
   270  			fmt.Sprintf("test_key0%d", i),
   271  			fmt.Sprintf("test_value0%d", i), true)
   272  		assert.NoError(t, err)
   273  	}
   274  
   275  	// Verify deletes
   276  	for i := 1; i <= n; i++ {
   277  		err = dbs[0].DeleteEntry("test_table", "network1",
   278  			fmt.Sprintf("test_key0%d", i))
   279  		assert.NoError(t, err)
   280  	}
   281  
   282  	for i := 1; i <= n; i++ {
   283  		err = dbs[1].DeleteEntry("test_table", "network1",
   284  			fmt.Sprintf("test_key1%d", i))
   285  		assert.NoError(t, err)
   286  	}
   287  
   288  	for i := 1; i <= n; i++ {
   289  		dbs[0].verifyEntryExistence(t, "test_table", "network1",
   290  			fmt.Sprintf("test_key1%d", i), "", false)
   291  		assert.NoError(t, err)
   292  	}
   293  
   294  	for i := 1; i <= n; i++ {
   295  		dbs[1].verifyEntryExistence(t, "test_table", "network1",
   296  			fmt.Sprintf("test_key0%d", i), "", false)
   297  		assert.NoError(t, err)
   298  	}
   299  
   300  	closeNetworkDBInstances(dbs)
   301  }
   302  
   303  func TestNetworkDBNodeLeave(t *testing.T) {
   304  	dbs := createNetworkDBInstances(t, 2, "node")
   305  
   306  	err := dbs[0].JoinNetwork("network1")
   307  	assert.NoError(t, err)
   308  
   309  	err = dbs[1].JoinNetwork("network1")
   310  	assert.NoError(t, err)
   311  
   312  	err = dbs[0].CreateEntry("test_table", "network1", "test_key", []byte("test_value"))
   313  	assert.NoError(t, err)
   314  
   315  	dbs[1].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_value", true)
   316  
   317  	dbs[0].Close()
   318  	dbs[1].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_value", false)
   319  	dbs[1].Close()
   320  }
   321  
   322  func TestNetworkDBWatch(t *testing.T) {
   323  	dbs := createNetworkDBInstances(t, 2, "node")
   324  	err := dbs[0].JoinNetwork("network1")
   325  	assert.NoError(t, err)
   326  
   327  	err = dbs[1].JoinNetwork("network1")
   328  	assert.NoError(t, err)
   329  
   330  	ch, cancel := dbs[1].Watch("", "", "")
   331  
   332  	err = dbs[0].CreateEntry("test_table", "network1", "test_key", []byte("test_value"))
   333  	assert.NoError(t, err)
   334  
   335  	testWatch(t, ch, CreateEvent{}, "test_table", "network1", "test_key", "test_value")
   336  
   337  	err = dbs[0].UpdateEntry("test_table", "network1", "test_key", []byte("test_updated_value"))
   338  	assert.NoError(t, err)
   339  
   340  	testWatch(t, ch, UpdateEvent{}, "test_table", "network1", "test_key", "test_updated_value")
   341  
   342  	err = dbs[0].DeleteEntry("test_table", "network1", "test_key")
   343  	assert.NoError(t, err)
   344  
   345  	testWatch(t, ch, DeleteEvent{}, "test_table", "network1", "test_key", "")
   346  
   347  	cancel()
   348  	closeNetworkDBInstances(dbs)
   349  }
   350  
   351  func TestNetworkDBBulkSync(t *testing.T) {
   352  	dbs := createNetworkDBInstances(t, 2, "node")
   353  
   354  	err := dbs[0].JoinNetwork("network1")
   355  	assert.NoError(t, err)
   356  
   357  	dbs[1].verifyNetworkExistence(t, "node1", "network1", true)
   358  
   359  	n := 1000
   360  	for i := 1; i <= n; i++ {
   361  		err = dbs[0].CreateEntry("test_table", "network1",
   362  			fmt.Sprintf("test_key0%d", i),
   363  			[]byte(fmt.Sprintf("test_value0%d", i)))
   364  		assert.NoError(t, err)
   365  	}
   366  
   367  	err = dbs[1].JoinNetwork("network1")
   368  	assert.NoError(t, err)
   369  
   370  	dbs[0].verifyNetworkExistence(t, "node2", "network1", true)
   371  
   372  	for i := 1; i <= n; i++ {
   373  		dbs[1].verifyEntryExistence(t, "test_table", "network1",
   374  			fmt.Sprintf("test_key0%d", i),
   375  			fmt.Sprintf("test_value0%d", i), true)
   376  		assert.NoError(t, err)
   377  	}
   378  
   379  	closeNetworkDBInstances(dbs)
   380  }
   381  
   382  func TestNetworkDBCRUDMediumCluster(t *testing.T) {
   383  	n := 5
   384  
   385  	dbs := createNetworkDBInstances(t, n, "node")
   386  
   387  	for i := 0; i < n; i++ {
   388  		for j := 0; j < n; j++ {
   389  			if i == j {
   390  				continue
   391  			}
   392  
   393  			dbs[i].verifyNodeExistence(t, fmt.Sprintf("node%d", j+1), true)
   394  		}
   395  	}
   396  
   397  	for i := 0; i < n; i++ {
   398  		err := dbs[i].JoinNetwork("network1")
   399  		assert.NoError(t, err)
   400  	}
   401  
   402  	for i := 0; i < n; i++ {
   403  		for j := 0; j < n; j++ {
   404  			dbs[i].verifyNetworkExistence(t, fmt.Sprintf("node%d", j+1), "network1", true)
   405  		}
   406  	}
   407  
   408  	err := dbs[0].CreateEntry("test_table", "network1", "test_key", []byte("test_value"))
   409  	assert.NoError(t, err)
   410  
   411  	for i := 1; i < n; i++ {
   412  		dbs[i].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_value", true)
   413  	}
   414  
   415  	err = dbs[0].UpdateEntry("test_table", "network1", "test_key", []byte("test_updated_value"))
   416  	assert.NoError(t, err)
   417  
   418  	for i := 1; i < n; i++ {
   419  		dbs[i].verifyEntryExistence(t, "test_table", "network1", "test_key", "test_updated_value", true)
   420  	}
   421  
   422  	err = dbs[0].DeleteEntry("test_table", "network1", "test_key")
   423  	assert.NoError(t, err)
   424  
   425  	for i := 1; i < n; i++ {
   426  		dbs[i].verifyEntryExistence(t, "test_table", "network1", "test_key", "", false)
   427  	}
   428  
   429  	log.Printf("Closing DB instances...")
   430  	closeNetworkDBInstances(dbs)
   431  }