+22

cmd/patreon-saasproxy/main.go

reviewed

··· 1 1 package main 2 2 3 3 import ( 4 4 + "context" 4 5 "encoding/base64" 5 6 "encoding/json" 6 7 "expvar" ··· 14 15 "github.com/facebookgo/flagenv" 15 16 _ "github.com/joho/godotenv/autoload" 16 17 "golang.org/x/oauth2" 18 18 + "google.golang.org/protobuf/types/known/emptypb" 19 19 + "google.golang.org/protobuf/types/known/timestamppb" 17 20 "gopkg.in/mxpv/patreon-go.v1" 18 21 "tailscale.com/client/tailscale" 19 22 "tailscale.com/hostinfo" ··· 21 24 "tailscale.com/tsnet" 22 25 "tailscale.com/tsweb" 23 26 "xeiaso.net/v4/internal" 27 27 + "xeiaso.net/v4/internal/adminpb" 24 28 ) 25 29 26 30 var ( ··· 110 114 log.Fatal(err) 111 115 } 112 116 117 117 + ph := adminpb.NewPatreonServer(s) 118 118 + http.Handle(adminpb.PatreonPathPrefix, ph) 119 119 + 113 120 slog.Info("listening over tailscale", "hostname", *tailscaleHostname) 114 121 115 122 log.Fatal(http.Serve(ln, nil)) ··· 118 125 type Server struct { 119 126 lc *tailscale.LocalClient 120 127 cts oauth2.TokenSource 128 128 + } 129 129 + 130 130 + func (s *Server) GetToken(ctx context.Context, _ *emptypb.Empty) (*adminpb.PatreonToken, error) { 131 131 + token, err := s.cts.Token() 132 132 + if err != nil { 133 133 + slog.Error("token fetch failed", "err", err) 134 134 + return nil, err 135 135 + } 136 136 + 137 137 + return &adminpb.PatreonToken{ 138 138 + AccessToken: token.AccessToken, 139 139 + TokenType: token.TokenType, 140 140 + RefreshToken: token.RefreshToken, 141 141 + Expiry: timestamppb.New(token.Expiry), 142 142 + }, nil 121 143 } 122 144 123 145 func (s *Server) GiveToken(w http.ResponseWriter, r *http.Request) {

+4

flake.nix

reviewed

··· 192 192 zig 193 193 nodejs 194 194 195 195 + protobuf 196 196 + protoc-gen-go 197 197 + protoc-gen-twirp 198 198 + 195 199 jq 196 200 jo 197 201

+3 -2

go.mod

reviewed

··· 6 6 github.com/bep/debounce v1.2.1 7 7 github.com/donatj/hmacsig v1.1.0 8 8 github.com/facebookgo/flagenv v0.0.0-20160425205200-fcd59fca7456 9 9 + github.com/go-faker/faker/v4 v4.2.0 9 10 github.com/go-git/go-git/v5 v5.10.0 10 11 github.com/joho/godotenv v1.5.1 12 12 + github.com/twitchtv/twirp v8.1.3+incompatible 11 13 golang.org/x/oauth2 v0.12.0 14 14 + google.golang.org/protobuf v1.31.0 12 15 gopkg.in/fsnotify.v1 v1.4.7 13 16 gopkg.in/mxpv/patreon-go.v1 v1.0.0-20171031001022-1d2f253ac700 14 17 tailscale.com v1.58.2 ··· 48 51 github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c // indirect 49 52 github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 // indirect 50 53 github.com/fxamacker/cbor/v2 v2.5.0 // indirect 51 51 - github.com/go-faker/faker/v4 v4.2.0 // indirect 52 54 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect 53 55 github.com/go-git/go-billy/v5 v5.5.0 // indirect 54 56 github.com/go-ole/go-ole v1.3.0 // indirect ··· 117 119 golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 // indirect 118 120 golang.zx2c4.com/wireguard/windows v0.5.3 // indirect 119 121 google.golang.org/appengine v1.6.8 // indirect 120 120 - google.golang.org/protobuf v1.31.0 // indirect 121 122 gopkg.in/warnings.v0 v0.1.2 // indirect 122 123 gvisor.dev/gvisor v0.0.0-20230928000133-4fe30062272c // indirect 123 124 inet.af/peercred v0.0.0-20210906144145-0893ea02156a // indirect

+2

go.sum

reviewed

··· 276 276 github.com/tailscale/wireguard-go v0.0.0-20231121184858-cc193a0b3272/go.mod h1:BOm5fXUBFM+m9woLNBoxI9TaBXXhGNP50LX/TGIvGb4= 277 277 github.com/tcnksm/go-httpstat v0.2.0 h1:rP7T5e5U2HfmOBmZzGgGZjBQ5/GluWUylujl0tJ04I0= 278 278 github.com/tcnksm/go-httpstat v0.2.0/go.mod h1:s3JVJFtQxtBEBC9dwcdTTXS9xFnM3SXAZwPG41aurT8= 279 279 + github.com/twitchtv/twirp v8.1.3+incompatible h1:+F4TdErPgSUbMZMwp13Q/KgDVuI7HJXP61mNV3/7iuU= 280 280 + github.com/twitchtv/twirp v8.1.3+incompatible/go.mod h1:RRJoFSAmTEh2weEqWtpPE3vFK5YBhA6bqp2l1kfCC5A= 279 281 github.com/u-root/u-root v0.11.0 h1:6gCZLOeRyevw7gbTwMj3fKxnr9+yHFlgF3N7udUVNO8= 280 282 github.com/u-root/u-root v0.11.0/go.mod h1:DBkDtiZyONk9hzVEdB/PWI9B4TxDkElWlVTHseglrZY= 281 283 github.com/u-root/uio v0.0.0-20230305220412-3e8cd9d6bf63 h1:YcojQL98T/OO+rybuzn2+5KrD5dBwXIvYBvQ2cD3Avg=

+3

gomod2nix.toml

reviewed

··· 259 259 [mod."github.com/tcnksm/go-httpstat"] 260 260 version = "v0.2.0" 261 261 hash = "sha256-bCWn8E+DcZY6+yPu07AF3hCcDZx3CFdD74qfpDIgVqI=" 262 262 + [mod."github.com/twitchtv/twirp"] 263 263 + version = "v8.1.3+incompatible" 264 264 + hash = "sha256-j1h9YE3wl9h36DfPf92To1H/PwNk4CgerOARNO3HK1w=" 262 265 [mod."github.com/u-root/uio"] 263 266 version = "v0.0.0-20230305220412-3e8cd9d6bf63" 264 267 hash = "sha256-y0VT9PLROozi6wNMgnX706ifumQxlMc8y4/XZDhdfMY="

+5

internal/adminpb/generate.go

reviewed

··· 1 1 + package adminpb 2 2 + 3 3 + func init() {} 4 4 + 5 5 + //go:generate protoc --proto_path=. --proto_path=../../pb --go_out=. --go_opt=paths=source_relative --twirp_out=. --twirp_opt=paths=source_relative internal.proto

+201

internal/adminpb/internal.pb.go

reviewed

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.32.0 4 4 + // protoc v4.24.4 5 5 + // source: internal.proto 6 6 + 7 7 + package adminpb 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + emptypb "google.golang.org/protobuf/types/known/emptypb" 13 13 + timestamppb "google.golang.org/protobuf/types/known/timestamppb" 14 14 + reflect "reflect" 15 15 + sync "sync" 16 16 + pb "xeiaso.net/v4/pb" 17 17 + ) 18 18 + 19 19 + const ( 20 20 + // Verify that this generated code is sufficiently up-to-date. 21 21 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 22 22 + // Verify that runtime/protoimpl is sufficiently up-to-date. 23 23 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 24 24 + ) 25 25 + 26 26 + type PatreonToken struct { 27 27 + state protoimpl.MessageState 28 28 + sizeCache protoimpl.SizeCache 29 29 + unknownFields protoimpl.UnknownFields 30 30 + 31 31 + AccessToken string `protobuf:"bytes,1,opt,name=access_token,json=accessToken,proto3" json:"access_token,omitempty"` 32 32 + TokenType string `protobuf:"bytes,2,opt,name=token_type,json=tokenType,proto3" json:"token_type,omitempty"` 33 33 + RefreshToken string `protobuf:"bytes,3,opt,name=refresh_token,json=refreshToken,proto3" json:"refresh_token,omitempty"` 34 34 + Expiry *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=expiry,proto3" json:"expiry,omitempty"` 35 35 + } 36 36 + 37 37 + func (x *PatreonToken) Reset() { 38 38 + *x = PatreonToken{} 39 39 + if protoimpl.UnsafeEnabled { 40 40 + mi := &file_internal_proto_msgTypes[0] 41 41 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 42 42 + ms.StoreMessageInfo(mi) 43 43 + } 44 44 + } 45 45 + 46 46 + func (x *PatreonToken) String() string { 47 47 + return protoimpl.X.MessageStringOf(x) 48 48 + } 49 49 + 50 50 + func (*PatreonToken) ProtoMessage() {} 51 51 + 52 52 + func (x *PatreonToken) ProtoReflect() protoreflect.Message { 53 53 + mi := &file_internal_proto_msgTypes[0] 54 54 + if protoimpl.UnsafeEnabled && x != nil { 55 55 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 56 56 + if ms.LoadMessageInfo() == nil { 57 57 + ms.StoreMessageInfo(mi) 58 58 + } 59 59 + return ms 60 60 + } 61 61 + return mi.MessageOf(x) 62 62 + } 63 63 + 64 64 + // Deprecated: Use PatreonToken.ProtoReflect.Descriptor instead. 65 65 + func (*PatreonToken) Descriptor() ([]byte, []int) { 66 66 + return file_internal_proto_rawDescGZIP(), []int{0} 67 67 + } 68 68 + 69 69 + func (x *PatreonToken) GetAccessToken() string { 70 70 + if x != nil { 71 71 + return x.AccessToken 72 72 + } 73 73 + return "" 74 74 + } 75 75 + 76 76 + func (x *PatreonToken) GetTokenType() string { 77 77 + if x != nil { 78 78 + return x.TokenType 79 79 + } 80 80 + return "" 81 81 + } 82 82 + 83 83 + func (x *PatreonToken) GetRefreshToken() string { 84 84 + if x != nil { 85 85 + return x.RefreshToken 86 86 + } 87 87 + return "" 88 88 + } 89 89 + 90 90 + func (x *PatreonToken) GetExpiry() *timestamppb.Timestamp { 91 91 + if x != nil { 92 92 + return x.Expiry 93 93 + } 94 94 + return nil 95 95 + } 96 96 + 97 97 + var File_internal_proto protoreflect.FileDescriptor 98 98 + 99 99 + var file_internal_proto_rawDesc = []byte{ 100 100 + 0x0a, 0x0e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 101 101 + 0x12, 0x13, 0x78, 0x65, 0x69, 0x61, 0x73, 0x6f, 0x2e, 0x6e, 0x65, 0x74, 0x2e, 0x69, 0x6e, 0x74, 102 102 + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 103 103 + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 104 104 + 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 105 105 + 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 106 106 + 0x6f, 0x74, 0x6f, 0x1a, 0x0c, 0x78, 0x65, 0x73, 0x69, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 107 107 + 0x6f, 0x22, 0xa9, 0x01, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x72, 0x65, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 108 108 + 0x65, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x6f, 0x6b, 109 109 + 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 110 110 + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x74, 111 111 + 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 112 112 + 0x54, 0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x5f, 113 113 + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x66, 114 114 + 0x72, 0x65, 0x73, 0x68, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x32, 0x0a, 0x06, 0x65, 0x78, 0x70, 115 115 + 0x69, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 116 116 + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 117 117 + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x32, 0x50, 0x0a, 118 118 + 0x07, 0x50, 0x61, 0x74, 0x72, 0x65, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x54, 119 119 + 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 120 120 + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x21, 0x2e, 0x78, 121 121 + 0x65, 0x69, 0x61, 0x73, 0x6f, 0x2e, 0x6e, 0x65, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 122 122 + 0x61, 0x6c, 0x2e, 0x50, 0x61, 0x74, 0x72, 0x65, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x32, 123 123 + 0x41, 0x0a, 0x05, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x12, 0x38, 0x0a, 0x07, 0x52, 0x65, 0x62, 0x75, 124 124 + 0x69, 0x6c, 0x64, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 125 125 + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x15, 0x2e, 0x78, 0x65, 126 126 + 0x69, 0x61, 0x73, 0x6f, 0x2e, 0x6e, 0x65, 0x74, 0x2e, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x6e, 127 127 + 0x66, 0x6f, 0x42, 0x20, 0x5a, 0x1e, 0x78, 0x65, 0x69, 0x61, 0x73, 0x6f, 0x2e, 0x6e, 0x65, 0x74, 128 128 + 0x2f, 0x76, 0x34, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x61, 0x64, 0x6d, 129 129 + 0x69, 0x6e, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 130 130 + } 131 131 + 132 132 + var ( 133 133 + file_internal_proto_rawDescOnce sync.Once 134 134 + file_internal_proto_rawDescData = file_internal_proto_rawDesc 135 135 + ) 136 136 + 137 137 + func file_internal_proto_rawDescGZIP() []byte { 138 138 + file_internal_proto_rawDescOnce.Do(func() { 139 139 + file_internal_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_proto_rawDescData) 140 140 + }) 141 141 + return file_internal_proto_rawDescData 142 142 + } 143 143 + 144 144 + var file_internal_proto_msgTypes = make([]protoimpl.MessageInfo, 1) 145 145 + var file_internal_proto_goTypes = []interface{}{ 146 146 + (*PatreonToken)(nil), // 0: xeiaso.net.internal.PatreonToken 147 147 + (*timestamppb.Timestamp)(nil), // 1: google.protobuf.Timestamp 148 148 + (*emptypb.Empty)(nil), // 2: google.protobuf.Empty 149 149 + (*pb.BuildInfo)(nil), // 3: xeiaso.net.BuildInfo 150 150 + } 151 151 + var file_internal_proto_depIdxs = []int32{ 152 152 + 1, // 0: xeiaso.net.internal.PatreonToken.expiry:type_name -> google.protobuf.Timestamp 153 153 + 2, // 1: xeiaso.net.internal.Patreon.GetToken:input_type -> google.protobuf.Empty 154 154 + 2, // 2: xeiaso.net.internal.Admin.Rebuild:input_type -> google.protobuf.Empty 155 155 + 0, // 3: xeiaso.net.internal.Patreon.GetToken:output_type -> xeiaso.net.internal.PatreonToken 156 156 + 3, // 4: xeiaso.net.internal.Admin.Rebuild:output_type -> xeiaso.net.BuildInfo 157 157 + 3, // [3:5] is the sub-list for method output_type 158 158 + 1, // [1:3] is the sub-list for method input_type 159 159 + 1, // [1:1] is the sub-list for extension type_name 160 160 + 1, // [1:1] is the sub-list for extension extendee 161 161 + 0, // [0:1] is the sub-list for field type_name 162 162 + } 163 163 + 164 164 + func init() { file_internal_proto_init() } 165 165 + func file_internal_proto_init() { 166 166 + if File_internal_proto != nil { 167 167 + return 168 168 + } 169 169 + if !protoimpl.UnsafeEnabled { 170 170 + file_internal_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 171 171 + switch v := v.(*PatreonToken); i { 172 172 + case 0: 173 173 + return &v.state 174 174 + case 1: 175 175 + return &v.sizeCache 176 176 + case 2: 177 177 + return &v.unknownFields 178 178 + default: 179 179 + return nil 180 180 + } 181 181 + } 182 182 + } 183 183 + type x struct{} 184 184 + out := protoimpl.TypeBuilder{ 185 185 + File: protoimpl.DescBuilder{ 186 186 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 187 187 + RawDescriptor: file_internal_proto_rawDesc, 188 188 + NumEnums: 0, 189 189 + NumMessages: 1, 190 190 + NumExtensions: 0, 191 191 + NumServices: 2, 192 192 + }, 193 193 + GoTypes: file_internal_proto_goTypes, 194 194 + DependencyIndexes: file_internal_proto_depIdxs, 195 195 + MessageInfos: file_internal_proto_msgTypes, 196 196 + }.Build() 197 197 + File_internal_proto = out.File 198 198 + file_internal_proto_rawDesc = nil 199 199 + file_internal_proto_goTypes = nil 200 200 + file_internal_proto_depIdxs = nil 201 201 + }

+22

internal/adminpb/internal.proto

reviewed

··· 1 1 + syntax = "proto3"; 2 2 + package xeiaso.net.internal.admin; 3 3 + option go_package = "xeiaso.net/v4/internal/adminpb"; 4 4 + 5 5 + import "google/protobuf/empty.proto"; 6 6 + import "google/protobuf/timestamp.proto"; 7 7 + import "xesite.proto"; 8 8 + 9 9 + service Patreon { 10 10 + rpc GetToken (google.protobuf.Empty) returns (PatreonToken); 11 11 + } 12 12 + 13 13 + message PatreonToken { 14 14 + string access_token = 1; 15 15 + string token_type = 2; 16 16 + string refresh_token = 3; 17 17 + google.protobuf.Timestamp expiry = 4; 18 18 + } 19 19 + 20 20 + service Admin { 21 21 + rpc Rebuild(google.protobuf.Empty) returns (xeiaso.net.BuildInfo); 22 22 + }

+1607

internal/adminpb/internal.twirp.go

reviewed

··· 1 1 + // Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT. 2 2 + // source: internal.proto 3 3 + 4 4 + package adminpb 5 5 + 6 6 + import context "context" 7 7 + import fmt "fmt" 8 8 + import http "net/http" 9 9 + import io "io" 10 10 + import json "encoding/json" 11 11 + import strconv "strconv" 12 12 + import strings "strings" 13 13 + 14 14 + import protojson "google.golang.org/protobuf/encoding/protojson" 15 15 + import proto "google.golang.org/protobuf/proto" 16 16 + import twirp "github.com/twitchtv/twirp" 17 17 + import ctxsetters "github.com/twitchtv/twirp/ctxsetters" 18 18 + 19 19 + import google_protobuf "google.golang.org/protobuf/types/known/emptypb" 20 20 + import xeiaso_net "xeiaso.net/v4/pb" 21 21 + 22 22 + import bytes "bytes" 23 23 + import errors "errors" 24 24 + import path "path" 25 25 + import url "net/url" 26 26 + 27 27 + // Version compatibility assertion. 28 28 + // If the constant is not defined in the package, that likely means 29 29 + // the package needs to be updated to work with this generated code. 30 30 + // See https://twitchtv.github.io/twirp/docs/version_matrix.html 31 31 + const _ = twirp.TwirpPackageMinVersion_8_1_0 32 32 + 33 33 + // ================= 34 34 + // Patreon Interface 35 35 + // ================= 36 36 + 37 37 + type Patreon interface { 38 38 + GetToken(context.Context, *google_protobuf.Empty) (*PatreonToken, error) 39 39 + } 40 40 + 41 41 + // ======================= 42 42 + // Patreon Protobuf Client 43 43 + // ======================= 44 44 + 45 45 + type patreonProtobufClient struct { 46 46 + client HTTPClient 47 47 + urls [1]string 48 48 + interceptor twirp.Interceptor 49 49 + opts twirp.ClientOptions 50 50 + } 51 51 + 52 52 + // NewPatreonProtobufClient creates a Protobuf client that implements the Patreon interface. 53 53 + // It communicates using Protobuf and can be configured with a custom HTTPClient. 54 54 + func NewPatreonProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) Patreon { 55 55 + if c, ok := client.(*http.Client); ok { 56 56 + client = withoutRedirects(c) 57 57 + } 58 58 + 59 59 + clientOpts := twirp.ClientOptions{} 60 60 + for _, o := range opts { 61 61 + o(&clientOpts) 62 62 + } 63 63 + 64 64 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 65 65 + literalURLs := false 66 66 + _ = clientOpts.ReadOpt("literalURLs", &literalURLs) 67 67 + var pathPrefix string 68 68 + if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 69 69 + pathPrefix = "/twirp" // default prefix 70 70 + } 71 71 + 72 72 + // Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method> 73 73 + serviceURL := sanitizeBaseURL(baseURL) 74 74 + serviceURL += baseServicePath(pathPrefix, "xeiaso.net.internal", "Patreon") 75 75 + urls := [1]string{ 76 76 + serviceURL + "GetToken", 77 77 + } 78 78 + 79 79 + return &patreonProtobufClient{ 80 80 + client: client, 81 81 + urls: urls, 82 82 + interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...), 83 83 + opts: clientOpts, 84 84 + } 85 85 + } 86 86 + 87 87 + func (c *patreonProtobufClient) GetToken(ctx context.Context, in *google_protobuf.Empty) (*PatreonToken, error) { 88 88 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net.internal") 89 89 + ctx = ctxsetters.WithServiceName(ctx, "Patreon") 90 90 + ctx = ctxsetters.WithMethodName(ctx, "GetToken") 91 91 + caller := c.callGetToken 92 92 + if c.interceptor != nil { 93 93 + caller = func(ctx context.Context, req *google_protobuf.Empty) (*PatreonToken, error) { 94 94 + resp, err := c.interceptor( 95 95 + func(ctx context.Context, req interface{}) (interface{}, error) { 96 96 + typedReq, ok := req.(*google_protobuf.Empty) 97 97 + if !ok { 98 98 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 99 99 + } 100 100 + return c.callGetToken(ctx, typedReq) 101 101 + }, 102 102 + )(ctx, req) 103 103 + if resp != nil { 104 104 + typedResp, ok := resp.(*PatreonToken) 105 105 + if !ok { 106 106 + return nil, twirp.InternalError("failed type assertion resp.(*PatreonToken) when calling interceptor") 107 107 + } 108 108 + return typedResp, err 109 109 + } 110 110 + return nil, err 111 111 + } 112 112 + } 113 113 + return caller(ctx, in) 114 114 + } 115 115 + 116 116 + func (c *patreonProtobufClient) callGetToken(ctx context.Context, in *google_protobuf.Empty) (*PatreonToken, error) { 117 117 + out := new(PatreonToken) 118 118 + ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out) 119 119 + if err != nil { 120 120 + twerr, ok := err.(twirp.Error) 121 121 + if !ok { 122 122 + twerr = twirp.InternalErrorWith(err) 123 123 + } 124 124 + callClientError(ctx, c.opts.Hooks, twerr) 125 125 + return nil, err 126 126 + } 127 127 + 128 128 + callClientResponseReceived(ctx, c.opts.Hooks) 129 129 + 130 130 + return out, nil 131 131 + } 132 132 + 133 133 + // =================== 134 134 + // Patreon JSON Client 135 135 + // =================== 136 136 + 137 137 + type patreonJSONClient struct { 138 138 + client HTTPClient 139 139 + urls [1]string 140 140 + interceptor twirp.Interceptor 141 141 + opts twirp.ClientOptions 142 142 + } 143 143 + 144 144 + // NewPatreonJSONClient creates a JSON client that implements the Patreon interface. 145 145 + // It communicates using JSON and can be configured with a custom HTTPClient. 146 146 + func NewPatreonJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) Patreon { 147 147 + if c, ok := client.(*http.Client); ok { 148 148 + client = withoutRedirects(c) 149 149 + } 150 150 + 151 151 + clientOpts := twirp.ClientOptions{} 152 152 + for _, o := range opts { 153 153 + o(&clientOpts) 154 154 + } 155 155 + 156 156 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 157 157 + literalURLs := false 158 158 + _ = clientOpts.ReadOpt("literalURLs", &literalURLs) 159 159 + var pathPrefix string 160 160 + if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 161 161 + pathPrefix = "/twirp" // default prefix 162 162 + } 163 163 + 164 164 + // Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method> 165 165 + serviceURL := sanitizeBaseURL(baseURL) 166 166 + serviceURL += baseServicePath(pathPrefix, "xeiaso.net.internal", "Patreon") 167 167 + urls := [1]string{ 168 168 + serviceURL + "GetToken", 169 169 + } 170 170 + 171 171 + return &patreonJSONClient{ 172 172 + client: client, 173 173 + urls: urls, 174 174 + interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...), 175 175 + opts: clientOpts, 176 176 + } 177 177 + } 178 178 + 179 179 + func (c *patreonJSONClient) GetToken(ctx context.Context, in *google_protobuf.Empty) (*PatreonToken, error) { 180 180 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net.internal") 181 181 + ctx = ctxsetters.WithServiceName(ctx, "Patreon") 182 182 + ctx = ctxsetters.WithMethodName(ctx, "GetToken") 183 183 + caller := c.callGetToken 184 184 + if c.interceptor != nil { 185 185 + caller = func(ctx context.Context, req *google_protobuf.Empty) (*PatreonToken, error) { 186 186 + resp, err := c.interceptor( 187 187 + func(ctx context.Context, req interface{}) (interface{}, error) { 188 188 + typedReq, ok := req.(*google_protobuf.Empty) 189 189 + if !ok { 190 190 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 191 191 + } 192 192 + return c.callGetToken(ctx, typedReq) 193 193 + }, 194 194 + )(ctx, req) 195 195 + if resp != nil { 196 196 + typedResp, ok := resp.(*PatreonToken) 197 197 + if !ok { 198 198 + return nil, twirp.InternalError("failed type assertion resp.(*PatreonToken) when calling interceptor") 199 199 + } 200 200 + return typedResp, err 201 201 + } 202 202 + return nil, err 203 203 + } 204 204 + } 205 205 + return caller(ctx, in) 206 206 + } 207 207 + 208 208 + func (c *patreonJSONClient) callGetToken(ctx context.Context, in *google_protobuf.Empty) (*PatreonToken, error) { 209 209 + out := new(PatreonToken) 210 210 + ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out) 211 211 + if err != nil { 212 212 + twerr, ok := err.(twirp.Error) 213 213 + if !ok { 214 214 + twerr = twirp.InternalErrorWith(err) 215 215 + } 216 216 + callClientError(ctx, c.opts.Hooks, twerr) 217 217 + return nil, err 218 218 + } 219 219 + 220 220 + callClientResponseReceived(ctx, c.opts.Hooks) 221 221 + 222 222 + return out, nil 223 223 + } 224 224 + 225 225 + // ====================== 226 226 + // Patreon Server Handler 227 227 + // ====================== 228 228 + 229 229 + type patreonServer struct { 230 230 + Patreon 231 231 + interceptor twirp.Interceptor 232 232 + hooks *twirp.ServerHooks 233 233 + pathPrefix string // prefix for routing 234 234 + jsonSkipDefaults bool // do not include unpopulated fields (default values) in the response 235 235 + jsonCamelCase bool // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names 236 236 + } 237 237 + 238 238 + // NewPatreonServer builds a TwirpServer that can be used as an http.Handler to handle 239 239 + // HTTP requests that are routed to the right method in the provided svc implementation. 240 240 + // The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks). 241 241 + func NewPatreonServer(svc Patreon, opts ...interface{}) TwirpServer { 242 242 + serverOpts := newServerOpts(opts) 243 243 + 244 244 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 245 245 + jsonSkipDefaults := false 246 246 + _ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults) 247 247 + jsonCamelCase := false 248 248 + _ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase) 249 249 + var pathPrefix string 250 250 + if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 251 251 + pathPrefix = "/twirp" // default prefix 252 252 + } 253 253 + 254 254 + return &patreonServer{ 255 255 + Patreon: svc, 256 256 + hooks: serverOpts.Hooks, 257 257 + interceptor: twirp.ChainInterceptors(serverOpts.Interceptors...), 258 258 + pathPrefix: pathPrefix, 259 259 + jsonSkipDefaults: jsonSkipDefaults, 260 260 + jsonCamelCase: jsonCamelCase, 261 261 + } 262 262 + } 263 263 + 264 264 + // writeError writes an HTTP response with a valid Twirp error format, and triggers hooks. 265 265 + // If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err) 266 266 + func (s *patreonServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) { 267 267 + writeError(ctx, resp, err, s.hooks) 268 268 + } 269 269 + 270 270 + // handleRequestBodyError is used to handle error when the twirp server cannot read request 271 271 + func (s *patreonServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) { 272 272 + if context.Canceled == ctx.Err() { 273 273 + s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled")) 274 274 + return 275 275 + } 276 276 + if context.DeadlineExceeded == ctx.Err() { 277 277 + s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded")) 278 278 + return 279 279 + } 280 280 + s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err)) 281 281 + } 282 282 + 283 283 + // PatreonPathPrefix is a convenience constant that may identify URL paths. 284 284 + // Should be used with caution, it only matches routes generated by Twirp Go clients, 285 285 + // with the default "/twirp" prefix and default CamelCase service and method names. 286 286 + // More info: https://twitchtv.github.io/twirp/docs/routing.html 287 287 + const PatreonPathPrefix = "/twirp/xeiaso.net.internal.Patreon/" 288 288 + 289 289 + func (s *patreonServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) { 290 290 + ctx := req.Context() 291 291 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net.internal") 292 292 + ctx = ctxsetters.WithServiceName(ctx, "Patreon") 293 293 + ctx = ctxsetters.WithResponseWriter(ctx, resp) 294 294 + 295 295 + var err error 296 296 + ctx, err = callRequestReceived(ctx, s.hooks) 297 297 + if err != nil { 298 298 + s.writeError(ctx, resp, err) 299 299 + return 300 300 + } 301 301 + 302 302 + if req.Method != "POST" { 303 303 + msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method) 304 304 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 305 305 + return 306 306 + } 307 307 + 308 308 + // Verify path format: [<prefix>]/<package>.<Service>/<Method> 309 309 + prefix, pkgService, method := parseTwirpPath(req.URL.Path) 310 310 + if pkgService != "xeiaso.net.internal.Patreon" { 311 311 + msg := fmt.Sprintf("no handler for path %q", req.URL.Path) 312 312 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 313 313 + return 314 314 + } 315 315 + if prefix != s.pathPrefix { 316 316 + msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path) 317 317 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 318 318 + return 319 319 + } 320 320 + 321 321 + switch method { 322 322 + case "GetToken": 323 323 + s.serveGetToken(ctx, resp, req) 324 324 + return 325 325 + default: 326 326 + msg := fmt.Sprintf("no handler for path %q", req.URL.Path) 327 327 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 328 328 + return 329 329 + } 330 330 + } 331 331 + 332 332 + func (s *patreonServer) serveGetToken(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 333 333 + header := req.Header.Get("Content-Type") 334 334 + i := strings.Index(header, ";") 335 335 + if i == -1 { 336 336 + i = len(header) 337 337 + } 338 338 + switch strings.TrimSpace(strings.ToLower(header[:i])) { 339 339 + case "application/json": 340 340 + s.serveGetTokenJSON(ctx, resp, req) 341 341 + case "application/protobuf": 342 342 + s.serveGetTokenProtobuf(ctx, resp, req) 343 343 + default: 344 344 + msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type")) 345 345 + twerr := badRouteError(msg, req.Method, req.URL.Path) 346 346 + s.writeError(ctx, resp, twerr) 347 347 + } 348 348 + } 349 349 + 350 350 + func (s *patreonServer) serveGetTokenJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 351 351 + var err error 352 352 + ctx = ctxsetters.WithMethodName(ctx, "GetToken") 353 353 + ctx, err = callRequestRouted(ctx, s.hooks) 354 354 + if err != nil { 355 355 + s.writeError(ctx, resp, err) 356 356 + return 357 357 + } 358 358 + 359 359 + d := json.NewDecoder(req.Body) 360 360 + rawReqBody := json.RawMessage{} 361 361 + if err := d.Decode(&rawReqBody); err != nil { 362 362 + s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err) 363 363 + return 364 364 + } 365 365 + reqContent := new(google_protobuf.Empty) 366 366 + unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true} 367 367 + if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil { 368 368 + s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err) 369 369 + return 370 370 + } 371 371 + 372 372 + handler := s.Patreon.GetToken 373 373 + if s.interceptor != nil { 374 374 + handler = func(ctx context.Context, req *google_protobuf.Empty) (*PatreonToken, error) { 375 375 + resp, err := s.interceptor( 376 376 + func(ctx context.Context, req interface{}) (interface{}, error) { 377 377 + typedReq, ok := req.(*google_protobuf.Empty) 378 378 + if !ok { 379 379 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 380 380 + } 381 381 + return s.Patreon.GetToken(ctx, typedReq) 382 382 + }, 383 383 + )(ctx, req) 384 384 + if resp != nil { 385 385 + typedResp, ok := resp.(*PatreonToken) 386 386 + if !ok { 387 387 + return nil, twirp.InternalError("failed type assertion resp.(*PatreonToken) when calling interceptor") 388 388 + } 389 389 + return typedResp, err 390 390 + } 391 391 + return nil, err 392 392 + } 393 393 + } 394 394 + 395 395 + // Call service method 396 396 + var respContent *PatreonToken 397 397 + func() { 398 398 + defer ensurePanicResponses(ctx, resp, s.hooks) 399 399 + respContent, err = handler(ctx, reqContent) 400 400 + }() 401 401 + 402 402 + if err != nil { 403 403 + s.writeError(ctx, resp, err) 404 404 + return 405 405 + } 406 406 + if respContent == nil { 407 407 + s.writeError(ctx, resp, twirp.InternalError("received a nil *PatreonToken and nil error while calling GetToken. nil responses are not supported")) 408 408 + return 409 409 + } 410 410 + 411 411 + ctx = callResponsePrepared(ctx, s.hooks) 412 412 + 413 413 + marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults} 414 414 + respBytes, err := marshaler.Marshal(respContent) 415 415 + if err != nil { 416 416 + s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response")) 417 417 + return 418 418 + } 419 419 + 420 420 + ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK) 421 421 + resp.Header().Set("Content-Type", "application/json") 422 422 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes))) 423 423 + resp.WriteHeader(http.StatusOK) 424 424 + 425 425 + if n, err := resp.Write(respBytes); err != nil { 426 426 + msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error()) 427 427 + twerr := twirp.NewError(twirp.Unknown, msg) 428 428 + ctx = callError(ctx, s.hooks, twerr) 429 429 + } 430 430 + callResponseSent(ctx, s.hooks) 431 431 + } 432 432 + 433 433 + func (s *patreonServer) serveGetTokenProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 434 434 + var err error 435 435 + ctx = ctxsetters.WithMethodName(ctx, "GetToken") 436 436 + ctx, err = callRequestRouted(ctx, s.hooks) 437 437 + if err != nil { 438 438 + s.writeError(ctx, resp, err) 439 439 + return 440 440 + } 441 441 + 442 442 + buf, err := io.ReadAll(req.Body) 443 443 + if err != nil { 444 444 + s.handleRequestBodyError(ctx, resp, "failed to read request body", err) 445 445 + return 446 446 + } 447 447 + reqContent := new(google_protobuf.Empty) 448 448 + if err = proto.Unmarshal(buf, reqContent); err != nil { 449 449 + s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded")) 450 450 + return 451 451 + } 452 452 + 453 453 + handler := s.Patreon.GetToken 454 454 + if s.interceptor != nil { 455 455 + handler = func(ctx context.Context, req *google_protobuf.Empty) (*PatreonToken, error) { 456 456 + resp, err := s.interceptor( 457 457 + func(ctx context.Context, req interface{}) (interface{}, error) { 458 458 + typedReq, ok := req.(*google_protobuf.Empty) 459 459 + if !ok { 460 460 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 461 461 + } 462 462 + return s.Patreon.GetToken(ctx, typedReq) 463 463 + }, 464 464 + )(ctx, req) 465 465 + if resp != nil { 466 466 + typedResp, ok := resp.(*PatreonToken) 467 467 + if !ok { 468 468 + return nil, twirp.InternalError("failed type assertion resp.(*PatreonToken) when calling interceptor") 469 469 + } 470 470 + return typedResp, err 471 471 + } 472 472 + return nil, err 473 473 + } 474 474 + } 475 475 + 476 476 + // Call service method 477 477 + var respContent *PatreonToken 478 478 + func() { 479 479 + defer ensurePanicResponses(ctx, resp, s.hooks) 480 480 + respContent, err = handler(ctx, reqContent) 481 481 + }() 482 482 + 483 483 + if err != nil { 484 484 + s.writeError(ctx, resp, err) 485 485 + return 486 486 + } 487 487 + if respContent == nil { 488 488 + s.writeError(ctx, resp, twirp.InternalError("received a nil *PatreonToken and nil error while calling GetToken. nil responses are not supported")) 489 489 + return 490 490 + } 491 491 + 492 492 + ctx = callResponsePrepared(ctx, s.hooks) 493 493 + 494 494 + respBytes, err := proto.Marshal(respContent) 495 495 + if err != nil { 496 496 + s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response")) 497 497 + return 498 498 + } 499 499 + 500 500 + ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK) 501 501 + resp.Header().Set("Content-Type", "application/protobuf") 502 502 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes))) 503 503 + resp.WriteHeader(http.StatusOK) 504 504 + if n, err := resp.Write(respBytes); err != nil { 505 505 + msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error()) 506 506 + twerr := twirp.NewError(twirp.Unknown, msg) 507 507 + ctx = callError(ctx, s.hooks, twerr) 508 508 + } 509 509 + callResponseSent(ctx, s.hooks) 510 510 + } 511 511 + 512 512 + func (s *patreonServer) ServiceDescriptor() ([]byte, int) { 513 513 + return twirpFileDescriptor0, 0 514 514 + } 515 515 + 516 516 + func (s *patreonServer) ProtocGenTwirpVersion() string { 517 517 + return "v8.1.3" 518 518 + } 519 519 + 520 520 + // PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/" 521 521 + // that is everything in a Twirp route except for the <Method>. This can be used for routing, 522 522 + // for example to identify the requests that are targeted to this service in a mux. 523 523 + func (s *patreonServer) PathPrefix() string { 524 524 + return baseServicePath(s.pathPrefix, "xeiaso.net.internal", "Patreon") 525 525 + } 526 526 + 527 527 + // =============== 528 528 + // Admin Interface 529 529 + // =============== 530 530 + 531 531 + type Admin interface { 532 532 + Rebuild(context.Context, *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) 533 533 + } 534 534 + 535 535 + // ===================== 536 536 + // Admin Protobuf Client 537 537 + // ===================== 538 538 + 539 539 + type adminProtobufClient struct { 540 540 + client HTTPClient 541 541 + urls [1]string 542 542 + interceptor twirp.Interceptor 543 543 + opts twirp.ClientOptions 544 544 + } 545 545 + 546 546 + // NewAdminProtobufClient creates a Protobuf client that implements the Admin interface. 547 547 + // It communicates using Protobuf and can be configured with a custom HTTPClient. 548 548 + func NewAdminProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) Admin { 549 549 + if c, ok := client.(*http.Client); ok { 550 550 + client = withoutRedirects(c) 551 551 + } 552 552 + 553 553 + clientOpts := twirp.ClientOptions{} 554 554 + for _, o := range opts { 555 555 + o(&clientOpts) 556 556 + } 557 557 + 558 558 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 559 559 + literalURLs := false 560 560 + _ = clientOpts.ReadOpt("literalURLs", &literalURLs) 561 561 + var pathPrefix string 562 562 + if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 563 563 + pathPrefix = "/twirp" // default prefix 564 564 + } 565 565 + 566 566 + // Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method> 567 567 + serviceURL := sanitizeBaseURL(baseURL) 568 568 + serviceURL += baseServicePath(pathPrefix, "xeiaso.net.internal", "Admin") 569 569 + urls := [1]string{ 570 570 + serviceURL + "Rebuild", 571 571 + } 572 572 + 573 573 + return &adminProtobufClient{ 574 574 + client: client, 575 575 + urls: urls, 576 576 + interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...), 577 577 + opts: clientOpts, 578 578 + } 579 579 + } 580 580 + 581 581 + func (c *adminProtobufClient) Rebuild(ctx context.Context, in *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 582 582 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net.internal") 583 583 + ctx = ctxsetters.WithServiceName(ctx, "Admin") 584 584 + ctx = ctxsetters.WithMethodName(ctx, "Rebuild") 585 585 + caller := c.callRebuild 586 586 + if c.interceptor != nil { 587 587 + caller = func(ctx context.Context, req *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 588 588 + resp, err := c.interceptor( 589 589 + func(ctx context.Context, req interface{}) (interface{}, error) { 590 590 + typedReq, ok := req.(*google_protobuf.Empty) 591 591 + if !ok { 592 592 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 593 593 + } 594 594 + return c.callRebuild(ctx, typedReq) 595 595 + }, 596 596 + )(ctx, req) 597 597 + if resp != nil { 598 598 + typedResp, ok := resp.(*xeiaso_net.BuildInfo) 599 599 + if !ok { 600 600 + return nil, twirp.InternalError("failed type assertion resp.(*xeiaso_net.BuildInfo) when calling interceptor") 601 601 + } 602 602 + return typedResp, err 603 603 + } 604 604 + return nil, err 605 605 + } 606 606 + } 607 607 + return caller(ctx, in) 608 608 + } 609 609 + 610 610 + func (c *adminProtobufClient) callRebuild(ctx context.Context, in *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 611 611 + out := new(xeiaso_net.BuildInfo) 612 612 + ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out) 613 613 + if err != nil { 614 614 + twerr, ok := err.(twirp.Error) 615 615 + if !ok { 616 616 + twerr = twirp.InternalErrorWith(err) 617 617 + } 618 618 + callClientError(ctx, c.opts.Hooks, twerr) 619 619 + return nil, err 620 620 + } 621 621 + 622 622 + callClientResponseReceived(ctx, c.opts.Hooks) 623 623 + 624 624 + return out, nil 625 625 + } 626 626 + 627 627 + // ================= 628 628 + // Admin JSON Client 629 629 + // ================= 630 630 + 631 631 + type adminJSONClient struct { 632 632 + client HTTPClient 633 633 + urls [1]string 634 634 + interceptor twirp.Interceptor 635 635 + opts twirp.ClientOptions 636 636 + } 637 637 + 638 638 + // NewAdminJSONClient creates a JSON client that implements the Admin interface. 639 639 + // It communicates using JSON and can be configured with a custom HTTPClient. 640 640 + func NewAdminJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) Admin { 641 641 + if c, ok := client.(*http.Client); ok { 642 642 + client = withoutRedirects(c) 643 643 + } 644 644 + 645 645 + clientOpts := twirp.ClientOptions{} 646 646 + for _, o := range opts { 647 647 + o(&clientOpts) 648 648 + } 649 649 + 650 650 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 651 651 + literalURLs := false 652 652 + _ = clientOpts.ReadOpt("literalURLs", &literalURLs) 653 653 + var pathPrefix string 654 654 + if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 655 655 + pathPrefix = "/twirp" // default prefix 656 656 + } 657 657 + 658 658 + // Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method> 659 659 + serviceURL := sanitizeBaseURL(baseURL) 660 660 + serviceURL += baseServicePath(pathPrefix, "xeiaso.net.internal", "Admin") 661 661 + urls := [1]string{ 662 662 + serviceURL + "Rebuild", 663 663 + } 664 664 + 665 665 + return &adminJSONClient{ 666 666 + client: client, 667 667 + urls: urls, 668 668 + interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...), 669 669 + opts: clientOpts, 670 670 + } 671 671 + } 672 672 + 673 673 + func (c *adminJSONClient) Rebuild(ctx context.Context, in *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 674 674 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net.internal") 675 675 + ctx = ctxsetters.WithServiceName(ctx, "Admin") 676 676 + ctx = ctxsetters.WithMethodName(ctx, "Rebuild") 677 677 + caller := c.callRebuild 678 678 + if c.interceptor != nil { 679 679 + caller = func(ctx context.Context, req *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 680 680 + resp, err := c.interceptor( 681 681 + func(ctx context.Context, req interface{}) (interface{}, error) { 682 682 + typedReq, ok := req.(*google_protobuf.Empty) 683 683 + if !ok { 684 684 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 685 685 + } 686 686 + return c.callRebuild(ctx, typedReq) 687 687 + }, 688 688 + )(ctx, req) 689 689 + if resp != nil { 690 690 + typedResp, ok := resp.(*xeiaso_net.BuildInfo) 691 691 + if !ok { 692 692 + return nil, twirp.InternalError("failed type assertion resp.(*xeiaso_net.BuildInfo) when calling interceptor") 693 693 + } 694 694 + return typedResp, err 695 695 + } 696 696 + return nil, err 697 697 + } 698 698 + } 699 699 + return caller(ctx, in) 700 700 + } 701 701 + 702 702 + func (c *adminJSONClient) callRebuild(ctx context.Context, in *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 703 703 + out := new(xeiaso_net.BuildInfo) 704 704 + ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out) 705 705 + if err != nil { 706 706 + twerr, ok := err.(twirp.Error) 707 707 + if !ok { 708 708 + twerr = twirp.InternalErrorWith(err) 709 709 + } 710 710 + callClientError(ctx, c.opts.Hooks, twerr) 711 711 + return nil, err 712 712 + } 713 713 + 714 714 + callClientResponseReceived(ctx, c.opts.Hooks) 715 715 + 716 716 + return out, nil 717 717 + } 718 718 + 719 719 + // ==================== 720 720 + // Admin Server Handler 721 721 + // ==================== 722 722 + 723 723 + type adminServer struct { 724 724 + Admin 725 725 + interceptor twirp.Interceptor 726 726 + hooks *twirp.ServerHooks 727 727 + pathPrefix string // prefix for routing 728 728 + jsonSkipDefaults bool // do not include unpopulated fields (default values) in the response 729 729 + jsonCamelCase bool // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names 730 730 + } 731 731 + 732 732 + // NewAdminServer builds a TwirpServer that can be used as an http.Handler to handle 733 733 + // HTTP requests that are routed to the right method in the provided svc implementation. 734 734 + // The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks). 735 735 + func NewAdminServer(svc Admin, opts ...interface{}) TwirpServer { 736 736 + serverOpts := newServerOpts(opts) 737 737 + 738 738 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 739 739 + jsonSkipDefaults := false 740 740 + _ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults) 741 741 + jsonCamelCase := false 742 742 + _ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase) 743 743 + var pathPrefix string 744 744 + if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 745 745 + pathPrefix = "/twirp" // default prefix 746 746 + } 747 747 + 748 748 + return &adminServer{ 749 749 + Admin: svc, 750 750 + hooks: serverOpts.Hooks, 751 751 + interceptor: twirp.ChainInterceptors(serverOpts.Interceptors...), 752 752 + pathPrefix: pathPrefix, 753 753 + jsonSkipDefaults: jsonSkipDefaults, 754 754 + jsonCamelCase: jsonCamelCase, 755 755 + } 756 756 + } 757 757 + 758 758 + // writeError writes an HTTP response with a valid Twirp error format, and triggers hooks. 759 759 + // If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err) 760 760 + func (s *adminServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) { 761 761 + writeError(ctx, resp, err, s.hooks) 762 762 + } 763 763 + 764 764 + // handleRequestBodyError is used to handle error when the twirp server cannot read request 765 765 + func (s *adminServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) { 766 766 + if context.Canceled == ctx.Err() { 767 767 + s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled")) 768 768 + return 769 769 + } 770 770 + if context.DeadlineExceeded == ctx.Err() { 771 771 + s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded")) 772 772 + return 773 773 + } 774 774 + s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err)) 775 775 + } 776 776 + 777 777 + // AdminPathPrefix is a convenience constant that may identify URL paths. 778 778 + // Should be used with caution, it only matches routes generated by Twirp Go clients, 779 779 + // with the default "/twirp" prefix and default CamelCase service and method names. 780 780 + // More info: https://twitchtv.github.io/twirp/docs/routing.html 781 781 + const AdminPathPrefix = "/twirp/xeiaso.net.internal.Admin/" 782 782 + 783 783 + func (s *adminServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) { 784 784 + ctx := req.Context() 785 785 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net.internal") 786 786 + ctx = ctxsetters.WithServiceName(ctx, "Admin") 787 787 + ctx = ctxsetters.WithResponseWriter(ctx, resp) 788 788 + 789 789 + var err error 790 790 + ctx, err = callRequestReceived(ctx, s.hooks) 791 791 + if err != nil { 792 792 + s.writeError(ctx, resp, err) 793 793 + return 794 794 + } 795 795 + 796 796 + if req.Method != "POST" { 797 797 + msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method) 798 798 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 799 799 + return 800 800 + } 801 801 + 802 802 + // Verify path format: [<prefix>]/<package>.<Service>/<Method> 803 803 + prefix, pkgService, method := parseTwirpPath(req.URL.Path) 804 804 + if pkgService != "xeiaso.net.internal.Admin" { 805 805 + msg := fmt.Sprintf("no handler for path %q", req.URL.Path) 806 806 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 807 807 + return 808 808 + } 809 809 + if prefix != s.pathPrefix { 810 810 + msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path) 811 811 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 812 812 + return 813 813 + } 814 814 + 815 815 + switch method { 816 816 + case "Rebuild": 817 817 + s.serveRebuild(ctx, resp, req) 818 818 + return 819 819 + default: 820 820 + msg := fmt.Sprintf("no handler for path %q", req.URL.Path) 821 821 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 822 822 + return 823 823 + } 824 824 + } 825 825 + 826 826 + func (s *adminServer) serveRebuild(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 827 827 + header := req.Header.Get("Content-Type") 828 828 + i := strings.Index(header, ";") 829 829 + if i == -1 { 830 830 + i = len(header) 831 831 + } 832 832 + switch strings.TrimSpace(strings.ToLower(header[:i])) { 833 833 + case "application/json": 834 834 + s.serveRebuildJSON(ctx, resp, req) 835 835 + case "application/protobuf": 836 836 + s.serveRebuildProtobuf(ctx, resp, req) 837 837 + default: 838 838 + msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type")) 839 839 + twerr := badRouteError(msg, req.Method, req.URL.Path) 840 840 + s.writeError(ctx, resp, twerr) 841 841 + } 842 842 + } 843 843 + 844 844 + func (s *adminServer) serveRebuildJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 845 845 + var err error 846 846 + ctx = ctxsetters.WithMethodName(ctx, "Rebuild") 847 847 + ctx, err = callRequestRouted(ctx, s.hooks) 848 848 + if err != nil { 849 849 + s.writeError(ctx, resp, err) 850 850 + return 851 851 + } 852 852 + 853 853 + d := json.NewDecoder(req.Body) 854 854 + rawReqBody := json.RawMessage{} 855 855 + if err := d.Decode(&rawReqBody); err != nil { 856 856 + s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err) 857 857 + return 858 858 + } 859 859 + reqContent := new(google_protobuf.Empty) 860 860 + unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true} 861 861 + if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil { 862 862 + s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err) 863 863 + return 864 864 + } 865 865 + 866 866 + handler := s.Admin.Rebuild 867 867 + if s.interceptor != nil { 868 868 + handler = func(ctx context.Context, req *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 869 869 + resp, err := s.interceptor( 870 870 + func(ctx context.Context, req interface{}) (interface{}, error) { 871 871 + typedReq, ok := req.(*google_protobuf.Empty) 872 872 + if !ok { 873 873 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 874 874 + } 875 875 + return s.Admin.Rebuild(ctx, typedReq) 876 876 + }, 877 877 + )(ctx, req) 878 878 + if resp != nil { 879 879 + typedResp, ok := resp.(*xeiaso_net.BuildInfo) 880 880 + if !ok { 881 881 + return nil, twirp.InternalError("failed type assertion resp.(*xeiaso_net.BuildInfo) when calling interceptor") 882 882 + } 883 883 + return typedResp, err 884 884 + } 885 885 + return nil, err 886 886 + } 887 887 + } 888 888 + 889 889 + // Call service method 890 890 + var respContent *xeiaso_net.BuildInfo 891 891 + func() { 892 892 + defer ensurePanicResponses(ctx, resp, s.hooks) 893 893 + respContent, err = handler(ctx, reqContent) 894 894 + }() 895 895 + 896 896 + if err != nil { 897 897 + s.writeError(ctx, resp, err) 898 898 + return 899 899 + } 900 900 + if respContent == nil { 901 901 + s.writeError(ctx, resp, twirp.InternalError("received a nil *xeiaso_net.BuildInfo and nil error while calling Rebuild. nil responses are not supported")) 902 902 + return 903 903 + } 904 904 + 905 905 + ctx = callResponsePrepared(ctx, s.hooks) 906 906 + 907 907 + marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults} 908 908 + respBytes, err := marshaler.Marshal(respContent) 909 909 + if err != nil { 910 910 + s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response")) 911 911 + return 912 912 + } 913 913 + 914 914 + ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK) 915 915 + resp.Header().Set("Content-Type", "application/json") 916 916 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes))) 917 917 + resp.WriteHeader(http.StatusOK) 918 918 + 919 919 + if n, err := resp.Write(respBytes); err != nil { 920 920 + msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error()) 921 921 + twerr := twirp.NewError(twirp.Unknown, msg) 922 922 + ctx = callError(ctx, s.hooks, twerr) 923 923 + } 924 924 + callResponseSent(ctx, s.hooks) 925 925 + } 926 926 + 927 927 + func (s *adminServer) serveRebuildProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 928 928 + var err error 929 929 + ctx = ctxsetters.WithMethodName(ctx, "Rebuild") 930 930 + ctx, err = callRequestRouted(ctx, s.hooks) 931 931 + if err != nil { 932 932 + s.writeError(ctx, resp, err) 933 933 + return 934 934 + } 935 935 + 936 936 + buf, err := io.ReadAll(req.Body) 937 937 + if err != nil { 938 938 + s.handleRequestBodyError(ctx, resp, "failed to read request body", err) 939 939 + return 940 940 + } 941 941 + reqContent := new(google_protobuf.Empty) 942 942 + if err = proto.Unmarshal(buf, reqContent); err != nil { 943 943 + s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded")) 944 944 + return 945 945 + } 946 946 + 947 947 + handler := s.Admin.Rebuild 948 948 + if s.interceptor != nil { 949 949 + handler = func(ctx context.Context, req *google_protobuf.Empty) (*xeiaso_net.BuildInfo, error) { 950 950 + resp, err := s.interceptor( 951 951 + func(ctx context.Context, req interface{}) (interface{}, error) { 952 952 + typedReq, ok := req.(*google_protobuf.Empty) 953 953 + if !ok { 954 954 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 955 955 + } 956 956 + return s.Admin.Rebuild(ctx, typedReq) 957 957 + }, 958 958 + )(ctx, req) 959 959 + if resp != nil { 960 960 + typedResp, ok := resp.(*xeiaso_net.BuildInfo) 961 961 + if !ok { 962 962 + return nil, twirp.InternalError("failed type assertion resp.(*xeiaso_net.BuildInfo) when calling interceptor") 963 963 + } 964 964 + return typedResp, err 965 965 + } 966 966 + return nil, err 967 967 + } 968 968 + } 969 969 + 970 970 + // Call service method 971 971 + var respContent *xeiaso_net.BuildInfo 972 972 + func() { 973 973 + defer ensurePanicResponses(ctx, resp, s.hooks) 974 974 + respContent, err = handler(ctx, reqContent) 975 975 + }() 976 976 + 977 977 + if err != nil { 978 978 + s.writeError(ctx, resp, err) 979 979 + return 980 980 + } 981 981 + if respContent == nil { 982 982 + s.writeError(ctx, resp, twirp.InternalError("received a nil *xeiaso_net.BuildInfo and nil error while calling Rebuild. nil responses are not supported")) 983 983 + return 984 984 + } 985 985 + 986 986 + ctx = callResponsePrepared(ctx, s.hooks) 987 987 + 988 988 + respBytes, err := proto.Marshal(respContent) 989 989 + if err != nil { 990 990 + s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response")) 991 991 + return 992 992 + } 993 993 + 994 994 + ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK) 995 995 + resp.Header().Set("Content-Type", "application/protobuf") 996 996 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes))) 997 997 + resp.WriteHeader(http.StatusOK) 998 998 + if n, err := resp.Write(respBytes); err != nil { 999 999 + msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error()) 1000 1000 + twerr := twirp.NewError(twirp.Unknown, msg) 1001 1001 + ctx = callError(ctx, s.hooks, twerr) 1002 1002 + } 1003 1003 + callResponseSent(ctx, s.hooks) 1004 1004 + } 1005 1005 + 1006 1006 + func (s *adminServer) ServiceDescriptor() ([]byte, int) { 1007 1007 + return twirpFileDescriptor0, 1 1008 1008 + } 1009 1009 + 1010 1010 + func (s *adminServer) ProtocGenTwirpVersion() string { 1011 1011 + return "v8.1.3" 1012 1012 + } 1013 1013 + 1014 1014 + // PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/" 1015 1015 + // that is everything in a Twirp route except for the <Method>. This can be used for routing, 1016 1016 + // for example to identify the requests that are targeted to this service in a mux. 1017 1017 + func (s *adminServer) PathPrefix() string { 1018 1018 + return baseServicePath(s.pathPrefix, "xeiaso.net.internal", "Admin") 1019 1019 + } 1020 1020 + 1021 1021 + // ===== 1022 1022 + // Utils 1023 1023 + // ===== 1024 1024 + 1025 1025 + // HTTPClient is the interface used by generated clients to send HTTP requests. 1026 1026 + // It is fulfilled by *(net/http).Client, which is sufficient for most users. 1027 1027 + // Users can provide their own implementation for special retry policies. 1028 1028 + // 1029 1029 + // HTTPClient implementations should not follow redirects. Redirects are 1030 1030 + // automatically disabled if *(net/http).Client is passed to client 1031 1031 + // constructors. See the withoutRedirects function in this file for more 1032 1032 + // details. 1033 1033 + type HTTPClient interface { 1034 1034 + Do(req *http.Request) (*http.Response, error) 1035 1035 + } 1036 1036 + 1037 1037 + // TwirpServer is the interface generated server structs will support: they're 1038 1038 + // HTTP handlers with additional methods for accessing metadata about the 1039 1039 + // service. Those accessors are a low-level API for building reflection tools. 1040 1040 + // Most people can think of TwirpServers as just http.Handlers. 1041 1041 + type TwirpServer interface { 1042 1042 + http.Handler 1043 1043 + 1044 1044 + // ServiceDescriptor returns gzipped bytes describing the .proto file that 1045 1045 + // this service was generated from. Once unzipped, the bytes can be 1046 1046 + // unmarshalled as a 1047 1047 + // google.golang.org/protobuf/types/descriptorpb.FileDescriptorProto. 1048 1048 + // 1049 1049 + // The returned integer is the index of this particular service within that 1050 1050 + // FileDescriptorProto's 'Service' slice of ServiceDescriptorProtos. This is a 1051 1051 + // low-level field, expected to be used for reflection. 1052 1052 + ServiceDescriptor() ([]byte, int) 1053 1053 + 1054 1054 + // ProtocGenTwirpVersion is the semantic version string of the version of 1055 1055 + // twirp used to generate this file. 1056 1056 + ProtocGenTwirpVersion() string 1057 1057 + 1058 1058 + // PathPrefix returns the HTTP URL path prefix for all methods handled by this 1059 1059 + // service. This can be used with an HTTP mux to route Twirp requests. 1060 1060 + // The path prefix is in the form: "/<prefix>/<package>.<Service>/" 1061 1061 + // that is, everything in a Twirp route except for the <Method> at the end. 1062 1062 + PathPrefix() string 1063 1063 + } 1064 1064 + 1065 1065 + func newServerOpts(opts []interface{}) *twirp.ServerOptions { 1066 1066 + serverOpts := &twirp.ServerOptions{} 1067 1067 + for _, opt := range opts { 1068 1068 + switch o := opt.(type) { 1069 1069 + case twirp.ServerOption: 1070 1070 + o(serverOpts) 1071 1071 + case *twirp.ServerHooks: // backwards compatibility, allow to specify hooks as an argument 1072 1072 + twirp.WithServerHooks(o)(serverOpts) 1073 1073 + case nil: // backwards compatibility, allow nil value for the argument 1074 1074 + continue 1075 1075 + default: 1076 1076 + panic(fmt.Sprintf("Invalid option type %T, please use a twirp.ServerOption", o)) 1077 1077 + } 1078 1078 + } 1079 1079 + return serverOpts 1080 1080 + } 1081 1081 + 1082 1082 + // WriteError writes an HTTP response with a valid Twirp error format (code, msg, meta). 1083 1083 + // Useful outside of the Twirp server (e.g. http middleware), but does not trigger hooks. 1084 1084 + // If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err) 1085 1085 + func WriteError(resp http.ResponseWriter, err error) { 1086 1086 + writeError(context.Background(), resp, err, nil) 1087 1087 + } 1088 1088 + 1089 1089 + // writeError writes Twirp errors in the response and triggers hooks. 1090 1090 + func writeError(ctx context.Context, resp http.ResponseWriter, err error, hooks *twirp.ServerHooks) { 1091 1091 + // Convert to a twirp.Error. Non-twirp errors are converted to internal errors. 1092 1092 + var twerr twirp.Error 1093 1093 + if !errors.As(err, &twerr) { 1094 1094 + twerr = twirp.InternalErrorWith(err) 1095 1095 + } 1096 1096 + 1097 1097 + statusCode := twirp.ServerHTTPStatusFromErrorCode(twerr.Code()) 1098 1098 + ctx = ctxsetters.WithStatusCode(ctx, statusCode) 1099 1099 + ctx = callError(ctx, hooks, twerr) 1100 1100 + 1101 1101 + respBody := marshalErrorToJSON(twerr) 1102 1102 + 1103 1103 + resp.Header().Set("Content-Type", "application/json") // Error responses are always JSON 1104 1104 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBody))) 1105 1105 + resp.WriteHeader(statusCode) // set HTTP status code and send response 1106 1106 + 1107 1107 + _, writeErr := resp.Write(respBody) 1108 1108 + if writeErr != nil { 1109 1109 + // We have three options here. We could log the error, call the Error 1110 1110 + // hook, or just silently ignore the error. 1111 1111 + // 1112 1112 + // Logging is unacceptable because we don't have a user-controlled 1113 1113 + // logger; writing out to stderr without permission is too rude. 1114 1114 + // 1115 1115 + // Calling the Error hook would confuse users: it would mean the Error 1116 1116 + // hook got called twice for one request, which is likely to lead to 1117 1117 + // duplicated log messages and metrics, no matter how well we document 1118 1118 + // the behavior. 1119 1119 + // 1120 1120 + // Silently ignoring the error is our least-bad option. It's highly 1121 1121 + // likely that the connection is broken and the original 'err' says 1122 1122 + // so anyway. 1123 1123 + _ = writeErr 1124 1124 + } 1125 1125 + 1126 1126 + callResponseSent(ctx, hooks) 1127 1127 + } 1128 1128 + 1129 1129 + // sanitizeBaseURL parses the the baseURL, and adds the "http" scheme if needed. 1130 1130 + // If the URL is unparsable, the baseURL is returned unchanged. 1131 1131 + func sanitizeBaseURL(baseURL string) string { 1132 1132 + u, err := url.Parse(baseURL) 1133 1133 + if err != nil { 1134 1134 + return baseURL // invalid URL will fail later when making requests 1135 1135 + } 1136 1136 + if u.Scheme == "" { 1137 1137 + u.Scheme = "http" 1138 1138 + } 1139 1139 + return u.String() 1140 1140 + } 1141 1141 + 1142 1142 + // baseServicePath composes the path prefix for the service (without <Method>). 1143 1143 + // e.g.: baseServicePath("/twirp", "my.pkg", "MyService") 1144 1144 + // 1145 1145 + // returns => "/twirp/my.pkg.MyService/" 1146 1146 + // 1147 1147 + // e.g.: baseServicePath("", "", "MyService") 1148 1148 + // 1149 1149 + // returns => "/MyService/" 1150 1150 + func baseServicePath(prefix, pkg, service string) string { 1151 1151 + fullServiceName := service 1152 1152 + if pkg != "" { 1153 1153 + fullServiceName = pkg + "." + service 1154 1154 + } 1155 1155 + return path.Join("/", prefix, fullServiceName) + "/" 1156 1156 + } 1157 1157 + 1158 1158 + // parseTwirpPath extracts path components form a valid Twirp route. 1159 1159 + // Expected format: "[<prefix>]/<package>.<Service>/<Method>" 1160 1160 + // e.g.: prefix, pkgService, method := parseTwirpPath("/twirp/pkg.Svc/MakeHat") 1161 1161 + func parseTwirpPath(path string) (string, string, string) { 1162 1162 + parts := strings.Split(path, "/") 1163 1163 + if len(parts) < 2 { 1164 1164 + return "", "", "" 1165 1165 + } 1166 1166 + method := parts[len(parts)-1] 1167 1167 + pkgService := parts[len(parts)-2] 1168 1168 + prefix := strings.Join(parts[0:len(parts)-2], "/") 1169 1169 + return prefix, pkgService, method 1170 1170 + } 1171 1171 + 1172 1172 + // getCustomHTTPReqHeaders retrieves a copy of any headers that are set in 1173 1173 + // a context through the twirp.WithHTTPRequestHeaders function. 1174 1174 + // If there are no headers set, or if they have the wrong type, nil is returned. 1175 1175 + func getCustomHTTPReqHeaders(ctx context.Context) http.Header { 1176 1176 + header, ok := twirp.HTTPRequestHeaders(ctx) 1177 1177 + if !ok || header == nil { 1178 1178 + return nil 1179 1179 + } 1180 1180 + copied := make(http.Header) 1181 1181 + for k, vv := range header { 1182 1182 + if vv == nil { 1183 1183 + copied[k] = nil 1184 1184 + continue 1185 1185 + } 1186 1186 + copied[k] = make([]string, len(vv)) 1187 1187 + copy(copied[k], vv) 1188 1188 + } 1189 1189 + return copied 1190 1190 + } 1191 1191 + 1192 1192 + // newRequest makes an http.Request from a client, adding common headers. 1193 1193 + func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType string) (*http.Request, error) { 1194 1194 + req, err := http.NewRequest("POST", url, reqBody) 1195 1195 + if err != nil { 1196 1196 + return nil, err 1197 1197 + } 1198 1198 + req = req.WithContext(ctx) 1199 1199 + if customHeader := getCustomHTTPReqHeaders(ctx); customHeader != nil { 1200 1200 + req.Header = customHeader 1201 1201 + } 1202 1202 + req.Header.Set("Accept", contentType) 1203 1203 + req.Header.Set("Content-Type", contentType) 1204 1204 + req.Header.Set("Twirp-Version", "v8.1.3") 1205 1205 + return req, nil 1206 1206 + } 1207 1207 + 1208 1208 + // JSON serialization for errors 1209 1209 + type twerrJSON struct { 1210 1210 + Code string `json:"code"` 1211 1211 + Msg string `json:"msg"` 1212 1212 + Meta map[string]string `json:"meta,omitempty"` 1213 1213 + } 1214 1214 + 1215 1215 + // marshalErrorToJSON returns JSON from a twirp.Error, that can be used as HTTP error response body. 1216 1216 + // If serialization fails, it will use a descriptive Internal error instead. 1217 1217 + func marshalErrorToJSON(twerr twirp.Error) []byte { 1218 1218 + // make sure that msg is not too large 1219 1219 + msg := twerr.Msg() 1220 1220 + if len(msg) > 1e6 { 1221 1221 + msg = msg[:1e6] 1222 1222 + } 1223 1223 + 1224 1224 + tj := twerrJSON{ 1225 1225 + Code: string(twerr.Code()), 1226 1226 + Msg: msg, 1227 1227 + Meta: twerr.MetaMap(), 1228 1228 + } 1229 1229 + 1230 1230 + buf, err := json.Marshal(&tj) 1231 1231 + if err != nil { 1232 1232 + buf = []byte("{\"type\": \"" + twirp.Internal + "\", \"msg\": \"There was an error but it could not be serialized into JSON\"}") // fallback 1233 1233 + } 1234 1234 + 1235 1235 + return buf 1236 1236 + } 1237 1237 + 1238 1238 + // errorFromResponse builds a twirp.Error from a non-200 HTTP response. 1239 1239 + // If the response has a valid serialized Twirp error, then it's returned. 1240 1240 + // If not, the response status code is used to generate a similar twirp 1241 1241 + // error. See twirpErrorFromIntermediary for more info on intermediary errors. 1242 1242 + func errorFromResponse(resp *http.Response) twirp.Error { 1243 1243 + statusCode := resp.StatusCode 1244 1244 + statusText := http.StatusText(statusCode) 1245 1245 + 1246 1246 + if isHTTPRedirect(statusCode) { 1247 1247 + // Unexpected redirect: it must be an error from an intermediary. 1248 1248 + // Twirp clients don't follow redirects automatically, Twirp only handles 1249 1249 + // POST requests, redirects should only happen on GET and HEAD requests. 1250 1250 + location := resp.Header.Get("Location") 1251 1251 + msg := fmt.Sprintf("unexpected HTTP status code %d %q received, Location=%q", statusCode, statusText, location) 1252 1252 + return twirpErrorFromIntermediary(statusCode, msg, location) 1253 1253 + } 1254 1254 + 1255 1255 + respBodyBytes, err := io.ReadAll(resp.Body) 1256 1256 + if err != nil { 1257 1257 + return wrapInternal(err, "failed to read server error response body") 1258 1258 + } 1259 1259 + 1260 1260 + var tj twerrJSON 1261 1261 + dec := json.NewDecoder(bytes.NewReader(respBodyBytes)) 1262 1262 + dec.DisallowUnknownFields() 1263 1263 + if err := dec.Decode(&tj); err != nil || tj.Code == "" { 1264 1264 + // Invalid JSON response; it must be an error from an intermediary. 1265 1265 + msg := fmt.Sprintf("Error from intermediary with HTTP status code %d %q", statusCode, statusText) 1266 1266 + return twirpErrorFromIntermediary(statusCode, msg, string(respBodyBytes)) 1267 1267 + } 1268 1268 + 1269 1269 + errorCode := twirp.ErrorCode(tj.Code) 1270 1270 + if !twirp.IsValidErrorCode(errorCode) { 1271 1271 + msg := "invalid type returned from server error response: " + tj.Code 1272 1272 + return twirp.InternalError(msg).WithMeta("body", string(respBodyBytes)) 1273 1273 + } 1274 1274 + 1275 1275 + twerr := twirp.NewError(errorCode, tj.Msg) 1276 1276 + for k, v := range tj.Meta { 1277 1277 + twerr = twerr.WithMeta(k, v) 1278 1278 + } 1279 1279 + return twerr 1280 1280 + } 1281 1281 + 1282 1282 + // twirpErrorFromIntermediary maps HTTP errors from non-twirp sources to twirp errors. 1283 1283 + // The mapping is similar to gRPC: https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md. 1284 1284 + // Returned twirp Errors have some additional metadata for inspection. 1285 1285 + func twirpErrorFromIntermediary(status int, msg string, bodyOrLocation string) twirp.Error { 1286 1286 + var code twirp.ErrorCode 1287 1287 + if isHTTPRedirect(status) { // 3xx 1288 1288 + code = twirp.Internal 1289 1289 + } else { 1290 1290 + switch status { 1291 1291 + case 400: // Bad Request 1292 1292 + code = twirp.Internal 1293 1293 + case 401: // Unauthorized 1294 1294 + code = twirp.Unauthenticated 1295 1295 + case 403: // Forbidden 1296 1296 + code = twirp.PermissionDenied 1297 1297 + case 404: // Not Found 1298 1298 + code = twirp.BadRoute 1299 1299 + case 429: // Too Many Requests 1300 1300 + code = twirp.ResourceExhausted 1301 1301 + case 502, 503, 504: // Bad Gateway, Service Unavailable, Gateway Timeout 1302 1302 + code = twirp.Unavailable 1303 1303 + default: // All other codes 1304 1304 + code = twirp.Unknown 1305 1305 + } 1306 1306 + } 1307 1307 + 1308 1308 + twerr := twirp.NewError(code, msg) 1309 1309 + twerr = twerr.WithMeta("http_error_from_intermediary", "true") // to easily know if this error was from intermediary 1310 1310 + twerr = twerr.WithMeta("status_code", strconv.Itoa(status)) 1311 1311 + if isHTTPRedirect(status) { 1312 1312 + twerr = twerr.WithMeta("location", bodyOrLocation) 1313 1313 + } else { 1314 1314 + twerr = twerr.WithMeta("body", bodyOrLocation) 1315 1315 + } 1316 1316 + return twerr 1317 1317 + } 1318 1318 + 1319 1319 + func isHTTPRedirect(status int) bool { 1320 1320 + return status >= 300 && status <= 399 1321 1321 + } 1322 1322 + 1323 1323 + // wrapInternal wraps an error with a prefix as an Internal error. 1324 1324 + // The original error cause is accessible by github.com/pkg/errors.Cause. 1325 1325 + func wrapInternal(err error, prefix string) twirp.Error { 1326 1326 + return twirp.InternalErrorWith(&wrappedError{prefix: prefix, cause: err}) 1327 1327 + } 1328 1328 + 1329 1329 + type wrappedError struct { 1330 1330 + prefix string 1331 1331 + cause error 1332 1332 + } 1333 1333 + 1334 1334 + func (e *wrappedError) Error() string { return e.prefix + ": " + e.cause.Error() } 1335 1335 + func (e *wrappedError) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As 1336 1336 + func (e *wrappedError) Cause() error { return e.cause } // for github.com/pkg/errors 1337 1337 + 1338 1338 + // ensurePanicResponses makes sure that rpc methods causing a panic still result in a Twirp Internal 1339 1339 + // error response (status 500), and error hooks are properly called with the panic wrapped as an error. 1340 1340 + // The panic is re-raised so it can be handled normally with middleware. 1341 1341 + func ensurePanicResponses(ctx context.Context, resp http.ResponseWriter, hooks *twirp.ServerHooks) { 1342 1342 + if r := recover(); r != nil { 1343 1343 + // Wrap the panic as an error so it can be passed to error hooks. 1344 1344 + // The original error is accessible from error hooks, but not visible in the response. 1345 1345 + err := errFromPanic(r) 1346 1346 + twerr := &internalWithCause{msg: "Internal service panic", cause: err} 1347 1347 + // Actually write the error 1348 1348 + writeError(ctx, resp, twerr, hooks) 1349 1349 + // If possible, flush the error to the wire. 1350 1350 + f, ok := resp.(http.Flusher) 1351 1351 + if ok { 1352 1352 + f.Flush() 1353 1353 + } 1354 1354 + 1355 1355 + panic(r) 1356 1356 + } 1357 1357 + } 1358 1358 + 1359 1359 + // errFromPanic returns the typed error if the recovered panic is an error, otherwise formats as error. 1360 1360 + func errFromPanic(p interface{}) error { 1361 1361 + if err, ok := p.(error); ok { 1362 1362 + return err 1363 1363 + } 1364 1364 + return fmt.Errorf("panic: %v", p) 1365 1365 + } 1366 1366 + 1367 1367 + // internalWithCause is a Twirp Internal error wrapping an original error cause, 1368 1368 + // but the original error message is not exposed on Msg(). The original error 1369 1369 + // can be checked with go1.13+ errors.Is/As, and also by (github.com/pkg/errors).Unwrap 1370 1370 + type internalWithCause struct { 1371 1371 + msg string 1372 1372 + cause error 1373 1373 + } 1374 1374 + 1375 1375 + func (e *internalWithCause) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As 1376 1376 + func (e *internalWithCause) Cause() error { return e.cause } // for github.com/pkg/errors 1377 1377 + func (e *internalWithCause) Error() string { return e.msg + ": " + e.cause.Error() } 1378 1378 + func (e *internalWithCause) Code() twirp.ErrorCode { return twirp.Internal } 1379 1379 + func (e *internalWithCause) Msg() string { return e.msg } 1380 1380 + func (e *internalWithCause) Meta(key string) string { return "" } 1381 1381 + func (e *internalWithCause) MetaMap() map[string]string { return nil } 1382 1382 + func (e *internalWithCause) WithMeta(key string, val string) twirp.Error { return e } 1383 1383 + 1384 1384 + // malformedRequestError is used when the twirp server cannot unmarshal a request 1385 1385 + func malformedRequestError(msg string) twirp.Error { 1386 1386 + return twirp.NewError(twirp.Malformed, msg) 1387 1387 + } 1388 1388 + 1389 1389 + // badRouteError is used when the twirp server cannot route a request 1390 1390 + func badRouteError(msg string, method, url string) twirp.Error { 1391 1391 + err := twirp.NewError(twirp.BadRoute, msg) 1392 1392 + err = err.WithMeta("twirp_invalid_route", method+" "+url) 1393 1393 + return err 1394 1394 + } 1395 1395 + 1396 1396 + // withoutRedirects makes sure that the POST request can not be redirected. 1397 1397 + // The standard library will, by default, redirect requests (including POSTs) if it gets a 302 or 1398 1398 + // 303 response, and also 301s in go1.8. It redirects by making a second request, changing the 1399 1399 + // method to GET and removing the body. This produces very confusing error messages, so instead we 1400 1400 + // set a redirect policy that always errors. This stops Go from executing the redirect. 1401 1401 + // 1402 1402 + // We have to be a little careful in case the user-provided http.Client has its own CheckRedirect 1403 1403 + // policy - if so, we'll run through that policy first. 1404 1404 + // 1405 1405 + // Because this requires modifying the http.Client, we make a new copy of the client and return it. 1406 1406 + func withoutRedirects(in *http.Client) *http.Client { 1407 1407 + copy := *in 1408 1408 + copy.CheckRedirect = func(req *http.Request, via []*http.Request) error { 1409 1409 + if in.CheckRedirect != nil { 1410 1410 + // Run the input's redirect if it exists, in case it has side effects, but ignore any error it 1411 1411 + // returns, since we want to use ErrUseLastResponse. 1412 1412 + err := in.CheckRedirect(req, via) 1413 1413 + _ = err // Silly, but this makes sure generated code passes errcheck -blank, which some people use. 1414 1414 + } 1415 1415 + return http.ErrUseLastResponse 1416 1416 + } 1417 1417 + return &copy 1418 1418 + } 1419 1419 + 1420 1420 + // doProtobufRequest makes a Protobuf request to the remote Twirp service. 1421 1421 + func doProtobufRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) { 1422 1422 + reqBodyBytes, err := proto.Marshal(in) 1423 1423 + if err != nil { 1424 1424 + return ctx, wrapInternal(err, "failed to marshal proto request") 1425 1425 + } 1426 1426 + reqBody := bytes.NewBuffer(reqBodyBytes) 1427 1427 + if err = ctx.Err(); err != nil { 1428 1428 + return ctx, wrapInternal(err, "aborted because context was done") 1429 1429 + } 1430 1430 + 1431 1431 + req, err := newRequest(ctx, url, reqBody, "application/protobuf") 1432 1432 + if err != nil { 1433 1433 + return ctx, wrapInternal(err, "could not build request") 1434 1434 + } 1435 1435 + ctx, err = callClientRequestPrepared(ctx, hooks, req) 1436 1436 + if err != nil { 1437 1437 + return ctx, err 1438 1438 + } 1439 1439 + 1440 1440 + req = req.WithContext(ctx) 1441 1441 + resp, err := client.Do(req) 1442 1442 + if err != nil { 1443 1443 + return ctx, wrapInternal(err, "failed to do request") 1444 1444 + } 1445 1445 + defer func() { _ = resp.Body.Close() }() 1446 1446 + 1447 1447 + if err = ctx.Err(); err != nil { 1448 1448 + return ctx, wrapInternal(err, "aborted because context was done") 1449 1449 + } 1450 1450 + 1451 1451 + if resp.StatusCode != 200 { 1452 1452 + return ctx, errorFromResponse(resp) 1453 1453 + } 1454 1454 + 1455 1455 + respBodyBytes, err := io.ReadAll(resp.Body) 1456 1456 + if err != nil { 1457 1457 + return ctx, wrapInternal(err, "failed to read response body") 1458 1458 + } 1459 1459 + if err = ctx.Err(); err != nil { 1460 1460 + return ctx, wrapInternal(err, "aborted because context was done") 1461 1461 + } 1462 1462 + 1463 1463 + if err = proto.Unmarshal(respBodyBytes, out); err != nil { 1464 1464 + return ctx, wrapInternal(err, "failed to unmarshal proto response") 1465 1465 + } 1466 1466 + return ctx, nil 1467 1467 + } 1468 1468 + 1469 1469 + // doJSONRequest makes a JSON request to the remote Twirp service. 1470 1470 + func doJSONRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) { 1471 1471 + marshaler := &protojson.MarshalOptions{UseProtoNames: true} 1472 1472 + reqBytes, err := marshaler.Marshal(in) 1473 1473 + if err != nil { 1474 1474 + return ctx, wrapInternal(err, "failed to marshal json request") 1475 1475 + } 1476 1476 + if err = ctx.Err(); err != nil { 1477 1477 + return ctx, wrapInternal(err, "aborted because context was done") 1478 1478 + } 1479 1479 + 1480 1480 + req, err := newRequest(ctx, url, bytes.NewReader(reqBytes), "application/json") 1481 1481 + if err != nil { 1482 1482 + return ctx, wrapInternal(err, "could not build request") 1483 1483 + } 1484 1484 + ctx, err = callClientRequestPrepared(ctx, hooks, req) 1485 1485 + if err != nil { 1486 1486 + return ctx, err 1487 1487 + } 1488 1488 + 1489 1489 + req = req.WithContext(ctx) 1490 1490 + resp, err := client.Do(req) 1491 1491 + if err != nil { 1492 1492 + return ctx, wrapInternal(err, "failed to do request") 1493 1493 + } 1494 1494 + 1495 1495 + defer func() { 1496 1496 + cerr := resp.Body.Close() 1497 1497 + if err == nil && cerr != nil { 1498 1498 + err = wrapInternal(cerr, "failed to close response body") 1499 1499 + } 1500 1500 + }() 1501 1501 + 1502 1502 + if err = ctx.Err(); err != nil { 1503 1503 + return ctx, wrapInternal(err, "aborted because context was done") 1504 1504 + } 1505 1505 + 1506 1506 + if resp.StatusCode != 200 { 1507 1507 + return ctx, errorFromResponse(resp) 1508 1508 + } 1509 1509 + 1510 1510 + d := json.NewDecoder(resp.Body) 1511 1511 + rawRespBody := json.RawMessage{} 1512 1512 + if err := d.Decode(&rawRespBody); err != nil { 1513 1513 + return ctx, wrapInternal(err, "failed to unmarshal json response") 1514 1514 + } 1515 1515 + unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true} 1516 1516 + if err = unmarshaler.Unmarshal(rawRespBody, out); err != nil { 1517 1517 + return ctx, wrapInternal(err, "failed to unmarshal json response") 1518 1518 + } 1519 1519 + if err = ctx.Err(); err != nil { 1520 1520 + return ctx, wrapInternal(err, "aborted because context was done") 1521 1521 + } 1522 1522 + return ctx, nil 1523 1523 + } 1524 1524 + 1525 1525 + // Call twirp.ServerHooks.RequestReceived if the hook is available 1526 1526 + func callRequestReceived(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) { 1527 1527 + if h == nil || h.RequestReceived == nil { 1528 1528 + return ctx, nil 1529 1529 + } 1530 1530 + return h.RequestReceived(ctx) 1531 1531 + } 1532 1532 + 1533 1533 + // Call twirp.ServerHooks.RequestRouted if the hook is available 1534 1534 + func callRequestRouted(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) { 1535 1535 + if h == nil || h.RequestRouted == nil { 1536 1536 + return ctx, nil 1537 1537 + } 1538 1538 + return h.RequestRouted(ctx) 1539 1539 + } 1540 1540 + 1541 1541 + // Call twirp.ServerHooks.ResponsePrepared if the hook is available 1542 1542 + func callResponsePrepared(ctx context.Context, h *twirp.ServerHooks) context.Context { 1543 1543 + if h == nil || h.ResponsePrepared == nil { 1544 1544 + return ctx 1545 1545 + } 1546 1546 + return h.ResponsePrepared(ctx) 1547 1547 + } 1548 1548 + 1549 1549 + // Call twirp.ServerHooks.ResponseSent if the hook is available 1550 1550 + func callResponseSent(ctx context.Context, h *twirp.ServerHooks) { 1551 1551 + if h == nil || h.ResponseSent == nil { 1552 1552 + return 1553 1553 + } 1554 1554 + h.ResponseSent(ctx) 1555 1555 + } 1556 1556 + 1557 1557 + // Call twirp.ServerHooks.Error if the hook is available 1558 1558 + func callError(ctx context.Context, h *twirp.ServerHooks, err twirp.Error) context.Context { 1559 1559 + if h == nil || h.Error == nil { 1560 1560 + return ctx 1561 1561 + } 1562 1562 + return h.Error(ctx, err) 1563 1563 + } 1564 1564 + 1565 1565 + func callClientResponseReceived(ctx context.Context, h *twirp.ClientHooks) { 1566 1566 + if h == nil || h.ResponseReceived == nil { 1567 1567 + return 1568 1568 + } 1569 1569 + h.ResponseReceived(ctx) 1570 1570 + } 1571 1571 + 1572 1572 + func callClientRequestPrepared(ctx context.Context, h *twirp.ClientHooks, req *http.Request) (context.Context, error) { 1573 1573 + if h == nil || h.RequestPrepared == nil { 1574 1574 + return ctx, nil 1575 1575 + } 1576 1576 + return h.RequestPrepared(ctx, req) 1577 1577 + } 1578 1578 + 1579 1579 + func callClientError(ctx context.Context, h *twirp.ClientHooks, err twirp.Error) { 1580 1580 + if h == nil || h.Error == nil { 1581 1581 + return 1582 1582 + } 1583 1583 + h.Error(ctx, err) 1584 1584 + } 1585 1585 + 1586 1586 + var twirpFileDescriptor0 = []byte{ 1587 1587 + // 291 bytes of a gzipped FileDescriptorProto 1588 1588 + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x3d, 0x4f, 0xc3, 0x30, 1589 1589 + 0x10, 0x86, 0x15, 0x3e, 0x5a, 0xea, 0x06, 0x86, 0x20, 0x50, 0x15, 0x04, 0xb4, 0xb0, 0x74, 0x72, 1590 1590 + 0xa4, 0xc0, 0xc0, 0xda, 0x4a, 0x15, 0x62, 0xab, 0xa2, 0x4c, 0x2c, 0x95, 0xd3, 0x5e, 0x8a, 0x45, 1591 1591 + 0x62, 0x5b, 0xf6, 0x15, 0x25, 0x3f, 0x89, 0x7f, 0x89, 0x62, 0x27, 0xa2, 0xe2, 0x63, 0xf4, 0x7b, 1592 1592 + 0xcf, 0x3d, 0x79, 0x73, 0xe4, 0x8c, 0x0b, 0x04, 0x2d, 0x58, 0x41, 0x95, 0x96, 0x28, 0x83, 0xf3, 1593 1593 + 0x0a, 0x38, 0x33, 0x92, 0x0a, 0x40, 0xda, 0x8d, 0xc2, 0xab, 0xad, 0x94, 0xdb, 0x02, 0x22, 0x8b, 1594 1594 + 0x64, 0xbb, 0x3c, 0x82, 0x52, 0x61, 0xed, 0x36, 0xc2, 0xdb, 0x9f, 0x43, 0xe4, 0x25, 0x18, 0x64, 1595 1595 + 0xa5, 0x6a, 0x01, 0xbf, 0x02, 0xc3, 0x11, 0xdc, 0xeb, 0xee, 0xd3, 0x23, 0xfe, 0x92, 0xa1, 0x06, 1596 1596 + 0x29, 0x52, 0xf9, 0x0e, 0x22, 0x98, 0x10, 0x9f, 0xad, 0xd7, 0x60, 0xcc, 0x0a, 0x9b, 0xf7, 0xc8, 1597 1597 + 0x1b, 0x7b, 0xd3, 0x41, 0x32, 0x74, 0x99, 0x43, 0xae, 0x09, 0xb1, 0xb3, 0x15, 0xd6, 0x0a, 0x46, 1598 1598 + 0x07, 0x16, 0x18, 0xd8, 0x24, 0xad, 0x15, 0x04, 0xf7, 0xe4, 0x54, 0x43, 0xae, 0xc1, 0xbc, 0xb5, 1599 1599 + 0x8a, 0x43, 0x4b, 0xf8, 0x6d, 0xe8, 0x1c, 0x31, 0xe9, 0x41, 0xa5, 0xb8, 0xae, 0x47, 0x47, 0x63, 1600 1600 + 0x6f, 0x3a, 0x8c, 0x43, 0xea, 0x7a, 0xd3, 0xae, 0x37, 0x4d, 0xbb, 0xde, 0x49, 0x4b, 0xc6, 0x4b, 1601 1601 + 0xd2, 0x6f, 0xab, 0x06, 0x0b, 0x72, 0xf2, 0x0c, 0xe8, 0x54, 0x97, 0xbf, 0x56, 0x17, 0xcd, 0x3d, 1602 1602 + 0xc2, 0x09, 0xfd, 0xe3, 0x78, 0x74, 0xff, 0x67, 0xe3, 0x19, 0x39, 0x9e, 0x6d, 0x4a, 0x2e, 0x82, 1603 1603 + 0x27, 0xd2, 0x4f, 0x20, 0xdb, 0xf1, 0x62, 0xf3, 0xaf, 0xee, 0x62, 0x5f, 0x37, 0x6f, 0xd0, 0x17, 1604 1604 + 0x91, 0xcb, 0xf9, 0xf8, 0xf5, 0xe6, 0x3b, 0x8f, 0x3e, 0x1e, 0xa3, 0xee, 0x4b, 0x11, 0x6b, 0xcc, 1605 1605 + 0x2a, 0xcb, 0x7a, 0x56, 0xf4, 0xf0, 0x15, 0x00, 0x00, 0xff, 0xff, 0x82, 0x33, 0x91, 0x6c, 0xdc, 1606 1606 + 0x01, 0x00, 0x00, 1607 1607 + }

+13 -11

internal/saasproxytoken/tokensource.go

reviewed

··· 1 1 package saasproxytoken 2 2 3 3 import ( 4 4 - "encoding/json" 4 4 + "context" 5 5 "net/http" 6 6 "sync" 7 7 "time" 8 8 9 9 "golang.org/x/oauth2" 10 10 - "within.website/x/web" 10 10 + "google.golang.org/protobuf/types/known/emptypb" 11 11 + "xeiaso.net/v4/internal/adminpb" 11 12 ) 12 13 13 14 type remoteTokenSource struct { ··· 15 16 lock sync.Mutex 16 17 remoteURL string 17 18 httpClient *http.Client 19 19 + ptc adminpb.Patreon 18 20 } 19 21 20 22 func (r *remoteTokenSource) fetchToken() (*oauth2.Token, error) { 21 21 - resp, err := r.httpClient.Get(r.remoteURL) 23 23 + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 24 24 + defer cancel() 25 25 + 26 26 + resp, err := r.ptc.GetToken(ctx, &emptypb.Empty{}) 22 27 if err != nil { 23 28 return nil, err 24 29 } 25 25 - defer resp.Body.Close() 26 26 - 27 27 - if resp.StatusCode != http.StatusOK { 28 28 - return nil, web.NewError(http.StatusOK, resp) 29 29 - } 30 30 31 31 var tok oauth2.Token 32 32 - if err := json.NewDecoder(resp.Body).Decode(&tok); err != nil { 33 33 - return nil, err 34 34 - } 32 32 + tok.AccessToken = resp.AccessToken 33 33 + tok.TokenType = resp.TokenType 34 34 + tok.RefreshToken = resp.RefreshToken 35 35 + tok.Expiry = resp.Expiry.AsTime() 35 36 36 37 return &tok, nil 37 38 } ··· 64 65 return &remoteTokenSource{ 65 66 remoteURL: remoteURL, 66 67 httpClient: httpClient, 68 68 + ptc: adminpb.NewPatreonProtobufClient(remoteURL, httpClient), 67 69 } 68 70 }

+5

pb/generate.go

reviewed

··· 1 1 + package pb 2 2 + 3 3 + func init() {} 4 4 + 5 5 + //go:generate protoc --proto_path=. --go_out=. --go_opt=paths=source_relative --twirp_out=. --twirp_opt=paths=source_relative xesite.proto

+189

pb/xesite.pb.go

reviewed

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.32.0 4 4 + // protoc v4.24.4 5 5 + // source: xesite.proto 6 6 + 7 7 + package pb 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + emptypb "google.golang.org/protobuf/types/known/emptypb" 13 13 + timestamppb "google.golang.org/protobuf/types/known/timestamppb" 14 14 + reflect "reflect" 15 15 + sync "sync" 16 16 + ) 17 17 + 18 18 + const ( 19 19 + // Verify that this generated code is sufficiently up-to-date. 20 20 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 21 21 + // Verify that runtime/protoimpl is sufficiently up-to-date. 22 22 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 23 23 + ) 24 24 + 25 25 + type BuildInfo struct { 26 26 + state protoimpl.MessageState 27 27 + sizeCache protoimpl.SizeCache 28 28 + unknownFields protoimpl.UnknownFields 29 29 + 30 30 + Commit string `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"` 31 31 + BuildTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=build_time,json=buildTime,proto3" json:"build_time,omitempty"` 32 32 + GoVersion string `protobuf:"bytes,3,opt,name=go_version,json=goVersion,proto3" json:"go_version,omitempty"` 33 33 + DenoVersion string `protobuf:"bytes,4,opt,name=deno_version,json=denoVersion,proto3" json:"deno_version,omitempty"` 34 34 + } 35 35 + 36 36 + func (x *BuildInfo) Reset() { 37 37 + *x = BuildInfo{} 38 38 + if protoimpl.UnsafeEnabled { 39 39 + mi := &file_xesite_proto_msgTypes[0] 40 40 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 41 41 + ms.StoreMessageInfo(mi) 42 42 + } 43 43 + } 44 44 + 45 45 + func (x *BuildInfo) String() string { 46 46 + return protoimpl.X.MessageStringOf(x) 47 47 + } 48 48 + 49 49 + func (*BuildInfo) ProtoMessage() {} 50 50 + 51 51 + func (x *BuildInfo) ProtoReflect() protoreflect.Message { 52 52 + mi := &file_xesite_proto_msgTypes[0] 53 53 + if protoimpl.UnsafeEnabled && x != nil { 54 54 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 55 55 + if ms.LoadMessageInfo() == nil { 56 56 + ms.StoreMessageInfo(mi) 57 57 + } 58 58 + return ms 59 59 + } 60 60 + return mi.MessageOf(x) 61 61 + } 62 62 + 63 63 + // Deprecated: Use BuildInfo.ProtoReflect.Descriptor instead. 64 64 + func (*BuildInfo) Descriptor() ([]byte, []int) { 65 65 + return file_xesite_proto_rawDescGZIP(), []int{0} 66 66 + } 67 67 + 68 68 + func (x *BuildInfo) GetCommit() string { 69 69 + if x != nil { 70 70 + return x.Commit 71 71 + } 72 72 + return "" 73 73 + } 74 74 + 75 75 + func (x *BuildInfo) GetBuildTime() *timestamppb.Timestamp { 76 76 + if x != nil { 77 77 + return x.BuildTime 78 78 + } 79 79 + return nil 80 80 + } 81 81 + 82 82 + func (x *BuildInfo) GetGoVersion() string { 83 83 + if x != nil { 84 84 + return x.GoVersion 85 85 + } 86 86 + return "" 87 87 + } 88 88 + 89 89 + func (x *BuildInfo) GetDenoVersion() string { 90 90 + if x != nil { 91 91 + return x.DenoVersion 92 92 + } 93 93 + return "" 94 94 + } 95 95 + 96 96 + var File_xesite_proto protoreflect.FileDescriptor 97 97 + 98 98 + var file_xesite_proto_rawDesc = []byte{ 99 99 + 0x0a, 0x0c, 0x78, 0x65, 0x73, 0x69, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 100 100 + 0x78, 0x65, 0x69, 0x61, 0x73, 0x6f, 0x2e, 0x6e, 0x65, 0x74, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 101 101 + 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 102 102 + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 103 103 + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 104 104 + 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa0, 0x01, 0x0a, 0x09, 0x42, 0x75, 0x69, 105 105 + 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 106 106 + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x39, 107 107 + 0x0a, 0x0a, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 108 108 + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 109 109 + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 110 110 + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x6f, 0x5f, 111 111 + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 112 112 + 0x6f, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x65, 0x6e, 0x6f, 113 113 + 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 114 114 + 0x64, 0x65, 0x6e, 0x6f, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x41, 0x0a, 0x04, 0x4c, 115 115 + 0x75, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 116 116 + 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 117 117 + 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x15, 0x2e, 0x78, 0x65, 0x69, 0x61, 0x73, 0x6f, 118 118 + 0x2e, 0x6e, 0x65, 0x74, 0x2e, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x12, 119 119 + 0x5a, 0x10, 0x78, 0x65, 0x69, 0x61, 0x73, 0x6f, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x76, 0x34, 0x2f, 120 120 + 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 121 121 + } 122 122 + 123 123 + var ( 124 124 + file_xesite_proto_rawDescOnce sync.Once 125 125 + file_xesite_proto_rawDescData = file_xesite_proto_rawDesc 126 126 + ) 127 127 + 128 128 + func file_xesite_proto_rawDescGZIP() []byte { 129 129 + file_xesite_proto_rawDescOnce.Do(func() { 130 130 + file_xesite_proto_rawDescData = protoimpl.X.CompressGZIP(file_xesite_proto_rawDescData) 131 131 + }) 132 132 + return file_xesite_proto_rawDescData 133 133 + } 134 134 + 135 135 + var file_xesite_proto_msgTypes = make([]protoimpl.MessageInfo, 1) 136 136 + var file_xesite_proto_goTypes = []interface{}{ 137 137 + (*BuildInfo)(nil), // 0: xeiaso.net.BuildInfo 138 138 + (*timestamppb.Timestamp)(nil), // 1: google.protobuf.Timestamp 139 139 + (*emptypb.Empty)(nil), // 2: google.protobuf.Empty 140 140 + } 141 141 + var file_xesite_proto_depIdxs = []int32{ 142 142 + 1, // 0: xeiaso.net.BuildInfo.build_time:type_name -> google.protobuf.Timestamp 143 143 + 2, // 1: xeiaso.net.Lume.Metadata:input_type -> google.protobuf.Empty 144 144 + 0, // 2: xeiaso.net.Lume.Metadata:output_type -> xeiaso.net.BuildInfo 145 145 + 2, // [2:3] is the sub-list for method output_type 146 146 + 1, // [1:2] is the sub-list for method input_type 147 147 + 1, // [1:1] is the sub-list for extension type_name 148 148 + 1, // [1:1] is the sub-list for extension extendee 149 149 + 0, // [0:1] is the sub-list for field type_name 150 150 + } 151 151 + 152 152 + func init() { file_xesite_proto_init() } 153 153 + func file_xesite_proto_init() { 154 154 + if File_xesite_proto != nil { 155 155 + return 156 156 + } 157 157 + if !protoimpl.UnsafeEnabled { 158 158 + file_xesite_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { 159 159 + switch v := v.(*BuildInfo); i { 160 160 + case 0: 161 161 + return &v.state 162 162 + case 1: 163 163 + return &v.sizeCache 164 164 + case 2: 165 165 + return &v.unknownFields 166 166 + default: 167 167 + return nil 168 168 + } 169 169 + } 170 170 + } 171 171 + type x struct{} 172 172 + out := protoimpl.TypeBuilder{ 173 173 + File: protoimpl.DescBuilder{ 174 174 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 175 175 + RawDescriptor: file_xesite_proto_rawDesc, 176 176 + NumEnums: 0, 177 177 + NumMessages: 1, 178 178 + NumExtensions: 0, 179 179 + NumServices: 1, 180 180 + }, 181 181 + GoTypes: file_xesite_proto_goTypes, 182 182 + DependencyIndexes: file_xesite_proto_depIdxs, 183 183 + MessageInfos: file_xesite_proto_msgTypes, 184 184 + }.Build() 185 185 + File_xesite_proto = out.File 186 186 + file_xesite_proto_rawDesc = nil 187 187 + file_xesite_proto_goTypes = nil 188 188 + file_xesite_proto_depIdxs = nil 189 189 + }

+17

pb/xesite.proto

reviewed

··· 1 1 + syntax = "proto3"; 2 2 + package xeiaso.net; 3 3 + option go_package = "xeiaso.net/v4/pb"; 4 4 + 5 5 + import "google/protobuf/empty.proto"; 6 6 + import "google/protobuf/timestamp.proto"; 7 7 + 8 8 + service Lume { 9 9 + rpc Metadata(google.protobuf.Empty) returns (BuildInfo); 10 10 + } 11 11 + 12 12 + message BuildInfo { 13 13 + string commit = 1; 14 14 + google.protobuf.Timestamp build_time = 2; 15 15 + string go_version = 3; 16 16 + string deno_version = 4; 17 17 + }

+1109

pb/xesite.twirp.go

reviewed

··· 1 1 + // Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT. 2 2 + // source: xesite.proto 3 3 + 4 4 + package pb 5 5 + 6 6 + import context "context" 7 7 + import fmt "fmt" 8 8 + import http "net/http" 9 9 + import io "io" 10 10 + import json "encoding/json" 11 11 + import strconv "strconv" 12 12 + import strings "strings" 13 13 + 14 14 + import protojson "google.golang.org/protobuf/encoding/protojson" 15 15 + import proto "google.golang.org/protobuf/proto" 16 16 + import twirp "github.com/twitchtv/twirp" 17 17 + import ctxsetters "github.com/twitchtv/twirp/ctxsetters" 18 18 + 19 19 + import google_protobuf "google.golang.org/protobuf/types/known/emptypb" 20 20 + 21 21 + import bytes "bytes" 22 22 + import errors "errors" 23 23 + import path "path" 24 24 + import url "net/url" 25 25 + 26 26 + // Version compatibility assertion. 27 27 + // If the constant is not defined in the package, that likely means 28 28 + // the package needs to be updated to work with this generated code. 29 29 + // See https://twitchtv.github.io/twirp/docs/version_matrix.html 30 30 + const _ = twirp.TwirpPackageMinVersion_8_1_0 31 31 + 32 32 + // ============== 33 33 + // Lume Interface 34 34 + // ============== 35 35 + 36 36 + type Lume interface { 37 37 + Metadata(context.Context, *google_protobuf.Empty) (*BuildInfo, error) 38 38 + } 39 39 + 40 40 + // ==================== 41 41 + // Lume Protobuf Client 42 42 + // ==================== 43 43 + 44 44 + type lumeProtobufClient struct { 45 45 + client HTTPClient 46 46 + urls [1]string 47 47 + interceptor twirp.Interceptor 48 48 + opts twirp.ClientOptions 49 49 + } 50 50 + 51 51 + // NewLumeProtobufClient creates a Protobuf client that implements the Lume interface. 52 52 + // It communicates using Protobuf and can be configured with a custom HTTPClient. 53 53 + func NewLumeProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) Lume { 54 54 + if c, ok := client.(*http.Client); ok { 55 55 + client = withoutRedirects(c) 56 56 + } 57 57 + 58 58 + clientOpts := twirp.ClientOptions{} 59 59 + for _, o := range opts { 60 60 + o(&clientOpts) 61 61 + } 62 62 + 63 63 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 64 64 + literalURLs := false 65 65 + _ = clientOpts.ReadOpt("literalURLs", &literalURLs) 66 66 + var pathPrefix string 67 67 + if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 68 68 + pathPrefix = "/twirp" // default prefix 69 69 + } 70 70 + 71 71 + // Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method> 72 72 + serviceURL := sanitizeBaseURL(baseURL) 73 73 + serviceURL += baseServicePath(pathPrefix, "xeiaso.net", "Lume") 74 74 + urls := [1]string{ 75 75 + serviceURL + "Metadata", 76 76 + } 77 77 + 78 78 + return &lumeProtobufClient{ 79 79 + client: client, 80 80 + urls: urls, 81 81 + interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...), 82 82 + opts: clientOpts, 83 83 + } 84 84 + } 85 85 + 86 86 + func (c *lumeProtobufClient) Metadata(ctx context.Context, in *google_protobuf.Empty) (*BuildInfo, error) { 87 87 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net") 88 88 + ctx = ctxsetters.WithServiceName(ctx, "Lume") 89 89 + ctx = ctxsetters.WithMethodName(ctx, "Metadata") 90 90 + caller := c.callMetadata 91 91 + if c.interceptor != nil { 92 92 + caller = func(ctx context.Context, req *google_protobuf.Empty) (*BuildInfo, error) { 93 93 + resp, err := c.interceptor( 94 94 + func(ctx context.Context, req interface{}) (interface{}, error) { 95 95 + typedReq, ok := req.(*google_protobuf.Empty) 96 96 + if !ok { 97 97 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 98 98 + } 99 99 + return c.callMetadata(ctx, typedReq) 100 100 + }, 101 101 + )(ctx, req) 102 102 + if resp != nil { 103 103 + typedResp, ok := resp.(*BuildInfo) 104 104 + if !ok { 105 105 + return nil, twirp.InternalError("failed type assertion resp.(*BuildInfo) when calling interceptor") 106 106 + } 107 107 + return typedResp, err 108 108 + } 109 109 + return nil, err 110 110 + } 111 111 + } 112 112 + return caller(ctx, in) 113 113 + } 114 114 + 115 115 + func (c *lumeProtobufClient) callMetadata(ctx context.Context, in *google_protobuf.Empty) (*BuildInfo, error) { 116 116 + out := new(BuildInfo) 117 117 + ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out) 118 118 + if err != nil { 119 119 + twerr, ok := err.(twirp.Error) 120 120 + if !ok { 121 121 + twerr = twirp.InternalErrorWith(err) 122 122 + } 123 123 + callClientError(ctx, c.opts.Hooks, twerr) 124 124 + return nil, err 125 125 + } 126 126 + 127 127 + callClientResponseReceived(ctx, c.opts.Hooks) 128 128 + 129 129 + return out, nil 130 130 + } 131 131 + 132 132 + // ================ 133 133 + // Lume JSON Client 134 134 + // ================ 135 135 + 136 136 + type lumeJSONClient struct { 137 137 + client HTTPClient 138 138 + urls [1]string 139 139 + interceptor twirp.Interceptor 140 140 + opts twirp.ClientOptions 141 141 + } 142 142 + 143 143 + // NewLumeJSONClient creates a JSON client that implements the Lume interface. 144 144 + // It communicates using JSON and can be configured with a custom HTTPClient. 145 145 + func NewLumeJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) Lume { 146 146 + if c, ok := client.(*http.Client); ok { 147 147 + client = withoutRedirects(c) 148 148 + } 149 149 + 150 150 + clientOpts := twirp.ClientOptions{} 151 151 + for _, o := range opts { 152 152 + o(&clientOpts) 153 153 + } 154 154 + 155 155 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 156 156 + literalURLs := false 157 157 + _ = clientOpts.ReadOpt("literalURLs", &literalURLs) 158 158 + var pathPrefix string 159 159 + if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 160 160 + pathPrefix = "/twirp" // default prefix 161 161 + } 162 162 + 163 163 + // Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method> 164 164 + serviceURL := sanitizeBaseURL(baseURL) 165 165 + serviceURL += baseServicePath(pathPrefix, "xeiaso.net", "Lume") 166 166 + urls := [1]string{ 167 167 + serviceURL + "Metadata", 168 168 + } 169 169 + 170 170 + return &lumeJSONClient{ 171 171 + client: client, 172 172 + urls: urls, 173 173 + interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...), 174 174 + opts: clientOpts, 175 175 + } 176 176 + } 177 177 + 178 178 + func (c *lumeJSONClient) Metadata(ctx context.Context, in *google_protobuf.Empty) (*BuildInfo, error) { 179 179 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net") 180 180 + ctx = ctxsetters.WithServiceName(ctx, "Lume") 181 181 + ctx = ctxsetters.WithMethodName(ctx, "Metadata") 182 182 + caller := c.callMetadata 183 183 + if c.interceptor != nil { 184 184 + caller = func(ctx context.Context, req *google_protobuf.Empty) (*BuildInfo, error) { 185 185 + resp, err := c.interceptor( 186 186 + func(ctx context.Context, req interface{}) (interface{}, error) { 187 187 + typedReq, ok := req.(*google_protobuf.Empty) 188 188 + if !ok { 189 189 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 190 190 + } 191 191 + return c.callMetadata(ctx, typedReq) 192 192 + }, 193 193 + )(ctx, req) 194 194 + if resp != nil { 195 195 + typedResp, ok := resp.(*BuildInfo) 196 196 + if !ok { 197 197 + return nil, twirp.InternalError("failed type assertion resp.(*BuildInfo) when calling interceptor") 198 198 + } 199 199 + return typedResp, err 200 200 + } 201 201 + return nil, err 202 202 + } 203 203 + } 204 204 + return caller(ctx, in) 205 205 + } 206 206 + 207 207 + func (c *lumeJSONClient) callMetadata(ctx context.Context, in *google_protobuf.Empty) (*BuildInfo, error) { 208 208 + out := new(BuildInfo) 209 209 + ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out) 210 210 + if err != nil { 211 211 + twerr, ok := err.(twirp.Error) 212 212 + if !ok { 213 213 + twerr = twirp.InternalErrorWith(err) 214 214 + } 215 215 + callClientError(ctx, c.opts.Hooks, twerr) 216 216 + return nil, err 217 217 + } 218 218 + 219 219 + callClientResponseReceived(ctx, c.opts.Hooks) 220 220 + 221 221 + return out, nil 222 222 + } 223 223 + 224 224 + // =================== 225 225 + // Lume Server Handler 226 226 + // =================== 227 227 + 228 228 + type lumeServer struct { 229 229 + Lume 230 230 + interceptor twirp.Interceptor 231 231 + hooks *twirp.ServerHooks 232 232 + pathPrefix string // prefix for routing 233 233 + jsonSkipDefaults bool // do not include unpopulated fields (default values) in the response 234 234 + jsonCamelCase bool // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names 235 235 + } 236 236 + 237 237 + // NewLumeServer builds a TwirpServer that can be used as an http.Handler to handle 238 238 + // HTTP requests that are routed to the right method in the provided svc implementation. 239 239 + // The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks). 240 240 + func NewLumeServer(svc Lume, opts ...interface{}) TwirpServer { 241 241 + serverOpts := newServerOpts(opts) 242 242 + 243 243 + // Using ReadOpt allows backwards and forwards compatibility with new options in the future 244 244 + jsonSkipDefaults := false 245 245 + _ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults) 246 246 + jsonCamelCase := false 247 247 + _ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase) 248 248 + var pathPrefix string 249 249 + if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok { 250 250 + pathPrefix = "/twirp" // default prefix 251 251 + } 252 252 + 253 253 + return &lumeServer{ 254 254 + Lume: svc, 255 255 + hooks: serverOpts.Hooks, 256 256 + interceptor: twirp.ChainInterceptors(serverOpts.Interceptors...), 257 257 + pathPrefix: pathPrefix, 258 258 + jsonSkipDefaults: jsonSkipDefaults, 259 259 + jsonCamelCase: jsonCamelCase, 260 260 + } 261 261 + } 262 262 + 263 263 + // writeError writes an HTTP response with a valid Twirp error format, and triggers hooks. 264 264 + // If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err) 265 265 + func (s *lumeServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) { 266 266 + writeError(ctx, resp, err, s.hooks) 267 267 + } 268 268 + 269 269 + // handleRequestBodyError is used to handle error when the twirp server cannot read request 270 270 + func (s *lumeServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) { 271 271 + if context.Canceled == ctx.Err() { 272 272 + s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled")) 273 273 + return 274 274 + } 275 275 + if context.DeadlineExceeded == ctx.Err() { 276 276 + s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded")) 277 277 + return 278 278 + } 279 279 + s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err)) 280 280 + } 281 281 + 282 282 + // LumePathPrefix is a convenience constant that may identify URL paths. 283 283 + // Should be used with caution, it only matches routes generated by Twirp Go clients, 284 284 + // with the default "/twirp" prefix and default CamelCase service and method names. 285 285 + // More info: https://twitchtv.github.io/twirp/docs/routing.html 286 286 + const LumePathPrefix = "/twirp/xeiaso.net.Lume/" 287 287 + 288 288 + func (s *lumeServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) { 289 289 + ctx := req.Context() 290 290 + ctx = ctxsetters.WithPackageName(ctx, "xeiaso.net") 291 291 + ctx = ctxsetters.WithServiceName(ctx, "Lume") 292 292 + ctx = ctxsetters.WithResponseWriter(ctx, resp) 293 293 + 294 294 + var err error 295 295 + ctx, err = callRequestReceived(ctx, s.hooks) 296 296 + if err != nil { 297 297 + s.writeError(ctx, resp, err) 298 298 + return 299 299 + } 300 300 + 301 301 + if req.Method != "POST" { 302 302 + msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method) 303 303 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 304 304 + return 305 305 + } 306 306 + 307 307 + // Verify path format: [<prefix>]/<package>.<Service>/<Method> 308 308 + prefix, pkgService, method := parseTwirpPath(req.URL.Path) 309 309 + if pkgService != "xeiaso.net.Lume" { 310 310 + msg := fmt.Sprintf("no handler for path %q", req.URL.Path) 311 311 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 312 312 + return 313 313 + } 314 314 + if prefix != s.pathPrefix { 315 315 + msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path) 316 316 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 317 317 + return 318 318 + } 319 319 + 320 320 + switch method { 321 321 + case "Metadata": 322 322 + s.serveMetadata(ctx, resp, req) 323 323 + return 324 324 + default: 325 325 + msg := fmt.Sprintf("no handler for path %q", req.URL.Path) 326 326 + s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path)) 327 327 + return 328 328 + } 329 329 + } 330 330 + 331 331 + func (s *lumeServer) serveMetadata(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 332 332 + header := req.Header.Get("Content-Type") 333 333 + i := strings.Index(header, ";") 334 334 + if i == -1 { 335 335 + i = len(header) 336 336 + } 337 337 + switch strings.TrimSpace(strings.ToLower(header[:i])) { 338 338 + case "application/json": 339 339 + s.serveMetadataJSON(ctx, resp, req) 340 340 + case "application/protobuf": 341 341 + s.serveMetadataProtobuf(ctx, resp, req) 342 342 + default: 343 343 + msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type")) 344 344 + twerr := badRouteError(msg, req.Method, req.URL.Path) 345 345 + s.writeError(ctx, resp, twerr) 346 346 + } 347 347 + } 348 348 + 349 349 + func (s *lumeServer) serveMetadataJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 350 350 + var err error 351 351 + ctx = ctxsetters.WithMethodName(ctx, "Metadata") 352 352 + ctx, err = callRequestRouted(ctx, s.hooks) 353 353 + if err != nil { 354 354 + s.writeError(ctx, resp, err) 355 355 + return 356 356 + } 357 357 + 358 358 + d := json.NewDecoder(req.Body) 359 359 + rawReqBody := json.RawMessage{} 360 360 + if err := d.Decode(&rawReqBody); err != nil { 361 361 + s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err) 362 362 + return 363 363 + } 364 364 + reqContent := new(google_protobuf.Empty) 365 365 + unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true} 366 366 + if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil { 367 367 + s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err) 368 368 + return 369 369 + } 370 370 + 371 371 + handler := s.Lume.Metadata 372 372 + if s.interceptor != nil { 373 373 + handler = func(ctx context.Context, req *google_protobuf.Empty) (*BuildInfo, error) { 374 374 + resp, err := s.interceptor( 375 375 + func(ctx context.Context, req interface{}) (interface{}, error) { 376 376 + typedReq, ok := req.(*google_protobuf.Empty) 377 377 + if !ok { 378 378 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 379 379 + } 380 380 + return s.Lume.Metadata(ctx, typedReq) 381 381 + }, 382 382 + )(ctx, req) 383 383 + if resp != nil { 384 384 + typedResp, ok := resp.(*BuildInfo) 385 385 + if !ok { 386 386 + return nil, twirp.InternalError("failed type assertion resp.(*BuildInfo) when calling interceptor") 387 387 + } 388 388 + return typedResp, err 389 389 + } 390 390 + return nil, err 391 391 + } 392 392 + } 393 393 + 394 394 + // Call service method 395 395 + var respContent *BuildInfo 396 396 + func() { 397 397 + defer ensurePanicResponses(ctx, resp, s.hooks) 398 398 + respContent, err = handler(ctx, reqContent) 399 399 + }() 400 400 + 401 401 + if err != nil { 402 402 + s.writeError(ctx, resp, err) 403 403 + return 404 404 + } 405 405 + if respContent == nil { 406 406 + s.writeError(ctx, resp, twirp.InternalError("received a nil *BuildInfo and nil error while calling Metadata. nil responses are not supported")) 407 407 + return 408 408 + } 409 409 + 410 410 + ctx = callResponsePrepared(ctx, s.hooks) 411 411 + 412 412 + marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults} 413 413 + respBytes, err := marshaler.Marshal(respContent) 414 414 + if err != nil { 415 415 + s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response")) 416 416 + return 417 417 + } 418 418 + 419 419 + ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK) 420 420 + resp.Header().Set("Content-Type", "application/json") 421 421 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes))) 422 422 + resp.WriteHeader(http.StatusOK) 423 423 + 424 424 + if n, err := resp.Write(respBytes); err != nil { 425 425 + msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error()) 426 426 + twerr := twirp.NewError(twirp.Unknown, msg) 427 427 + ctx = callError(ctx, s.hooks, twerr) 428 428 + } 429 429 + callResponseSent(ctx, s.hooks) 430 430 + } 431 431 + 432 432 + func (s *lumeServer) serveMetadataProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) { 433 433 + var err error 434 434 + ctx = ctxsetters.WithMethodName(ctx, "Metadata") 435 435 + ctx, err = callRequestRouted(ctx, s.hooks) 436 436 + if err != nil { 437 437 + s.writeError(ctx, resp, err) 438 438 + return 439 439 + } 440 440 + 441 441 + buf, err := io.ReadAll(req.Body) 442 442 + if err != nil { 443 443 + s.handleRequestBodyError(ctx, resp, "failed to read request body", err) 444 444 + return 445 445 + } 446 446 + reqContent := new(google_protobuf.Empty) 447 447 + if err = proto.Unmarshal(buf, reqContent); err != nil { 448 448 + s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded")) 449 449 + return 450 450 + } 451 451 + 452 452 + handler := s.Lume.Metadata 453 453 + if s.interceptor != nil { 454 454 + handler = func(ctx context.Context, req *google_protobuf.Empty) (*BuildInfo, error) { 455 455 + resp, err := s.interceptor( 456 456 + func(ctx context.Context, req interface{}) (interface{}, error) { 457 457 + typedReq, ok := req.(*google_protobuf.Empty) 458 458 + if !ok { 459 459 + return nil, twirp.InternalError("failed type assertion req.(*google_protobuf.Empty) when calling interceptor") 460 460 + } 461 461 + return s.Lume.Metadata(ctx, typedReq) 462 462 + }, 463 463 + )(ctx, req) 464 464 + if resp != nil { 465 465 + typedResp, ok := resp.(*BuildInfo) 466 466 + if !ok { 467 467 + return nil, twirp.InternalError("failed type assertion resp.(*BuildInfo) when calling interceptor") 468 468 + } 469 469 + return typedResp, err 470 470 + } 471 471 + return nil, err 472 472 + } 473 473 + } 474 474 + 475 475 + // Call service method 476 476 + var respContent *BuildInfo 477 477 + func() { 478 478 + defer ensurePanicResponses(ctx, resp, s.hooks) 479 479 + respContent, err = handler(ctx, reqContent) 480 480 + }() 481 481 + 482 482 + if err != nil { 483 483 + s.writeError(ctx, resp, err) 484 484 + return 485 485 + } 486 486 + if respContent == nil { 487 487 + s.writeError(ctx, resp, twirp.InternalError("received a nil *BuildInfo and nil error while calling Metadata. nil responses are not supported")) 488 488 + return 489 489 + } 490 490 + 491 491 + ctx = callResponsePrepared(ctx, s.hooks) 492 492 + 493 493 + respBytes, err := proto.Marshal(respContent) 494 494 + if err != nil { 495 495 + s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response")) 496 496 + return 497 497 + } 498 498 + 499 499 + ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK) 500 500 + resp.Header().Set("Content-Type", "application/protobuf") 501 501 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes))) 502 502 + resp.WriteHeader(http.StatusOK) 503 503 + if n, err := resp.Write(respBytes); err != nil { 504 504 + msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error()) 505 505 + twerr := twirp.NewError(twirp.Unknown, msg) 506 506 + ctx = callError(ctx, s.hooks, twerr) 507 507 + } 508 508 + callResponseSent(ctx, s.hooks) 509 509 + } 510 510 + 511 511 + func (s *lumeServer) ServiceDescriptor() ([]byte, int) { 512 512 + return twirpFileDescriptor0, 0 513 513 + } 514 514 + 515 515 + func (s *lumeServer) ProtocGenTwirpVersion() string { 516 516 + return "v8.1.3" 517 517 + } 518 518 + 519 519 + // PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/" 520 520 + // that is everything in a Twirp route except for the <Method>. This can be used for routing, 521 521 + // for example to identify the requests that are targeted to this service in a mux. 522 522 + func (s *lumeServer) PathPrefix() string { 523 523 + return baseServicePath(s.pathPrefix, "xeiaso.net", "Lume") 524 524 + } 525 525 + 526 526 + // ===== 527 527 + // Utils 528 528 + // ===== 529 529 + 530 530 + // HTTPClient is the interface used by generated clients to send HTTP requests. 531 531 + // It is fulfilled by *(net/http).Client, which is sufficient for most users. 532 532 + // Users can provide their own implementation for special retry policies. 533 533 + // 534 534 + // HTTPClient implementations should not follow redirects. Redirects are 535 535 + // automatically disabled if *(net/http).Client is passed to client 536 536 + // constructors. See the withoutRedirects function in this file for more 537 537 + // details. 538 538 + type HTTPClient interface { 539 539 + Do(req *http.Request) (*http.Response, error) 540 540 + } 541 541 + 542 542 + // TwirpServer is the interface generated server structs will support: they're 543 543 + // HTTP handlers with additional methods for accessing metadata about the 544 544 + // service. Those accessors are a low-level API for building reflection tools. 545 545 + // Most people can think of TwirpServers as just http.Handlers. 546 546 + type TwirpServer interface { 547 547 + http.Handler 548 548 + 549 549 + // ServiceDescriptor returns gzipped bytes describing the .proto file that 550 550 + // this service was generated from. Once unzipped, the bytes can be 551 551 + // unmarshalled as a 552 552 + // google.golang.org/protobuf/types/descriptorpb.FileDescriptorProto. 553 553 + // 554 554 + // The returned integer is the index of this particular service within that 555 555 + // FileDescriptorProto's 'Service' slice of ServiceDescriptorProtos. This is a 556 556 + // low-level field, expected to be used for reflection. 557 557 + ServiceDescriptor() ([]byte, int) 558 558 + 559 559 + // ProtocGenTwirpVersion is the semantic version string of the version of 560 560 + // twirp used to generate this file. 561 561 + ProtocGenTwirpVersion() string 562 562 + 563 563 + // PathPrefix returns the HTTP URL path prefix for all methods handled by this 564 564 + // service. This can be used with an HTTP mux to route Twirp requests. 565 565 + // The path prefix is in the form: "/<prefix>/<package>.<Service>/" 566 566 + // that is, everything in a Twirp route except for the <Method> at the end. 567 567 + PathPrefix() string 568 568 + } 569 569 + 570 570 + func newServerOpts(opts []interface{}) *twirp.ServerOptions { 571 571 + serverOpts := &twirp.ServerOptions{} 572 572 + for _, opt := range opts { 573 573 + switch o := opt.(type) { 574 574 + case twirp.ServerOption: 575 575 + o(serverOpts) 576 576 + case *twirp.ServerHooks: // backwards compatibility, allow to specify hooks as an argument 577 577 + twirp.WithServerHooks(o)(serverOpts) 578 578 + case nil: // backwards compatibility, allow nil value for the argument 579 579 + continue 580 580 + default: 581 581 + panic(fmt.Sprintf("Invalid option type %T, please use a twirp.ServerOption", o)) 582 582 + } 583 583 + } 584 584 + return serverOpts 585 585 + } 586 586 + 587 587 + // WriteError writes an HTTP response with a valid Twirp error format (code, msg, meta). 588 588 + // Useful outside of the Twirp server (e.g. http middleware), but does not trigger hooks. 589 589 + // If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err) 590 590 + func WriteError(resp http.ResponseWriter, err error) { 591 591 + writeError(context.Background(), resp, err, nil) 592 592 + } 593 593 + 594 594 + // writeError writes Twirp errors in the response and triggers hooks. 595 595 + func writeError(ctx context.Context, resp http.ResponseWriter, err error, hooks *twirp.ServerHooks) { 596 596 + // Convert to a twirp.Error. Non-twirp errors are converted to internal errors. 597 597 + var twerr twirp.Error 598 598 + if !errors.As(err, &twerr) { 599 599 + twerr = twirp.InternalErrorWith(err) 600 600 + } 601 601 + 602 602 + statusCode := twirp.ServerHTTPStatusFromErrorCode(twerr.Code()) 603 603 + ctx = ctxsetters.WithStatusCode(ctx, statusCode) 604 604 + ctx = callError(ctx, hooks, twerr) 605 605 + 606 606 + respBody := marshalErrorToJSON(twerr) 607 607 + 608 608 + resp.Header().Set("Content-Type", "application/json") // Error responses are always JSON 609 609 + resp.Header().Set("Content-Length", strconv.Itoa(len(respBody))) 610 610 + resp.WriteHeader(statusCode) // set HTTP status code and send response 611 611 + 612 612 + _, writeErr := resp.Write(respBody) 613 613 + if writeErr != nil { 614 614 + // We have three options here. We could log the error, call the Error 615 615 + // hook, or just silently ignore the error. 616 616 + // 617 617 + // Logging is unacceptable because we don't have a user-controlled 618 618 + // logger; writing out to stderr without permission is too rude. 619 619 + // 620 620 + // Calling the Error hook would confuse users: it would mean the Error 621 621 + // hook got called twice for one request, which is likely to lead to 622 622 + // duplicated log messages and metrics, no matter how well we document 623 623 + // the behavior. 624 624 + // 625 625 + // Silently ignoring the error is our least-bad option. It's highly 626 626 + // likely that the connection is broken and the original 'err' says 627 627 + // so anyway. 628 628 + _ = writeErr 629 629 + } 630 630 + 631 631 + callResponseSent(ctx, hooks) 632 632 + } 633 633 + 634 634 + // sanitizeBaseURL parses the the baseURL, and adds the "http" scheme if needed. 635 635 + // If the URL is unparsable, the baseURL is returned unchanged. 636 636 + func sanitizeBaseURL(baseURL string) string { 637 637 + u, err := url.Parse(baseURL) 638 638 + if err != nil { 639 639 + return baseURL // invalid URL will fail later when making requests 640 640 + } 641 641 + if u.Scheme == "" { 642 642 + u.Scheme = "http" 643 643 + } 644 644 + return u.String() 645 645 + } 646 646 + 647 647 + // baseServicePath composes the path prefix for the service (without <Method>). 648 648 + // e.g.: baseServicePath("/twirp", "my.pkg", "MyService") 649 649 + // 650 650 + // returns => "/twirp/my.pkg.MyService/" 651 651 + // 652 652 + // e.g.: baseServicePath("", "", "MyService") 653 653 + // 654 654 + // returns => "/MyService/" 655 655 + func baseServicePath(prefix, pkg, service string) string { 656 656 + fullServiceName := service 657 657 + if pkg != "" { 658 658 + fullServiceName = pkg + "." + service 659 659 + } 660 660 + return path.Join("/", prefix, fullServiceName) + "/" 661 661 + } 662 662 + 663 663 + // parseTwirpPath extracts path components form a valid Twirp route. 664 664 + // Expected format: "[<prefix>]/<package>.<Service>/<Method>" 665 665 + // e.g.: prefix, pkgService, method := parseTwirpPath("/twirp/pkg.Svc/MakeHat") 666 666 + func parseTwirpPath(path string) (string, string, string) { 667 667 + parts := strings.Split(path, "/") 668 668 + if len(parts) < 2 { 669 669 + return "", "", "" 670 670 + } 671 671 + method := parts[len(parts)-1] 672 672 + pkgService := parts[len(parts)-2] 673 673 + prefix := strings.Join(parts[0:len(parts)-2], "/") 674 674 + return prefix, pkgService, method 675 675 + } 676 676 + 677 677 + // getCustomHTTPReqHeaders retrieves a copy of any headers that are set in 678 678 + // a context through the twirp.WithHTTPRequestHeaders function. 679 679 + // If there are no headers set, or if they have the wrong type, nil is returned. 680 680 + func getCustomHTTPReqHeaders(ctx context.Context) http.Header { 681 681 + header, ok := twirp.HTTPRequestHeaders(ctx) 682 682 + if !ok || header == nil { 683 683 + return nil 684 684 + } 685 685 + copied := make(http.Header) 686 686 + for k, vv := range header { 687 687 + if vv == nil { 688 688 + copied[k] = nil 689 689 + continue 690 690 + } 691 691 + copied[k] = make([]string, len(vv)) 692 692 + copy(copied[k], vv) 693 693 + } 694 694 + return copied 695 695 + } 696 696 + 697 697 + // newRequest makes an http.Request from a client, adding common headers. 698 698 + func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType string) (*http.Request, error) { 699 699 + req, err := http.NewRequest("POST", url, reqBody) 700 700 + if err != nil { 701 701 + return nil, err 702 702 + } 703 703 + req = req.WithContext(ctx) 704 704 + if customHeader := getCustomHTTPReqHeaders(ctx); customHeader != nil { 705 705 + req.Header = customHeader 706 706 + } 707 707 + req.Header.Set("Accept", contentType) 708 708 + req.Header.Set("Content-Type", contentType) 709 709 + req.Header.Set("Twirp-Version", "v8.1.3") 710 710 + return req, nil 711 711 + } 712 712 + 713 713 + // JSON serialization for errors 714 714 + type twerrJSON struct { 715 715 + Code string `json:"code"` 716 716 + Msg string `json:"msg"` 717 717 + Meta map[string]string `json:"meta,omitempty"` 718 718 + } 719 719 + 720 720 + // marshalErrorToJSON returns JSON from a twirp.Error, that can be used as HTTP error response body. 721 721 + // If serialization fails, it will use a descriptive Internal error instead. 722 722 + func marshalErrorToJSON(twerr twirp.Error) []byte { 723 723 + // make sure that msg is not too large 724 724 + msg := twerr.Msg() 725 725 + if len(msg) > 1e6 { 726 726 + msg = msg[:1e6] 727 727 + } 728 728 + 729 729 + tj := twerrJSON{ 730 730 + Code: string(twerr.Code()), 731 731 + Msg: msg, 732 732 + Meta: twerr.MetaMap(), 733 733 + } 734 734 + 735 735 + buf, err := json.Marshal(&tj) 736 736 + if err != nil { 737 737 + buf = []byte("{\"type\": \"" + twirp.Internal + "\", \"msg\": \"There was an error but it could not be serialized into JSON\"}") // fallback 738 738 + } 739 739 + 740 740 + return buf 741 741 + } 742 742 + 743 743 + // errorFromResponse builds a twirp.Error from a non-200 HTTP response. 744 744 + // If the response has a valid serialized Twirp error, then it's returned. 745 745 + // If not, the response status code is used to generate a similar twirp 746 746 + // error. See twirpErrorFromIntermediary for more info on intermediary errors. 747 747 + func errorFromResponse(resp *http.Response) twirp.Error { 748 748 + statusCode := resp.StatusCode 749 749 + statusText := http.StatusText(statusCode) 750 750 + 751 751 + if isHTTPRedirect(statusCode) { 752 752 + // Unexpected redirect: it must be an error from an intermediary. 753 753 + // Twirp clients don't follow redirects automatically, Twirp only handles 754 754 + // POST requests, redirects should only happen on GET and HEAD requests. 755 755 + location := resp.Header.Get("Location") 756 756 + msg := fmt.Sprintf("unexpected HTTP status code %d %q received, Location=%q", statusCode, statusText, location) 757 757 + return twirpErrorFromIntermediary(statusCode, msg, location) 758 758 + } 759 759 + 760 760 + respBodyBytes, err := io.ReadAll(resp.Body) 761 761 + if err != nil { 762 762 + return wrapInternal(err, "failed to read server error response body") 763 763 + } 764 764 + 765 765 + var tj twerrJSON 766 766 + dec := json.NewDecoder(bytes.NewReader(respBodyBytes)) 767 767 + dec.DisallowUnknownFields() 768 768 + if err := dec.Decode(&tj); err != nil || tj.Code == "" { 769 769 + // Invalid JSON response; it must be an error from an intermediary. 770 770 + msg := fmt.Sprintf("Error from intermediary with HTTP status code %d %q", statusCode, statusText) 771 771 + return twirpErrorFromIntermediary(statusCode, msg, string(respBodyBytes)) 772 772 + } 773 773 + 774 774 + errorCode := twirp.ErrorCode(tj.Code) 775 775 + if !twirp.IsValidErrorCode(errorCode) { 776 776 + msg := "invalid type returned from server error response: " + tj.Code 777 777 + return twirp.InternalError(msg).WithMeta("body", string(respBodyBytes)) 778 778 + } 779 779 + 780 780 + twerr := twirp.NewError(errorCode, tj.Msg) 781 781 + for k, v := range tj.Meta { 782 782 + twerr = twerr.WithMeta(k, v) 783 783 + } 784 784 + return twerr 785 785 + } 786 786 + 787 787 + // twirpErrorFromIntermediary maps HTTP errors from non-twirp sources to twirp errors. 788 788 + // The mapping is similar to gRPC: https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md. 789 789 + // Returned twirp Errors have some additional metadata for inspection. 790 790 + func twirpErrorFromIntermediary(status int, msg string, bodyOrLocation string) twirp.Error { 791 791 + var code twirp.ErrorCode 792 792 + if isHTTPRedirect(status) { // 3xx 793 793 + code = twirp.Internal 794 794 + } else { 795 795 + switch status { 796 796 + case 400: // Bad Request 797 797 + code = twirp.Internal 798 798 + case 401: // Unauthorized 799 799 + code = twirp.Unauthenticated 800 800 + case 403: // Forbidden 801 801 + code = twirp.PermissionDenied 802 802 + case 404: // Not Found 803 803 + code = twirp.BadRoute 804 804 + case 429: // Too Many Requests 805 805 + code = twirp.ResourceExhausted 806 806 + case 502, 503, 504: // Bad Gateway, Service Unavailable, Gateway Timeout 807 807 + code = twirp.Unavailable 808 808 + default: // All other codes 809 809 + code = twirp.Unknown 810 810 + } 811 811 + } 812 812 + 813 813 + twerr := twirp.NewError(code, msg) 814 814 + twerr = twerr.WithMeta("http_error_from_intermediary", "true") // to easily know if this error was from intermediary 815 815 + twerr = twerr.WithMeta("status_code", strconv.Itoa(status)) 816 816 + if isHTTPRedirect(status) { 817 817 + twerr = twerr.WithMeta("location", bodyOrLocation) 818 818 + } else { 819 819 + twerr = twerr.WithMeta("body", bodyOrLocation) 820 820 + } 821 821 + return twerr 822 822 + } 823 823 + 824 824 + func isHTTPRedirect(status int) bool { 825 825 + return status >= 300 && status <= 399 826 826 + } 827 827 + 828 828 + // wrapInternal wraps an error with a prefix as an Internal error. 829 829 + // The original error cause is accessible by github.com/pkg/errors.Cause. 830 830 + func wrapInternal(err error, prefix string) twirp.Error { 831 831 + return twirp.InternalErrorWith(&wrappedError{prefix: prefix, cause: err}) 832 832 + } 833 833 + 834 834 + type wrappedError struct { 835 835 + prefix string 836 836 + cause error 837 837 + } 838 838 + 839 839 + func (e *wrappedError) Error() string { return e.prefix + ": " + e.cause.Error() } 840 840 + func (e *wrappedError) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As 841 841 + func (e *wrappedError) Cause() error { return e.cause } // for github.com/pkg/errors 842 842 + 843 843 + // ensurePanicResponses makes sure that rpc methods causing a panic still result in a Twirp Internal 844 844 + // error response (status 500), and error hooks are properly called with the panic wrapped as an error. 845 845 + // The panic is re-raised so it can be handled normally with middleware. 846 846 + func ensurePanicResponses(ctx context.Context, resp http.ResponseWriter, hooks *twirp.ServerHooks) { 847 847 + if r := recover(); r != nil { 848 848 + // Wrap the panic as an error so it can be passed to error hooks. 849 849 + // The original error is accessible from error hooks, but not visible in the response. 850 850 + err := errFromPanic(r) 851 851 + twerr := &internalWithCause{msg: "Internal service panic", cause: err} 852 852 + // Actually write the error 853 853 + writeError(ctx, resp, twerr, hooks) 854 854 + // If possible, flush the error to the wire. 855 855 + f, ok := resp.(http.Flusher) 856 856 + if ok { 857 857 + f.Flush() 858 858 + } 859 859 + 860 860 + panic(r) 861 861 + } 862 862 + } 863 863 + 864 864 + // errFromPanic returns the typed error if the recovered panic is an error, otherwise formats as error. 865 865 + func errFromPanic(p interface{}) error { 866 866 + if err, ok := p.(error); ok { 867 867 + return err 868 868 + } 869 869 + return fmt.Errorf("panic: %v", p) 870 870 + } 871 871 + 872 872 + // internalWithCause is a Twirp Internal error wrapping an original error cause, 873 873 + // but the original error message is not exposed on Msg(). The original error 874 874 + // can be checked with go1.13+ errors.Is/As, and also by (github.com/pkg/errors).Unwrap 875 875 + type internalWithCause struct { 876 876 + msg string 877 877 + cause error 878 878 + } 879 879 + 880 880 + func (e *internalWithCause) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As 881 881 + func (e *internalWithCause) Cause() error { return e.cause } // for github.com/pkg/errors 882 882 + func (e *internalWithCause) Error() string { return e.msg + ": " + e.cause.Error() } 883 883 + func (e *internalWithCause) Code() twirp.ErrorCode { return twirp.Internal } 884 884 + func (e *internalWithCause) Msg() string { return e.msg } 885 885 + func (e *internalWithCause) Meta(key string) string { return "" } 886 886 + func (e *internalWithCause) MetaMap() map[string]string { return nil } 887 887 + func (e *internalWithCause) WithMeta(key string, val string) twirp.Error { return e } 888 888 + 889 889 + // malformedRequestError is used when the twirp server cannot unmarshal a request 890 890 + func malformedRequestError(msg string) twirp.Error { 891 891 + return twirp.NewError(twirp.Malformed, msg) 892 892 + } 893 893 + 894 894 + // badRouteError is used when the twirp server cannot route a request 895 895 + func badRouteError(msg string, method, url string) twirp.Error { 896 896 + err := twirp.NewError(twirp.BadRoute, msg) 897 897 + err = err.WithMeta("twirp_invalid_route", method+" "+url) 898 898 + return err 899 899 + } 900 900 + 901 901 + // withoutRedirects makes sure that the POST request can not be redirected. 902 902 + // The standard library will, by default, redirect requests (including POSTs) if it gets a 302 or 903 903 + // 303 response, and also 301s in go1.8. It redirects by making a second request, changing the 904 904 + // method to GET and removing the body. This produces very confusing error messages, so instead we 905 905 + // set a redirect policy that always errors. This stops Go from executing the redirect. 906 906 + // 907 907 + // We have to be a little careful in case the user-provided http.Client has its own CheckRedirect 908 908 + // policy - if so, we'll run through that policy first. 909 909 + // 910 910 + // Because this requires modifying the http.Client, we make a new copy of the client and return it. 911 911 + func withoutRedirects(in *http.Client) *http.Client { 912 912 + copy := *in 913 913 + copy.CheckRedirect = func(req *http.Request, via []*http.Request) error { 914 914 + if in.CheckRedirect != nil { 915 915 + // Run the input's redirect if it exists, in case it has side effects, but ignore any error it 916 916 + // returns, since we want to use ErrUseLastResponse. 917 917 + err := in.CheckRedirect(req, via) 918 918 + _ = err // Silly, but this makes sure generated code passes errcheck -blank, which some people use. 919 919 + } 920 920 + return http.ErrUseLastResponse 921 921 + } 922 922 + return &copy 923 923 + } 924 924 + 925 925 + // doProtobufRequest makes a Protobuf request to the remote Twirp service. 926 926 + func doProtobufRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) { 927 927 + reqBodyBytes, err := proto.Marshal(in) 928 928 + if err != nil { 929 929 + return ctx, wrapInternal(err, "failed to marshal proto request") 930 930 + } 931 931 + reqBody := bytes.NewBuffer(reqBodyBytes) 932 932 + if err = ctx.Err(); err != nil { 933 933 + return ctx, wrapInternal(err, "aborted because context was done") 934 934 + } 935 935 + 936 936 + req, err := newRequest(ctx, url, reqBody, "application/protobuf") 937 937 + if err != nil { 938 938 + return ctx, wrapInternal(err, "could not build request") 939 939 + } 940 940 + ctx, err = callClientRequestPrepared(ctx, hooks, req) 941 941 + if err != nil { 942 942 + return ctx, err 943 943 + } 944 944 + 945 945 + req = req.WithContext(ctx) 946 946 + resp, err := client.Do(req) 947 947 + if err != nil { 948 948 + return ctx, wrapInternal(err, "failed to do request") 949 949 + } 950 950 + defer func() { _ = resp.Body.Close() }() 951 951 + 952 952 + if err = ctx.Err(); err != nil { 953 953 + return ctx, wrapInternal(err, "aborted because context was done") 954 954 + } 955 955 + 956 956 + if resp.StatusCode != 200 { 957 957 + return ctx, errorFromResponse(resp) 958 958 + } 959 959 + 960 960 + respBodyBytes, err := io.ReadAll(resp.Body) 961 961 + if err != nil { 962 962 + return ctx, wrapInternal(err, "failed to read response body") 963 963 + } 964 964 + if err = ctx.Err(); err != nil { 965 965 + return ctx, wrapInternal(err, "aborted because context was done") 966 966 + } 967 967 + 968 968 + if err = proto.Unmarshal(respBodyBytes, out); err != nil { 969 969 + return ctx, wrapInternal(err, "failed to unmarshal proto response") 970 970 + } 971 971 + return ctx, nil 972 972 + } 973 973 + 974 974 + // doJSONRequest makes a JSON request to the remote Twirp service. 975 975 + func doJSONRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) { 976 976 + marshaler := &protojson.MarshalOptions{UseProtoNames: true} 977 977 + reqBytes, err := marshaler.Marshal(in) 978 978 + if err != nil { 979 979 + return ctx, wrapInternal(err, "failed to marshal json request") 980 980 + } 981 981 + if err = ctx.Err(); err != nil { 982 982 + return ctx, wrapInternal(err, "aborted because context was done") 983 983 + } 984 984 + 985 985 + req, err := newRequest(ctx, url, bytes.NewReader(reqBytes), "application/json") 986 986 + if err != nil { 987 987 + return ctx, wrapInternal(err, "could not build request") 988 988 + } 989 989 + ctx, err = callClientRequestPrepared(ctx, hooks, req) 990 990 + if err != nil { 991 991 + return ctx, err 992 992 + } 993 993 + 994 994 + req = req.WithContext(ctx) 995 995 + resp, err := client.Do(req) 996 996 + if err != nil { 997 997 + return ctx, wrapInternal(err, "failed to do request") 998 998 + } 999 999 + 1000 1000 + defer func() { 1001 1001 + cerr := resp.Body.Close() 1002 1002 + if err == nil && cerr != nil { 1003 1003 + err = wrapInternal(cerr, "failed to close response body") 1004 1004 + } 1005 1005 + }() 1006 1006 + 1007 1007 + if err = ctx.Err(); err != nil { 1008 1008 + return ctx, wrapInternal(err, "aborted because context was done") 1009 1009 + } 1010 1010 + 1011 1011 + if resp.StatusCode != 200 { 1012 1012 + return ctx, errorFromResponse(resp) 1013 1013 + } 1014 1014 + 1015 1015 + d := json.NewDecoder(resp.Body) 1016 1016 + rawRespBody := json.RawMessage{} 1017 1017 + if err := d.Decode(&rawRespBody); err != nil { 1018 1018 + return ctx, wrapInternal(err, "failed to unmarshal json response") 1019 1019 + } 1020 1020 + unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true} 1021 1021 + if err = unmarshaler.Unmarshal(rawRespBody, out); err != nil { 1022 1022 + return ctx, wrapInternal(err, "failed to unmarshal json response") 1023 1023 + } 1024 1024 + if err = ctx.Err(); err != nil { 1025 1025 + return ctx, wrapInternal(err, "aborted because context was done") 1026 1026 + } 1027 1027 + return ctx, nil 1028 1028 + } 1029 1029 + 1030 1030 + // Call twirp.ServerHooks.RequestReceived if the hook is available 1031 1031 + func callRequestReceived(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) { 1032 1032 + if h == nil || h.RequestReceived == nil { 1033 1033 + return ctx, nil 1034 1034 + } 1035 1035 + return h.RequestReceived(ctx) 1036 1036 + } 1037 1037 + 1038 1038 + // Call twirp.ServerHooks.RequestRouted if the hook is available 1039 1039 + func callRequestRouted(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) { 1040 1040 + if h == nil || h.RequestRouted == nil { 1041 1041 + return ctx, nil 1042 1042 + } 1043 1043 + return h.RequestRouted(ctx) 1044 1044 + } 1045 1045 + 1046 1046 + // Call twirp.ServerHooks.ResponsePrepared if the hook is available 1047 1047 + func callResponsePrepared(ctx context.Context, h *twirp.ServerHooks) context.Context { 1048 1048 + if h == nil || h.ResponsePrepared == nil { 1049 1049 + return ctx 1050 1050 + } 1051 1051 + return h.ResponsePrepared(ctx) 1052 1052 + } 1053 1053 + 1054 1054 + // Call twirp.ServerHooks.ResponseSent if the hook is available 1055 1055 + func callResponseSent(ctx context.Context, h *twirp.ServerHooks) { 1056 1056 + if h == nil || h.ResponseSent == nil { 1057 1057 + return 1058 1058 + } 1059 1059 + h.ResponseSent(ctx) 1060 1060 + } 1061 1061 + 1062 1062 + // Call twirp.ServerHooks.Error if the hook is available 1063 1063 + func callError(ctx context.Context, h *twirp.ServerHooks, err twirp.Error) context.Context { 1064 1064 + if h == nil || h.Error == nil { 1065 1065 + return ctx 1066 1066 + } 1067 1067 + return h.Error(ctx, err) 1068 1068 + } 1069 1069 + 1070 1070 + func callClientResponseReceived(ctx context.Context, h *twirp.ClientHooks) { 1071 1071 + if h == nil || h.ResponseReceived == nil { 1072 1072 + return 1073 1073 + } 1074 1074 + h.ResponseReceived(ctx) 1075 1075 + } 1076 1076 + 1077 1077 + func callClientRequestPrepared(ctx context.Context, h *twirp.ClientHooks, req *http.Request) (context.Context, error) { 1078 1078 + if h == nil || h.RequestPrepared == nil { 1079 1079 + return ctx, nil 1080 1080 + } 1081 1081 + return h.RequestPrepared(ctx, req) 1082 1082 + } 1083 1083 + 1084 1084 + func callClientError(ctx context.Context, h *twirp.ClientHooks, err twirp.Error) { 1085 1085 + if h == nil || h.Error == nil { 1086 1086 + return 1087 1087 + } 1088 1088 + h.Error(ctx, err) 1089 1089 + } 1090 1090 + 1091 1091 + var twirpFileDescriptor0 = []byte{ 1092 1092 + // 246 bytes of a gzipped FileDescriptorProto 1093 1093 + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xc1, 0x4a, 0xc3, 0x40, 1094 1094 + 0x10, 0x86, 0x89, 0x96, 0x62, 0xa6, 0x3d, 0xc8, 0x80, 0x25, 0x44, 0xc4, 0xea, 0xa9, 0xa7, 0x0d, 1095 1095 + 0x54, 0x2f, 0x3d, 0x5a, 0xf0, 0x20, 0xe8, 0xa5, 0x88, 0x07, 0x2f, 0x65, 0x63, 0xa6, 0x61, 0xa1, 1096 1096 + 0x9b, 0x09, 0xcd, 0xa4, 0xd4, 0xb7, 0xf1, 0x51, 0x65, 0x77, 0x1b, 0x03, 0xf6, 0x38, 0xff, 0x7c, 1097 1097 + 0xf3, 0x2d, 0xff, 0xc2, 0xf8, 0x40, 0x8d, 0x11, 0x52, 0xf5, 0x8e, 0x85, 0x11, 0x0e, 0x64, 0x74, 1098 1098 + 0xc3, 0xaa, 0x22, 0x49, 0xaf, 0x4b, 0xe6, 0x72, 0x4b, 0x99, 0xdf, 0xe4, 0xed, 0x26, 0x23, 0x5b, 1099 1099 + 0xcb, 0x77, 0x00, 0xd3, 0xdb, 0xff, 0x4b, 0x31, 0x96, 0x1a, 0xd1, 0xb6, 0x0e, 0xc0, 0xfd, 0x4f, 1100 1100 + 0x04, 0xf1, 0xb2, 0x35, 0xdb, 0xe2, 0xa5, 0xda, 0x30, 0x4e, 0x60, 0xf8, 0xc5, 0xd6, 0x1a, 0x49, 1101 1101 + 0xa2, 0x69, 0x34, 0x8b, 0x57, 0xc7, 0x09, 0x17, 0x00, 0xb9, 0x83, 0xd6, 0xee, 0x3c, 0x39, 0x9b, 1102 1102 + 0x46, 0xb3, 0xd1, 0x3c, 0x55, 0xc1, 0xad, 0x3a, 0xb7, 0x7a, 0xef, 0xdc, 0xab, 0xd8, 0xd3, 0x6e, 1103 1103 + 0xc6, 0x1b, 0x80, 0x92, 0xd7, 0x7b, 0xda, 0x35, 0x86, 0xab, 0xe4, 0xdc, 0x6b, 0xe3, 0x92, 0x3f, 1104 1104 + 0x42, 0x80, 0x77, 0x30, 0x2e, 0xa8, 0xea, 0x81, 0x81, 0x07, 0x46, 0x2e, 0x3b, 0x22, 0xf3, 0x27, 1105 1105 + 0x18, 0xbc, 0xb6, 0x96, 0x70, 0x01, 0x17, 0x6f, 0x24, 0xba, 0xd0, 0xa2, 0x71, 0x72, 0xf2, 0xf8, 1106 1106 + 0xb3, 0x6b, 0x9d, 0x5e, 0xa9, 0xfe, 0x67, 0xd4, 0x5f, 0xaf, 0x25, 0x7e, 0x5e, 0xf6, 0x79, 0xb6, 1107 1107 + 0x7f, 0xcc, 0xea, 0x3c, 0x1f, 0xfa, 0xd3, 0x87, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x93, 0x4b, 1108 1108 + 0xaa, 0x5a, 0x5a, 0x01, 0x00, 0x00, 1109 1109 + }