This all depends on the actual implementation used, but I’m basing this on the standard Go as well as gccgo. Slices Reslicing means changing an integer in a struct (a slice is a struct with three fields: length, capacity and pointer to backing memory). If the slice does not have sufficient capacity, append will need … Read more
The following works for me; package main import ( “archive/tar” “bytes” “context” “io” “io/ioutil” “log” “os” “github.com/docker/docker/api/types” “github.com/docker/docker/client” ) func main() { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { log.Fatal(err, ” :unable to init client”) } buf := new(bytes.Buffer) tw := tar.NewWriter(buf) defer tw.Close() dockerFile := “myDockerfile” dockerFileReader, err := … Read more
The accepted answer has a wrong suggestion: func sendRegularHeartbeats(ctx context.Context) { ticker := time.NewTicker(time.Second) defer ticker.Stop() for { //first select select { case <-ctx.Done(): return default: } //second select select { case <-ctx.Done(): return case <-ticker.C: sendHeartbeat() } } } This doesn’t help, because of the following scenario: both channels are empty first select runs … Read more
“Are you guaranteed that B will read data In the same order that A put it into the channel?” Yes. The order of data is guaranteed. But the delivery is guaranteed only for unbuffered channels, not buffered. (see second section of this answer) You can see the idea of channels illustrated in “The Nature Of … Read more
An import of a path containing the element “internal” disallowed if the importing code is outside the tree rooted at the parent of the “internal” directory. There is no mechanism for exceptions. In particular, by design, there is no ACL mechanism for allowing a whitelist of other packages to use an internal package. Proposal for … Read more
Beside any and interface{} being type aliases — hence, equivalent in usage —, there is a practical difference between any as type parameter and any as regular function argument, as in your example. The difference is that in printAny[T any](foo T) the type of foo is not any/interface{}, but it’s T. And T after instantiation … Read more
Below is an example of JWT decoding and verification. It uses both the jwt-go and jwk packages: package main import ( “errors” “fmt” “github.com/dgrijalva/jwt-go” “github.com/lestrrat-go/jwx/jwk” ) const token = `eyJhbGciOiJSUzI1NiIsImtpZCI6Ind5TXdLNEE2Q0w5UXcxMXVvZlZleVExMTlYeVgteHlreW1ra1h5Z1o1T00ifQ.eyJzdWIiOiIwMHUxOGVlaHUzNDlhUzJ5WDFkOCIsIm5hbWUiOiJva3RhcHJveHkgb2t0YXByb3h5IiwidmVyIjoxLCJpc3MiOiJodHRwczovL2NvbXBhbnl4Lm9rdGEuY29tIiwiYXVkIjoidlpWNkNwOHJuNWx4ck45YVo2ODgiLCJpYXQiOjE0ODEzODg0NTMsImV4cCI6MTQ4MTM5MjA1MywianRpIjoiSUQuWm9QdVdIR3IxNkR6a3RUbEdXMFI4b1lRaUhnVWg0aUotTHo3Z3BGcGItUSIsImFtciI6WyJwd2QiXSwiaWRwIjoiMDBveTc0YzBnd0hOWE1SSkJGUkkiLCJub25jZSI6Im4tMFM2X1d6QTJNaiIsInByZWZlcnJlZF91c2VybmFtZSI6Im9rdGFwcm94eUBva3RhLmNvbSIsImF1dGhfdGltZSI6MTQ4MTM4ODQ0MywiYXRfaGFzaCI6Im1YWlQtZjJJczhOQklIcV9CeE1ISFEifQ.OtVyCK0sE6Cuclg9VMD2AwLhqEyq2nv3a1bfxlzeS-bdu9KtYxcPSxJ6vxMcSSbMIIq9eEz9JFMU80zqgDPHBCjlOsC5SIPz7mm1Z3gCwq4zsFJ-2NIzYxA3p161ZRsPv_3bUyg9B_DPFyBoihgwWm6yrvrb4rmHXrDkjxpxCLPp3OeIpc_kb2t8r5HEQ5UBZPrsiScvuoVW13YwWpze59qBl_84n9xdmQ5pS7DklzkAVgqJT_NWBlb5uo6eW26HtJwHzss7xOIdQtcOtC1Gj3O82a55VJSQnsEEBeqG1ESb5Haq_hJgxYQnBssKydPCIxdZiye-0Ll9L8wWwpzwig` const jwksURL = `https://companyx.okta.com/oauth2/v1/keys` func getKey(token *jwt.Token) (interface{}, error) { // TODO: cache response so we don’t have to make a request every time // … Read more
What you’re experiencing is commonly known as “variable shadowing”. When you use := with any variable in an inner scope, including in statements like if and for despite the lack of braces, a new value and type are associated with that variable: n := “Example” //Prints the string variable `n` to standard output and // … Read more
To call a method on an object, first use reflect.ValueOf. Then find the method by name, and then finally call the found method. For example: package main import “fmt” import “reflect” type T struct {} func (t *T) Foo() { fmt.Println(“foo”) } func main() { var t T reflect.ValueOf(&t).MethodByName(“Foo”).Call([]reflect.Value{}) }
You should build an executable for your program (go build) and then either write a script for upstart and it will run your program as a daemon for you, or use an external tool like daemonize. I prefer the latter solution, because it does not depend on a system-dependent upstart. With daemonize you can start … Read more