GitBook: [master] 82 pages modified

developing-with-nats/events/README.md

@@ -9,19 +9,19 @@ For example, the client library may provide a mechanism to get the connection's
 ```go
 nc, err := nats.Connect("demo.nats.io", nats.Name("API Example"))
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 defer nc.Close()
 
 getStatusTxt := func(nc *nats.Conn) string {
-	switch nc.Status() {
-	case nats.CONNECTED:
-		return "Connected"
-	case nats.CLOSED:
-		return "Closed"
-	default:
-		return "Other"
-	}
+    switch nc.Status() {
+    case nats.CONNECTED:
+        return "Connected"
+    case nats.CLOSED:
+        return "Closed"
+    default:
+        return "Other"
+    }
 }
 log.Printf("The connection is %v\n", getStatusTxt(nc))
 

developing-with-nats/events/events.md

@@ -166,12 +166,12 @@ When working with a cluster, servers may be added or changed. Some of the client
 // Be notified if a new server joins the cluster.
 // Print all the known servers and the only the ones that were discovered.
 nc, err := nats.Connect("demo.nats.io",
-	nats.DiscoveredServersHandler(func(nc *nats.Conn) {
-		log.Printf("Known servers: %v\n", nc.Servers())
-		log.Printf("Discovered servers: %v\n", nc.DiscoveredServers())
-	}))
+    nats.DiscoveredServersHandler(func(nc *nats.Conn) {
+        log.Printf("Known servers: %v\n", nc.Servers())
+        log.Printf("Discovered servers: %v\n", nc.DiscoveredServers())
+    }))
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 defer nc.Close()
 
@@ -251,11 +251,11 @@ The client library may separate server-to-client errors from events. Many server
 ```go
 // Set the callback that will be invoked when an asynchronous error occurs.
 nc, err := nats.Connect("demo.nats.io",
-	nats.ErrorHandler(func(_ *nats.Conn, _ *nats.Subscription, err error) {
-		log.Printf("Error: %v", err)
-	}))
+    nats.ErrorHandler(func(_ *nats.Conn, _ *nats.Subscription, err error) {
+        log.Printf("Error: %v", err)
+    }))
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 defer nc.Close()
 

developing-with-nats/events/slow.md

@@ -25,14 +25,14 @@ The first way that the incoming queue can be limited is by message count. The se
 ```go
 nc, err := nats.Connect("demo.nats.io")
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 defer nc.Close()
 
 // Subscribe
 sub1, err := nc.Subscribe("updates", func(m *nats.Msg) {})
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 
 // Set limits of 1000 messages or 5MB, whichever comes first
@@ -41,7 +41,7 @@ sub1.SetPendingLimits(1000, 5*1024*1024)
 // Subscribe
 sub2, err := nc.Subscribe("updates", func(m *nats.Msg) {})
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 
 // Set no limits for this subscription
@@ -124,7 +124,7 @@ Some libraries, like Java, will not send this notification on every dropped mess
 // Set the callback that will be invoked when an asynchronous error occurs.
 nc, err := nats.Connect("demo.nats.io", nats.ErrorHandler(logSlowConsumer))
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 defer nc.Close()
 
@@ -173,13 +173,11 @@ public class SlowConsumerListener {
 {% tab title="JavaScript" %}
 ```javascript
 // slow consumer detection is not configurable on NATS JavaScript client.
-
 ```
 {% endtab %}
 
 {% tab title="Python" %}
 ```python
-
    nc = NATS()
 
    async def error_cb(e):
@@ -202,7 +200,7 @@ public class SlowConsumerListener {
 
        if len(msgs) == 3:
          # Head of line blocking on other messages caused
-	 # by single message proccesing taking long...
+     # by single message proccesing taking long...
          await asyncio.sleep(1)
 
    await nc.subscribe("updates", cb=cb, pending_msgs_limit=5)
@@ -235,3 +233,4 @@ public class SlowConsumerListener {
 ```
 {% endtab %}
 {% endtabs %}
+