panic: context deadline exceeded

[nexovec]

Observed behavior

Hi, I am getting this error panic: context deadline exceeded when trying to create a jetstream stream. I am running my services locally in docker compose including the nats server. NATS version is 2.10.3. Here are two different ways I've tried to create a jet stream:

Approach one

taken directly from nats by example limits example.

                natsConn, _ := nats.Connect(natsConnectionString)

		// Drain is a safe way to to ensure all buffered messages that were published
		// are sent and all buffered messages received on a subscription are processed
		// being closing the connection.
		// defer natsConn.Drain()

		// Access `JetStream` which provides methods to create
		// streams and consumers as well as convenience methods for publishing
		// to streams and consuming messages from the streams.
		js, _ := jetstream.New(natsConn)

		// We will declare the initial stream configuration by specifying
		// the name and subjects. Stream names are commonly uppercased to
		// visually differentiate them from subjects, but this is not required.
		// A stream can bind one or more subjects which almost always include
		// wildcards. In addition, no two streams can have overlapping subjects
		// otherwise the primary messages would be persisted twice. There
		// are option to replicate messages in various ways, but that will
		// be explained in later examples.
		cfg := jetstream.StreamConfig{
			Name:     "EVENTS2",
			Subjects: []string{"thing.>"},
		}

		// JetStream provides both file and in-memory storage options. For
		// durability of the stream data, file storage must be chosen to
		// survive crashes and restarts. This is the default for the stream,
		// but we can still set it explicitly.
		cfg.Storage = jetstream.FileStorage

		// JetStream API uses context for timeouts and cancellation.
		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()

		// Finally, let's add/create the stream with the default (no) limits.
		stream, err := js.CreateStream(ctx, cfg)
		if err != nil {
			panic(err.Error())
		}
		fmt.Println("created the stream")
		jsinfo, err := stream.Info(nats.Context(ctx))
		if jsinfo == nil {
			panic("jetstream info is nil")
		}
		if err != nil {
			panic(err.Error())
		}
		fmt.Println(jsinfo)
		// fmt.Println(stream.Info())

Approach 2

		natsConn, err = nats.Connect(
			natsConnectionString,
			nats.RetryOnFailedConnect(true),
			nats.MaxReconnects(10),
			nats.ReconnectWait(time.Second*3),
			nats.DisconnectErrHandler(func(nc *nats.Conn, err error) {
				fmt.Printf("Got disconnected! Reason: %q\n", err)
			}),
			nats.ReconnectHandler(func(nc *nats.Conn) {
				fmt.Printf("Got reconnected to %v!\n", nc.ConnectedUrl())
			}),
			nats.ClosedHandler(func(nc *nats.Conn) {
				fmt.Printf("Connection closed. Reason: %q\n", nc.LastError())
			}))
		if err != nil {
			panic(err)
		}
		jtctx, err = natsConn.JetStream()
		if err != nil {
			panic(err)
		}
		log.Println(jtctx)

		// create a test stream
		config := nats.StreamConfig{
			Name:     "EVENTS",
			Subjects: []string{"events.>"}, // You can specify the subjects you need
			// Retention:  nats.LimitsPolicy,
			// MaxAge:     0,
			// MaxMsgSize: -1,
			Storage: nats.FileStorage,
			// Replicas:   1,
		}

		ctx, _ := context.WithTimeout(context.Background(), time.Second*10)
		stream, err := jtctx.AddStream(&config, nats.Context(ctx))
		if err == nil {
			log.Println(stream)
			return
		}
		panic(err.Error())

NATS config

server_name: "my_mqtt_server"

# Client port of 4222 on all interfaces
port: 4222

# HTTP monitoring port
http_port: 8222

jetstream {
   store_dir: datastore,
   max_mem: 1G,
   max_file: 5G
}

Questions

• What does the error message mean? Does it relate to the go contexts? The same error is there even if I don't provide the ctx.
• What is even the difference between the two approaches? They seem the same to me.
• Can you give me your code snippets in case you do this differently?

Thanks