TestMu Conference is Back! Future of Testing + AI
How to use Addr method of server Package
Best Testkube code snippet using server.Addr
cluster.go
Source:cluster.go 
...100}101func (cluster *mongoCluster) LiveServers() (servers []string) {102 cluster.RLock()103 for _, serv := range cluster.servers.Slice() {104 servers = append(servers, serv.Addr)105 }106 cluster.RUnlock()107 return servers108}109func (cluster *mongoCluster) removeServer(server *mongoServer) {110 cluster.Lock()111 cluster.masters.Remove(server)112 other := cluster.servers.Remove(server)113 cluster.Unlock()114 if other != nil {115 other.Close()116 log("Removed server ", server.Addr, " from cluster.")117 }118 server.Close()119}120type isMasterResult struct {121 IsMaster bool122 Secondary bool123 Primary string124 Hosts []string125 Passives []string126 Tags bson.D127 Msg string128 SetName string `bson:"setName"`129 MaxWireVersion int `bson:"maxWireVersion"`130}131func (cluster *mongoCluster) isMaster(socket *mongoSocket, result *isMasterResult) error {132 // Monotonic let's it talk to a slave and still hold the socket.133 session := newSession(Monotonic, cluster, 10*time.Second)134 session.setSocket(socket)135 err := session.Run("ismaster", result)136 session.Close()137 return err138}139type possibleTimeout interface {140 Timeout() bool141}142var syncSocketTimeout = 5 * time.Second143func (cluster *mongoCluster) syncServer(server *mongoServer) (info *mongoServerInfo, hosts []string, err error) {144 var syncTimeout time.Duration145 if raceDetector {146 // This variable is only ever touched by tests.147 globalMutex.Lock()148 syncTimeout = syncSocketTimeout149 globalMutex.Unlock()150 } else {151 syncTimeout = syncSocketTimeout152 }153 addr := server.Addr154 log("SYNC Processing ", addr, "...")155 // Retry a few times to avoid knocking a server down for a hiccup.156 var result isMasterResult157 var tryerr error158 for retry := 0; ; retry++ {159 if retry == 3 || retry == 1 && cluster.failFast {160 return nil, nil, tryerr161 }162 if retry > 0 {163 // Don't abuse the server needlessly if there's something actually wrong.164 if err, ok := tryerr.(possibleTimeout); ok && err.Timeout() {165 // Give a chance for waiters to timeout as well.166 cluster.serverSynced.Broadcast()167 }168 time.Sleep(syncShortDelay)169 }170 // It's not clear what would be a good timeout here. Is it171 // better to wait longer or to retry?172 socket, _, err := server.AcquireSocket(0, syncTimeout)173 if err != nil {174 tryerr = err175 logf("SYNC Failed to get socket to %s: %v", addr, err)176 continue177 }178 err = cluster.isMaster(socket, &result)179 socket.Release()180 if err != nil {181 tryerr = err182 logf("SYNC Command 'ismaster' to %s failed: %v", addr, err)183 continue184 }185 debugf("SYNC Result of 'ismaster' from %s: %#v", addr, result)186 break187 }188 if cluster.setName != "" && result.SetName != cluster.setName {189 logf("SYNC Server %s is not a member of replica set %q", addr, cluster.setName)190 return nil, nil, fmt.Errorf("server %s is not a member of replica set %q", addr, cluster.setName)191 }192 if result.IsMaster {193 debugf("SYNC %s is a master.", addr)194 if !server.info.Master {195 // Made an incorrect assumption above, so fix stats.196 stats.conn(-1, false)197 stats.conn(+1, true)198 }199 } else if result.Secondary {200 debugf("SYNC %s is a slave.", addr)201 } else if cluster.direct {202 logf("SYNC %s in unknown state. Pretending it's a slave due to direct connection.", addr)203 } else {204 logf("SYNC %s is neither a master nor a slave.", addr)205 // Let stats track it as whatever was known before.206 return nil, nil, errors.New(addr + " is not a master nor slave")207 }208 info = &mongoServerInfo{209 Master: result.IsMaster,210 Mongos: result.Msg == "isdbgrid",211 Tags: result.Tags,212 SetName: result.SetName,213 MaxWireVersion: result.MaxWireVersion,214 }215 hosts = make([]string, 0, 1+len(result.Hosts)+len(result.Passives))216 if result.Primary != "" {217 // First in the list to speed up master discovery.218 hosts = append(hosts, result.Primary)219 }220 hosts = append(hosts, result.Hosts...)221 hosts = append(hosts, result.Passives...)222 debugf("SYNC %s knows about the following peers: %#v", addr, hosts)223 return info, hosts, nil224}225type syncKind bool226const (227 completeSync syncKind = true228 partialSync syncKind = false229)230func (cluster *mongoCluster) addServer(server *mongoServer, info *mongoServerInfo, syncKind syncKind) {231 cluster.Lock()232 current := cluster.servers.Search(server.ResolvedAddr)233 if current == nil {234 if syncKind == partialSync {235 cluster.Unlock()236 server.Close()237 log("SYNC Discarding unknown server ", server.Addr, " due to partial sync.")238 return239 }240 cluster.servers.Add(server)241 if info.Master {242 cluster.masters.Add(server)243 log("SYNC Adding ", server.Addr, " to cluster as a master.")244 } else {245 log("SYNC Adding ", server.Addr, " to cluster as a slave.")246 }247 } else {248 if server != current {249 panic("addServer attempting to add duplicated server")250 }251 if server.Info().Master != info.Master {252 if info.Master {253 log("SYNC Server ", server.Addr, " is now a master.")254 cluster.masters.Add(server)255 } else {256 log("SYNC Server ", server.Addr, " is now a slave.")257 cluster.masters.Remove(server)258 }259 }260 }261 server.SetInfo(info)262 debugf("SYNC Broadcasting availability of server %s", server.Addr)263 cluster.serverSynced.Broadcast()264 cluster.Unlock()265}266func (cluster *mongoCluster) getKnownAddrs() []string {267 cluster.RLock()268 max := len(cluster.userSeeds) + len(cluster.dynaSeeds) + cluster.servers.Len()269 seen := make(map[string]bool, max)270 known := make([]string, 0, max)271 add := func(addr string) {272 if _, found := seen[addr]; !found {273 seen[addr] = true274 known = append(known, addr)275 }276 }277 for _, addr := range cluster.userSeeds {278 add(addr)279 }280 for _, addr := range cluster.dynaSeeds {281 add(addr)282 }283 for _, serv := range cluster.servers.Slice() {284 add(serv.Addr)285 }286 cluster.RUnlock()287 return known288}289// syncServers injects a value into the cluster.sync channel to force290// an iteration of the syncServersLoop function.291func (cluster *mongoCluster) syncServers() {292 select {293 case cluster.sync <- true:294 default:295 }296}297// How long to wait for a checkup of the cluster topology if nothing298// else kicks a synchronization before that.299const syncServersDelay = 30 * time.Second300const syncShortDelay = 500 * time.Millisecond301// syncServersLoop loops while the cluster is alive to keep its idea of302// the server topology up-to-date. It must be called just once from303// newCluster. The loop iterates once syncServersDelay has passed, or304// if somebody injects a value into the cluster.sync channel to force a305// synchronization. A loop iteration will contact all servers in306// parallel, ask them about known peers and their own role within the307// cluster, and then attempt to do the same with all the peers308// retrieved.309func (cluster *mongoCluster) syncServersLoop() {310 for {311 debugf("SYNC Cluster %p is starting a sync loop iteration.", cluster)312 cluster.Lock()313 if cluster.references == 0 {314 cluster.Unlock()315 break316 }317 cluster.references++ // Keep alive while syncing.318 direct := cluster.direct319 cluster.Unlock()320 cluster.syncServersIteration(direct)321 // We just synchronized, so consume any outstanding requests.322 select {323 case <-cluster.sync:324 default:325 }326 cluster.Release()327 // Hold off before allowing another sync. No point in328 // burning CPU looking for down servers.329 if !cluster.failFast {330 time.Sleep(syncShortDelay)331 }332 cluster.Lock()333 if cluster.references == 0 {334 cluster.Unlock()335 break336 }337 cluster.syncCount++338 // Poke all waiters so they have a chance to timeout or339 // restart syncing if they wish to.340 cluster.serverSynced.Broadcast()341 // Check if we have to restart immediately either way.342 restart := !direct && cluster.masters.Empty() || cluster.servers.Empty()343 cluster.Unlock()344 if restart {345 log("SYNC No masters found. Will synchronize again.")346 time.Sleep(syncShortDelay)347 continue348 }349 debugf("SYNC Cluster %p waiting for next requested or scheduled sync.", cluster)350 // Hold off until somebody explicitly requests a synchronization351 // or it's time to check for a cluster topology change again.352 select {353 case <-cluster.sync:354 case <-time.After(syncServersDelay):355 }356 }357 debugf("SYNC Cluster %p is stopping its sync loop.", cluster)358}359func (cluster *mongoCluster) server(addr string, tcpaddr *net.TCPAddr) *mongoServer {360 cluster.RLock()361 server := cluster.servers.Search(tcpaddr.String())362 cluster.RUnlock()363 if server != nil {364 return server365 }366 return newServer(addr, tcpaddr, cluster.sync, cluster.dial)367}368func resolveAddr(addr string) (*net.TCPAddr, error) {369 // Simple cases that do not need actual resolution. Works with IPv4 and v6.370 if host, port, err := net.SplitHostPort(addr); err == nil {371 if port, _ := strconv.Atoi(port); port > 0 {372 zone := ""373 if i := strings.LastIndex(host, "%"); i >= 0 {374 zone = host[i+1:]375 host = host[:i]376 }377 ip := net.ParseIP(host)378 if ip != nil {379 return &net.TCPAddr{IP: ip, Port: port, Zone: zone}, nil380 }381 }382 }383 // Attempt to resolve IPv4 and v6 concurrently.384 addrChan := make(chan *net.TCPAddr, 2)385 for _, network := range []string{"udp4", "udp6"} {386 network := network387 go func() {388 // The unfortunate UDP dialing hack allows having a timeout on address resolution.389 conn, err := net.DialTimeout(network, addr, 10*time.Second)390 if err != nil {391 addrChan <- nil392 } else {393 addrChan <- (*net.TCPAddr)(conn.RemoteAddr().(*net.UDPAddr))394 conn.Close()395 }396 }()397 }398 // Wait for the result of IPv4 and v6 resolution. Use IPv4 if available.399 tcpaddr := <-addrChan400 if tcpaddr == nil || len(tcpaddr.IP) != 4 {401 var timeout <-chan time.Time402 if tcpaddr != nil {403 // Don't wait too long if an IPv6 address is known.404 timeout = time.After(50 * time.Millisecond)405 }406 select {407 case <-timeout:408 case tcpaddr2 := <-addrChan:409 if tcpaddr == nil || tcpaddr2 != nil {410 // It's an IPv4 address or the only known address. Use it.411 tcpaddr = tcpaddr2412 }413 }414 }415 if tcpaddr == nil {416 log("SYNC Failed to resolve server address: ", addr)417 return nil, errors.New("failed to resolve server address: " + addr)418 }419 if tcpaddr.String() != addr {420 debug("SYNC Address ", addr, " resolved as ", tcpaddr.String())421 }422 return tcpaddr, nil423}424type pendingAdd struct {425 server *mongoServer426 info *mongoServerInfo427}428func (cluster *mongoCluster) syncServersIteration(direct bool) {429 log("SYNC Starting full topology synchronization...")430 var wg sync.WaitGroup431 var m sync.Mutex432 notYetAdded := make(map[string]pendingAdd)433 addIfFound := make(map[string]bool)434 seen := make(map[string]bool)435 syncKind := partialSync436 var spawnSync func(addr string, byMaster bool)437 spawnSync = func(addr string, byMaster bool) {438 wg.Add(1)439 go func() {440 defer wg.Done()441 tcpaddr, err := resolveAddr(addr)442 if err != nil {443 log("SYNC Failed to start sync of ", addr, ": ", err.Error())444 return445 }446 resolvedAddr := tcpaddr.String()447 m.Lock()448 if byMaster {449 if pending, ok := notYetAdded[resolvedAddr]; ok {450 delete(notYetAdded, resolvedAddr)451 m.Unlock()452 cluster.addServer(pending.server, pending.info, completeSync)453 return454 }455 addIfFound[resolvedAddr] = true456 }457 if seen[resolvedAddr] {458 m.Unlock()459 return460 }461 seen[resolvedAddr] = true462 m.Unlock()463 server := cluster.server(addr, tcpaddr)464 info, hosts, err := cluster.syncServer(server)465 if err != nil {466 cluster.removeServer(server)467 return468 }469 m.Lock()470 add := direct || info.Master || addIfFound[resolvedAddr]471 if add {472 syncKind = completeSync473 } else {474 notYetAdded[resolvedAddr] = pendingAdd{server, info}475 }476 m.Unlock()477 if add {478 cluster.addServer(server, info, completeSync)479 }480 if !direct {481 for _, addr := range hosts {482 spawnSync(addr, info.Master)483 }484 }485 }()486 }487 knownAddrs := cluster.getKnownAddrs()488 for _, addr := range knownAddrs {489 spawnSync(addr, false)490 }491 wg.Wait()492 if syncKind == completeSync {493 logf("SYNC Synchronization was complete (got data from primary).")494 for _, pending := range notYetAdded {495 cluster.removeServer(pending.server)496 }497 } else {498 logf("SYNC Synchronization was partial (cannot talk to primary).")499 for _, pending := range notYetAdded {500 cluster.addServer(pending.server, pending.info, partialSync)501 }502 }503 cluster.Lock()504 mastersLen := cluster.masters.Len()505 logf("SYNC Synchronization completed: %d master(s) and %d slave(s) alive.", mastersLen, cluster.servers.Len()-mastersLen)506 // Update dynamic seeds, but only if we have any good servers. Otherwise,507 // leave them alone for better chances of a successful sync in the future.508 if syncKind == completeSync {509 dynaSeeds := make([]string, cluster.servers.Len())510 for i, server := range cluster.servers.Slice() {511 dynaSeeds[i] = server.Addr512 }513 cluster.dynaSeeds = dynaSeeds514 debugf("SYNC New dynamic seeds: %#v\n", dynaSeeds)515 }516 cluster.Unlock()517}518// AcquireSocket returns a socket to a server in the cluster. If slaveOk is519// true, it will attempt to return a socket to a slave server. If it is520// false, the socket will necessarily be to a master server.521func (cluster *mongoCluster) AcquireSocket(mode Mode, slaveOk bool, syncTimeout time.Duration, socketTimeout time.Duration, serverTags []bson.D, poolLimit int) (s *mongoSocket, err error) {522 var started time.Time523 var syncCount uint524 warnedLimit := false525 for {526 cluster.RLock()527 for {528 mastersLen := cluster.masters.Len()529 slavesLen := cluster.servers.Len() - mastersLen530 debugf("Cluster has %d known masters and %d known slaves.", mastersLen, slavesLen)531 if mastersLen > 0 && !(slaveOk && mode == Secondary) || slavesLen > 0 && slaveOk {532 break533 }534 if mastersLen > 0 && mode == Secondary && cluster.masters.HasMongos() {535 break536 }537 if started.IsZero() {538 // Initialize after fast path above.539 started = time.Now()540 syncCount = cluster.syncCount541 } else if syncTimeout != 0 && started.Before(time.Now().Add(-syncTimeout)) || cluster.failFast && cluster.syncCount != syncCount {542 cluster.RUnlock()543 return nil, errors.New("no reachable servers")544 }545 log("Waiting for servers to synchronize...")546 cluster.syncServers()547 // Remember: this will release and reacquire the lock.548 cluster.serverSynced.Wait()549 }550 var server *mongoServer551 if slaveOk {552 server = cluster.servers.BestFit(mode, serverTags)553 } else {554 server = cluster.masters.BestFit(mode, nil)555 }556 cluster.RUnlock()557 if server == nil {558 // Must have failed the requested tags. Sleep to avoid spinning.559 time.Sleep(1e8)560 continue561 }562 s, abended, err := server.AcquireSocket(poolLimit, socketTimeout)563 if err == errPoolLimit {564 if !warnedLimit {565 warnedLimit = true566 log("WARNING: Per-server connection limit reached.")567 }568 time.Sleep(100 * time.Millisecond)569 continue570 }571 if err != nil {572 cluster.removeServer(server)573 cluster.syncServers()574 continue575 }576 if abended && !slaveOk {577 var result isMasterResult578 err := cluster.isMaster(s, &result)579 if err != nil || !result.IsMaster {580 logf("Cannot confirm server %s as master (%v)", server.Addr, err)581 s.Release()582 cluster.syncServers()583 time.Sleep(100 * time.Millisecond)584 continue585 }586 }587 return s, nil588 }589 panic("unreached")590}591func (cluster *mongoCluster) CacheIndex(cacheKey string, exists bool) {592 cluster.Lock()593 if cluster.cachedIndex == nil {594 cluster.cachedIndex = make(map[string]bool)...
server.go
Source:server.go
...7)8// DynamicOpts creates test-friendly options for dynamic client.9func DynamicOpts(s *Server, b *Builder) client.DynamicOpts {10 return client.DynamicOpts{11 AddrFunc: s.AddrFunc(),12 AddrSetFunc: func(_ machine.Addr) {},13 Builder: b,14 DynAddrInterval: 10 * time.Millisecond,15 PingInterval: 50 * time.Millisecond,16 }17}18// TurnOnAddr returns address that "starts" test machine.19func TurnOnAddr() machine.Addr {20 return machine.Addr{21 Network: "on",22 Value: "0",23 UpdatedAt: time.Now(),24 }25}26// TurnOffAddr returns address that "stops" test machine.27func TurnOffAddr() machine.Addr {28 return machine.Addr{29 Network: "off",30 Value: "0",31 UpdatedAt: time.Now(),32 }33}34// Server simulates the real server.35type Server struct {36 mu sync.Mutex37 addr machine.Addr38}39// AddrFunc returns client.DynamicAddrFunc that can be used as addresses source.40func (s *Server) AddrFunc() client.DynamicAddrFunc {41 return func(network string) (machine.Addr, error) {42 s.mu.Lock()43 defer s.mu.Unlock()44 if network == s.addr.Network {45 return s.addr, nil46 }47 return machine.Addr{}, machine.ErrAddrNotFound48 }49}50// TurnOn simulates on-line server.51func (s *Server) TurnOn() {52 s.mu.Lock()53 defer s.mu.Unlock()54 value := s.addr.Value55 if value == "" {56 value = "0" // initial address.57 }58 s.addr = machine.Addr{59 Network: "on",60 Value: value,61 }62}63// TurnOff simulates off-line server.64func (s *Server) TurnOff() {65 s.mu.Lock()66 defer s.mu.Unlock()67 s.addr.Network = "off"68}69// ChangeAddr generates a new address for server.70func (s *Server) ChangeAddr() {71 s.mu.Lock()72 defer s.mu.Unlock()73 s.addr.Value += "0"74}...
server_lookup_test.go
Source:server_lookup_test.go
...4 "testing"5 "github.com/hashicorp/consul/agent/metadata"6 "github.com/hashicorp/raft"7)8type testAddr struct {9 addr string10}11func (ta *testAddr) Network() string {12 return "tcp"13}14func (ta *testAddr) String() string {15 return ta.addr16}17func TestServerLookup(t *testing.T) {18 lookup := NewServerLookup()19 addr := "72.0.0.17:8300"20 id := "1"21 svr := &metadata.Server{ID: id, Addr: &testAddr{addr}}22 lookup.AddServer(svr)23 got, err := lookup.ServerAddr(raft.ServerID(id))24 if err != nil {25 t.Fatalf("Unexpected error:%v", err)26 }27 if string(got) != addr {28 t.Fatalf("Expected %v but got %v", addr, got)29 }30 server := lookup.Server(raft.ServerAddress(addr))31 if server == nil {32 t.Fatalf("Expected lookup to return true")33 }34 if server.Addr.String() != addr {35 t.Fatalf("Expected lookup to return address %v but got %v", addr, server.Addr)36 }37 lookup.RemoveServer(svr)38 got, err = lookup.ServerAddr("1")39 expectedErr := fmt.Errorf("Could not find address for server id 1")40 if expectedErr.Error() != err.Error() {41 t.Fatalf("Unexpected error, got %v wanted %v", err, expectedErr)42 }43 svr2 := &metadata.Server{ID: "2", Addr: &testAddr{"123.4.5.6"}}44 lookup.RemoveServer(svr2)45}...
Addr
Using AI Code Generation
1import (2func main() {3 server, err := net.Listen("tcp", ":8080")4 if err != nil {5 fmt.Println(err)6 }7 defer server.Close()8 fmt.Println(server.Addr())9}
Addr
Using AI Code Generation
1import (2func main() {3 server, err := net.Listen("tcp", ":0")4 if err != nil {5 fmt.Println("Error listening:", err.Error())6 }7 defer server.Close()8 fmt.Println("Listening on " + server.Addr().String())9 for {10 conn, err := server.Accept()11 if err != nil {12 fmt.Println("Error accepting: ", err.Error())13 }14 go doServerStuff(conn)15 }16}17func doServerStuff(conn net.Conn) {18}19import (20func main() {21 conn, err := net.Dial("tcp", "www.google.com:80")22 if err != nil {23 fmt.Println("Error dialing", err.Error())24 }25 defer conn.Close()26 fmt.Println("Local address is " + conn.LocalAddr().String())27 fmt.Println("Remote address is " + conn.RemoteAddr().String())28}29import (30func main() {31 conn, err := net.Dial("tcp", "www.google.com:80")32 if err != nil {33 fmt.Println("Error dialing", err.Error())34 }35 defer conn.Close()36 fmt.Println("Local address is " + conn.LocalAddr().String())37 fmt.Println("Remote address is " + conn.RemoteAddr().String())38}39import (40func main() {41 conn, err := net.Dial("tcp", "www.google.com:80")42 if err != nil {43 fmt.Println("Error dialing", err.Error())44 }45 defer conn.Close()46 fmt.Println("Local address is " + conn.LocalAddr().String())47 fmt.Println("Remote address is " + conn.RemoteAddr().String())48}
Addr
Using AI Code Generation
1func main() {2 server := new(Server)3 client := new(Client)4 client.Connect(server)5 fmt.Println(server.Addr())6}7func main() {8 server := new(Server)9 client := new(Client)10 client.Connect(server)11 fmt.Println(server.Addr())12}13func main() {14 server := new(Server)15 client := new(Client)16 client.Connect(server)17 fmt.Println(server.Addr())18}19func main() {20 server := new(Server)21 client := new(Client)22 client.Connect(server)23 fmt.Println(server.Addr())24}25func main() {26 server := new(Server)27 client := new(Client)28 client.Connect(server)29 fmt.Println(server.Addr())30}31func main() {32 server := new(Server)33 client := new(Client)34 client.Connect(server)35 fmt.Println(server.Addr())36}37func main() {38 server := new(Server)39 client := new(Client)
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Testkube automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
