In testing TokenBucketv2 by sending curl requests from a single machine i found using r.remoteAddr as UID gave a different value everytime as a new port was assigned for each http request. The throttle therefore was not envoked.

To test i truncated r.remote Addr to just IP by removing port:

import strings

replacing r.remoteAddr in the call to throttled with strings.Split(r.RemoteAddr, ":")[0]

Hashicorp RPC Plugin example produces:

[DEBUG] plugin.duck: 2021/06/04 16:18:10 [ERR] plugin: plugin server: accept unix /tmp/pluginXXXXX: use of closed network connection

as per hashicorp/go-plugin#72

Hexarch example fails with panic: sync: negative WaitGroup counter.

Removing extra wg.Done from Write methods of FileTransactionLogger solves the issue:

func (l *FileTransactionLogger) WritePut(key, value string) {
l.wg.Add(1)
l.events <- core.Event{EventType: core.EventPut, Key: key, Value: url.QueryEscape(value)}
// l.wg.Done()
}

func (l *FileTransactionLogger) WriteDelete(key string) {
l.wg.Add(1)
l.events <- core.Event{EventType: core.EventDelete, Key: key}
// l.wg.Done()
}

Just wanted to inquire if anyone else Is having trouble with getting the FileLogger to load an existing log file.

If there is no existing file, I can run the program fine, it creates the log file, and writes to the file.

The problem lies in trying to run the program again, in which it hangs.

I've traced the problem to getting stuck the the Restore() function's for loop:

	for ok && err == nil {
		select {
		case err, ok = <-errors:
		case e, ok = <-events:
			switch e.EventType {
			case EventDelete:
				err = store.Delete(e.Key)
				count++
			case EventPut:
				err = store.Put(e.Key, e.Value)
				count++
			}
		}
	}

It's driving me crazy, wanted to see if anyone else had similar issues, or any idea on how to properly debug the issue.

func NewTestTransactionLogger() (core.TransactionLogger, error) { return TestTransactionLogger{}, nil}

Should return &TestTransactionLogger{}, nil

The README's four week's old, so it may be cleaned up now, but I'm willing to help if you're interested.

I think it's great to leave things up to the reader to implement themselves, but there's discrepancies with the code in the book and what you have in the GitHub repo, and it's kind of frustration. (Ch. 5)

Excellent book, there is just a simple miscommunication that I wanted to address.

In chapter 5, section Generation 1: The Monolith, page 117:

The URI for your key-value pair resources will have the form /v1/key/{key}, where {key} is the unique key string

In following pages, we also have:

• It must only match PUT requests for /v1/key/{key}
• It must only match GET requests for /v1/key/{key}

However, in the code sample provided on page 120, we are given:

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/v1/{key}", keyValuePutHandler).Methods("PUT")
    r.HandleFunc("/v1/{key}", keyValueGetHandler).Methods("GET")
    log.Fatal(http.ListenAndServe(":8080", r))
}

This is inconsistent, since the code sample will match PUT/GET requests for v1/{key}, and requests to a /v1/key/{key} path will result in a 404 error being raised without a clear indication of what the user is doing wrong.

I understand that this is difficult to fix in the print of the book, but I am suggesting that a note of this should be made in the chapter 5 `README.md

Shouldn't the DeleteRequest return a DeleteResponse? Seems correct in the book, or is it ok either way because both responses are an empty struct?

However, when looking at the generated keyvalue_grpc.pb.gofile on page 236 Delete does return a *PutResponse, aligned with the repo., so is this a typo in the book?

In case when ctx that passed to Effector canceled by timeout before refill ticker fires - possible lost token. Here is example:

func TestRefill(t *testing.T) {
	const max uint = 1
	const refillDuration = time.Second

	callsCounter := 0
	effector := callsCountFunction(&callsCounter)

	// Any context with cancellation (WithTimeout, etc)
	ctx, cancel := context.WithCancel(context.Background())
	throttle := Throttle(effector, max, max, refillDuration)

	_, err := throttle(ctx)
	if err != nil {
		t.Fatal("unexpected error: ", err)
	}
	if callsCounter != 1 {
		t.Fatal("unexpected callsCounter value: ", callsCounter)
	}
	// Request cancelled by timeout before refillDuration. (If comment this line – test will be success)
	cancel()

	// Waiting token refill . x2 for ensure that token refiled
	time.Sleep(refillDuration * 2)

	ctx, cancel = context.WithCancel(context.Background())
	defer cancel()

	_, err = throttle(ctx)
	if err != nil {
		t.Fatal("unexpected error: ", err)
	}
	if callsCounter != 2 {
		t.Fatal("unexpected callsCounter value: ", callsCounter)
	}
}