Merge pull request #124673 from richardpark-msft/ripark-fix-eventhubs-sample

Event Hubs sample: Fixing some syntax/compile time errors.

Author: ShannonLeavitt

articles/event-hubs/event-hubs-go-get-started-send.md

@@ -49,47 +49,58 @@ Here's the code to send events to an event hub. The main steps in the code are:
 package main
 
 import (
-    "context"
+	"context"
 
-    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
 )
 
 func main() {
+	// create an Event Hubs producer client using a connection string to the namespace and the event hub
+	producerClient, err := azeventhubs.NewProducerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", nil)
 
-    // create an Event Hubs producer client using a connection string to the namespace and the event hub
-    producerClient, err := azeventhubs.NewProducerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", nil)
+	if err != nil {
+		panic(err)
+	}
 
-    if err != nil {
-        panic(err)
-    }
+	defer producerClient.Close(context.TODO())
 
-    defer producerClient.Close(context.TODO())
+	// create sample events
+	events := createEventsForSample()
 
-    // create sample events
-    events := createEventsForSample()
+	// create a batch object and add sample events to the batch
+	newBatchOptions := &azeventhubs.EventDataBatchOptions{}
 
-    // create a batch object and add sample events to the batch
-    newBatchOptions := &azeventhubs.EventDataBatchOptions{}
+	batch, err := producerClient.NewEventDataBatch(context.TODO(), newBatchOptions)
 
-    batch, err := producerClient.NewEventDataBatch(context.TODO(), newBatchOptions)
+	if err != nil {
+		panic(err)
+	}
 
-    for i := 0; i < len(events); i++ {
-        err = batch.AddEventData(events[i], nil)
-    }
+	for i := 0; i < len(events); i++ {
+		err = batch.AddEventData(events[i], nil)
 
-    // send the batch of events to the event hub
-    producerClient.SendEventDataBatch(context.TODO(), batch, nil)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	// send the batch of events to the event hub
+	err = producerClient.SendEventDataBatch(context.TODO(), batch, nil)
+
+	if err != nil {
+		panic(err)
+	}
 }
 
 func createEventsForSample() []*azeventhubs.EventData {
-    return []*azeventhubs.EventData{
-        {
-            Body: []byte("hello"),
-        },
-        {
-            Body: []byte("world"),
-        },
-    }
+	return []*azeventhubs.EventData{
+		{
+			Body: []byte("hello"),
+		},
+		{
+			Body: []byte("world"),
+		},
+	}
 }
 ```
 
@@ -134,101 +145,104 @@ Here's the code to receive events from an event hub. The main steps in the code
 package main
 
 import (
-    "context"
-    "errors"
-    "fmt"
-    "time"
-
-    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
-    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/checkpoints"
-    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container"
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/checkpoints"
+	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container"
 )
 
 func main() {
 
-    // create a container client using a connection string and container name
-    checkClient, err := container.NewClientFromConnectionString("AZURE STORAGE CONNECTION STRING", "CONTAINER NAME", nil)
-    
-    // create a checkpoint store that will be used by the event hub
-    checkpointStore, err := checkpoints.NewBlobStore(checkClient, nil)
+	// create a container client using a connection string and container name
+	checkClient, err := container.NewClientFromConnectionString("AZURE STORAGE CONNECTION STRING", "CONTAINER NAME", nil)
+
+	if err != nil {
+		panic(err)
+	}
 
-    if err != nil {
-        panic(err)
-    }
+	// create a checkpoint store that will be used by the event hub
+	checkpointStore, err := checkpoints.NewBlobStore(checkClient, nil)
 
-    // create a consumer client using a connection string to the namespace and the event hub
-    consumerClient, err := azeventhubs.NewConsumerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", azeventhubs.DefaultConsumerGroup, nil)
+	if err != nil {
+		panic(err)
+	}
 
-    if err != nil {
-        panic(err)
-    }
+	// create a consumer client using a connection string to the namespace and the event hub
+	consumerClient, err := azeventhubs.NewConsumerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", azeventhubs.DefaultConsumerGroup, nil)
 
-    defer consumerClient.Close(context.TODO())
+	if err != nil {
+		panic(err)
+	}
 
-    // create a processor to receive and process events
-    processor, err := azeventhubs.NewProcessor(consumerClient, checkpointStore, nil)
+	defer consumerClient.Close(context.TODO())
 
-    if err != nil {
-        panic(err)
-    }
+	// create a processor to receive and process events
+	processor, err := azeventhubs.NewProcessor(consumerClient, checkpointStore, nil)
 
-    //  for each partition in the event hub, create a partition client with processEvents as the function to process events
-    dispatchPartitionClients := func() {
-        for {
-            partitionClient := processor.NextPartitionClient(context.TODO())
+	if err != nil {
+		panic(err)
+	}
 
-            if partitionClient == nil {
-                break
-            }
+	//  for each partition in the event hub, create a partition client with processEvents as the function to process events
+	dispatchPartitionClients := func() {
+		for {
+			partitionClient := processor.NextPartitionClient(context.TODO())
 
-            go func() {
-                if err := processEvents(partitionClient); err != nil {
-                    panic(err)
-                }
-            }()
-        }
-    }
+			if partitionClient == nil {
+				break
+			}
 
-    // run all partition clients
-    go dispatchPartitionClients()
+			go func() {
+				if err := processEvents(partitionClient); err != nil {
+					panic(err)
+				}
+			}()
+		}
+	}
 
-    processorCtx, processorCancel := context.WithCancel(context.TODO())
-    defer processorCancel()
+	// run all partition clients
+	go dispatchPartitionClients()
 
-    if err := processor.Run(processorCtx); err != nil {
-        panic(err)
-    }
+	processorCtx, processorCancel := context.WithCancel(context.TODO())
+	defer processorCancel()
+
+	if err := processor.Run(processorCtx); err != nil {
+		panic(err)
+	}
 }
 
 func processEvents(partitionClient *azeventhubs.ProcessorPartitionClient) error {
-    defer closePartitionResources(partitionClient)
-    for {
-        receiveCtx, receiveCtxCancel := context.WithTimeout(context.TODO(), time.Minute)
-        events, err := partitionClient.ReceiveEvents(receiveCtx, 100, nil)
-        receiveCtxCancel()
-
-        if err != nil && !errors.Is(err, context.DeadlineExceeded) {
-            return err
-        }
-
-        fmt.Printf("Processing %d event(s)\n", len(events))
-
-        for _, event := range events {
-            fmt.Printf("Event received with body %v\n", string(event.Body))
-        }
-
-        if len(events) != 0 {
-            if err := partitionClient.UpdateCheckpoint(context.TODO(), events[len(events)-1]); err != nil {
-                return err
-            }
-        }
-    }
+	defer closePartitionResources(partitionClient)
+	for {
+		receiveCtx, receiveCtxCancel := context.WithTimeout(context.TODO(), time.Minute)
+		events, err := partitionClient.ReceiveEvents(receiveCtx, 100, nil)
+		receiveCtxCancel()
+
+		if err != nil && !errors.Is(err, context.DeadlineExceeded) {
+			return err
+		}
+
+		fmt.Printf("Processing %d event(s)\n", len(events))
+
+		for _, event := range events {
+			fmt.Printf("Event received with body %v\n", string(event.Body))
+		}
+
+		if len(events) != 0 {
+			if err := partitionClient.UpdateCheckpoint(context.TODO(), events[len(events)-1], nil); err != nil {
+				return err
+			}
+		}
+	}
 }
 
 func closePartitionResources(partitionClient *azeventhubs.ProcessorPartitionClient) {
-    defer partitionClient.Close(context.TODO())
+	defer partitionClient.Close(context.TODO())
 }
-
 ```
 
 ## Run receiver and sender apps